diff --git a/g10/card-util.c b/g10/card-util.c
index 36f096f06..e79e9e508 100644
--- a/g10/card-util.c
+++ b/g10/card-util.c
@@ -1,2553 +1,2561 @@
 /* card-util.c - Utility functions for the OpenPGP card.
  * Copyright (C) 2003-2005, 2009 Free Software Foundation, Inc.
  * Copyright (C) 2003-2005, 2009 Werner Koch
  *
  * 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>
 #ifdef HAVE_LIBREADLINE
 # define GNUPG_LIBREADLINE_H_INCLUDED
 # include <readline/readline.h>
 #endif /*HAVE_LIBREADLINE*/
 
 #if GNUPG_MAJOR_VERSION != 1
 # include "gpg.h"
 #endif /*GNUPG_MAJOR_VERSION != 1*/
 #include "../common/util.h"
 #include "../common/i18n.h"
 #include "../common/ttyio.h"
 #include "../common/status.h"
 #include "options.h"
 #include "main.h"
 #include "keyserver-internal.h"
 
 #if GNUPG_MAJOR_VERSION == 1
 # include "cardglue.h"
 #else /*GNUPG_MAJOR_VERSION!=1*/
 # include "call-agent.h"
 #endif /*GNUPG_MAJOR_VERSION!=1*/
 
 #define CONTROL_D ('D' - 'A' + 1)
 
 
 static void
 write_sc_op_status (gpg_error_t err)
 {
   switch (gpg_err_code (err))
     {
     case 0:
       write_status (STATUS_SC_OP_SUCCESS);
       break;
 #if GNUPG_MAJOR_VERSION != 1
     case GPG_ERR_CANCELED:
     case GPG_ERR_FULLY_CANCELED:
       write_status_text (STATUS_SC_OP_FAILURE, "1");
       break;
     case GPG_ERR_BAD_PIN:
       write_status_text (STATUS_SC_OP_FAILURE, "2");
       break;
     default:
       write_status (STATUS_SC_OP_FAILURE);
       break;
 #endif /* GNUPG_MAJOR_VERSION != 1 */
     }
 }
 
 
 /* Change the PIN of an OpenPGP card.  This is an interactive
    function. */
 void
 change_pin (int unblock_v2, int allow_admin)
 {
   struct agent_card_info_s info;
   int rc;
 
   rc = agent_scd_learn (&info, 0);
   if (rc)
     {
       log_error (_("OpenPGP card not available: %s\n"),
                   gpg_strerror (rc));
       return;
     }
 
   log_info (_("OpenPGP card no. %s detected\n"),
               info.serialno? info.serialno : "[none]");
 
   if (opt.batch)
     {
       agent_release_card_info (&info);
       log_error (_("can't do this in batch mode\n"));
       return;
     }
 
 
   if (unblock_v2)
     {
       if (!info.is_v2)
         log_error (_("This command is only available for version 2 cards\n"));
       else if (!info.chvretry[1])
         log_error (_("Reset Code not or not anymore available\n"));
       else
         {
           rc = agent_scd_change_pin (2, info.serialno);
           write_sc_op_status (rc);
           if (rc)
             tty_printf ("Error changing the PIN: %s\n", gpg_strerror (rc));
           else
             tty_printf ("PIN changed.\n");
         }
     }
   else if (!allow_admin)
     {
       rc = agent_scd_change_pin (1, info.serialno);
       write_sc_op_status (rc);
       if (rc)
 	tty_printf ("Error changing the PIN: %s\n", gpg_strerror (rc));
       else
         tty_printf ("PIN changed.\n");
     }
   else
     for (;;)
       {
 	char *answer;
 
 	tty_printf ("\n");
 	tty_printf ("1 - change PIN\n"
 		    "2 - unblock PIN\n"
 		    "3 - change Admin PIN\n"
                     "4 - set the Reset Code\n"
 		    "Q - quit\n");
 	tty_printf ("\n");
 
 	answer = cpr_get("cardutil.change_pin.menu",_("Your selection? "));
 	cpr_kill_prompt();
 	if (strlen (answer) != 1)
-	  continue;
+          {
+            xfree (answer);
+            continue;
+          }
 
 	if (*answer == '1')
 	  {
             /* Change PIN.  */
 	    rc = agent_scd_change_pin (1, info.serialno);
             write_sc_op_status (rc);
 	    if (rc)
 	      tty_printf ("Error changing the PIN: %s\n", gpg_strerror (rc));
 	    else
               tty_printf ("PIN changed.\n");
 	  }
 	else if (*answer == '2')
 	  {
             /* Unblock PIN.  */
 	    rc = agent_scd_change_pin (101, info.serialno);
             write_sc_op_status (rc);
 	    if (rc)
 	      tty_printf ("Error unblocking the PIN: %s\n", gpg_strerror (rc));
 	    else
               tty_printf ("PIN unblocked and new PIN set.\n");
           }
 	else if (*answer == '3')
 	  {
             /* Change Admin PIN.  */
 	    rc = agent_scd_change_pin (3, info.serialno);
             write_sc_op_status (rc);
 	    if (rc)
 	      tty_printf ("Error changing the PIN: %s\n", gpg_strerror (rc));
 	    else
               tty_printf ("PIN changed.\n");
 	  }
 	else if (*answer == '4')
 	  {
             /* Set a new Reset Code.  */
 	    rc = agent_scd_change_pin (102, info.serialno);
             write_sc_op_status (rc);
 	    if (rc)
 	      tty_printf ("Error setting the Reset Code: %s\n",
                           gpg_strerror (rc));
 	    else
               tty_printf ("Reset Code set.\n");
 	  }
 	else if (*answer == 'q' || *answer == 'Q')
 	  {
+            xfree (answer);
 	    break;
 	  }
+        xfree (answer);
       }
 
   agent_release_card_info (&info);
 }
 
 
 static void
 print_shax_fpr (estream_t fp, const unsigned char *fpr, unsigned int fprlen)
 {
   int i;
 
   if (fpr)
     {
       /* FIXME: Fix formatting for FPRLEN != 20 */
       for (i=0; i < fprlen ; i+=2, fpr += 2 )
         {
           if (i == 10 )
             tty_fprintf (fp, " ");
           tty_fprintf (fp, " %02X%02X", *fpr, fpr[1]);
         }
     }
   else
     tty_fprintf (fp, " [none]");
   tty_fprintf (fp, "\n");
 }
 
 
 static void
 print_shax_fpr_colon (estream_t fp,
                       const unsigned char *fpr, unsigned int fprlen)
 {
   int i;
 
   if (fpr)
     {
       for (i=0; i < fprlen ; i++, fpr++)
         es_fprintf (fp, "%02X", *fpr);
     }
   es_putc (':', fp);
 }
 
 
 static void
 print_keygrip (estream_t fp, const unsigned char *grp)
 {
   int i;
 
   if (opt.with_keygrip)
     {
       tty_fprintf (fp, "      keygrip ....: ");
       for (i=0; i < 20 ; i++, grp++)
         tty_fprintf (fp, "%02X", *grp);
       tty_fprintf (fp, "\n");
     }
 }
 
 
 static void
 print_name (estream_t fp, const char *text, const char *name)
 {
   tty_fprintf (fp, "%s", text);
 
   /* FIXME: tty_printf_utf8_string2 eats everything after and
      including an @ - e.g. when printing an url. */
   if (name && *name)
     {
       if (fp)
         print_utf8_buffer2 (fp, name, strlen (name), '\n');
       else
         tty_print_utf8_string2 (NULL, name, strlen (name), 0);
     }
   else
     tty_fprintf (fp, _("[not set]"));
   tty_fprintf (fp, "\n");
 }
 
 static void
 print_isoname (estream_t fp, const char *text,
                const char *tag, const char *name)
 {
   if (opt.with_colons)
     es_fprintf (fp, "%s:", tag);
   else
     tty_fprintf (fp, "%s", text);
 
   if (name && *name)
     {
       char *p, *given, *buf = xstrdup (name);
 
       given = strstr (buf, "<<");
       for (p=buf; *p; p++)
         if (*p == '<')
           *p = ' ';
       if (given && given[2])
         {
           *given = 0;
           given += 2;
           if (opt.with_colons)
             es_write_sanitized (fp, given, strlen (given), ":", NULL);
           else if (fp)
             print_utf8_buffer2 (fp, given, strlen (given), '\n');
           else
             tty_print_utf8_string2 (NULL, given, strlen (given), 0);
 
           if (opt.with_colons)
             es_putc (':', fp);
           else if (*buf)
             tty_fprintf (fp, " ");
         }
 
       if (opt.with_colons)
         es_write_sanitized (fp, buf, strlen (buf), ":", NULL);
       else if (fp)
         print_utf8_buffer2 (fp, buf, strlen (buf), '\n');
       else
         tty_print_utf8_string2 (NULL, buf, strlen (buf), 0);
       xfree (buf);
     }
   else
     {
       if (opt.with_colons)
         es_putc (':', fp);
       else
         tty_fprintf (fp, _("[not set]"));
     }
 
   if (opt.with_colons)
     es_fputs (":\n", fp);
   else
     tty_fprintf (fp, "\n");
 }
 
 /* Return true if the SHA1 fingerprint FPR consists only of zeroes. */
 static int
 fpr_is_zero (const char *fpr, unsigned int fprlen)
 {
   int i;
 
   for (i=0; i < fprlen && !fpr[i]; i++)
     ;
   return (i == fprlen);
 }
 
 
 /* Return true if the fingerprint FPR consists only of 0xFF. */
 static int
 fpr_is_ff (const char *fpr, unsigned int fprlen)
 {
   int i;
 
   for (i=0; i < fprlen && fpr[i] == '\xff'; i++)
     ;
   return (i == fprlen);
 }
 
 
 /* Print all available information about the current card. */
 static void
 current_card_status (ctrl_t ctrl, estream_t fp,
                      char *serialno, size_t serialnobuflen)
 {
   struct agent_card_info_s info;
   PKT_public_key *pk = xcalloc (1, sizeof *pk);
   kbnode_t keyblock = NULL;
   int rc;
   unsigned int uval;
   const unsigned char *thefpr;
   unsigned int thefprlen;
   int i;
   char *pesc;
 
   if (serialno && serialnobuflen)
     *serialno = 0;
 
   rc = agent_scd_learn (&info, 0);
   if (rc)
     {
       if (opt.with_colons)
         es_fputs ("AID:::\n", fp);
       log_error (_("OpenPGP card not available: %s\n"), gpg_strerror (rc));
       xfree (pk);
       return;
     }
 
   if (opt.with_colons)
     es_fprintf (fp, "Reader:%s:", info.reader? info.reader : "");
   else
     tty_fprintf (fp, "Reader ...........: %s\n",
                  info.reader? info.reader : "[none]");
   if (opt.with_colons)
     es_fprintf (fp, "AID:%s:", info.serialno? info.serialno : "");
   else
     tty_fprintf (fp, "Application ID ...: %s\n",
                  info.serialno? info.serialno : "[none]");
   if (!info.serialno || strncmp (info.serialno, "D27600012401", 12)
       || strlen (info.serialno) != 32 )
     {
       const char *name1, *name2;
       if (info.apptype && !strcmp (info.apptype, "openpgp"))
         goto openpgp;
       else if (info.apptype && !strcmp (info.apptype, "NKS"))
         {
           name1 = "netkey";
           name2 = "NetKey";
         }
       else if (info.apptype && !strcmp (info.apptype, "DINSIG"))
         {
           name1 = "dinsig";
           name2 = "DINSIG";
         }
       else if (info.apptype && !strcmp (info.apptype, "P15"))
         {
           name1 = "pkcs15";
           name2 = "PKCS#15";
         }
       else if (info.apptype && !strcmp (info.apptype, "GELDKARTE"))
         {
           name1 = "geldkarte";
           name2 = "Geldkarte";
         }
       else if (info.apptype && !strcmp (info.apptype, "PIV"))
         {
           name1 = "piv";
           name2 = "PIV";
         }
       else
         {
           name1 = "unknown";
           name2 = "Unknown";
         }
 
       if (opt.with_colons)
         es_fprintf (fp, "%s-card:\n", name1);
       else
         tty_fprintf (fp, "Application type .: %s\n", name2);
 
       agent_release_card_info (&info);
       xfree (pk);
       return;
     }
  openpgp:
   if (!serialno)
     ;
   else if (strlen (info.serialno)+1 > serialnobuflen)
     log_error ("serial number longer than expected\n");
   else
     strcpy (serialno, info.serialno);
 
   if (opt.with_colons)
     es_fputs ("openpgp-card:\n", fp);
   else
     tty_fprintf (fp, "Application type .: %s\n", "OpenPGP");
 
 
   if (opt.with_colons)
     {
       es_fprintf (fp, "version:%.4s:\n", info.serialno+12);
       uval = xtoi_2(info.serialno+16)*256 + xtoi_2 (info.serialno+18);
       pesc = (info.manufacturer_name
               ? percent_escape (info.manufacturer_name, NULL) : NULL);
       es_fprintf (fp, "vendor:%04x:%s:\n", uval, pesc? pesc:"");
       xfree (pesc);
       es_fprintf (fp, "serial:%.8s:\n", info.serialno+20);
 
       print_isoname (fp, "Name of cardholder: ", "name", info.disp_name);
 
       es_fputs ("lang:", fp);
       if (info.disp_lang)
         es_write_sanitized (fp, info.disp_lang, strlen (info.disp_lang),
                             ":", NULL);
       es_fputs (":\n", fp);
 
       es_fprintf (fp, "sex:%c:\n", (info.disp_sex == 1? 'm':
                                  info.disp_sex == 2? 'f' : 'u'));
 
       es_fputs ("url:", fp);
       if (info.pubkey_url)
         es_write_sanitized (fp, info.pubkey_url, strlen (info.pubkey_url),
                             ":", NULL);
       es_fputs (":\n", fp);
 
       es_fputs ("login:", fp);
       if (info.login_data)
         es_write_sanitized (fp, info.login_data, strlen (info.login_data),
                             ":", NULL);
       es_fputs (":\n", fp);
 
       es_fprintf (fp, "forcepin:%d:::\n", !info.chv1_cached);
       for (i=0; i < DIM (info.key_attr); i++)
         if (info.key_attr[i].algo == PUBKEY_ALGO_RSA)
           es_fprintf (fp, "keyattr:%d:%d:%u:\n", i+1,
                       info.key_attr[i].algo, info.key_attr[i].nbits);
         else if (info.key_attr[i].algo == PUBKEY_ALGO_ECDH
                  || info.key_attr[i].algo == PUBKEY_ALGO_ECDSA
                  || info.key_attr[i].algo == PUBKEY_ALGO_EDDSA)
           es_fprintf (fp, "keyattr:%d:%d:%s:\n", i+1,
                       info.key_attr[i].algo, info.key_attr[i].curve);
       es_fprintf (fp, "maxpinlen:%d:%d:%d:\n",
                   info.chvmaxlen[0], info.chvmaxlen[1], info.chvmaxlen[2]);
       es_fprintf (fp, "pinretry:%d:%d:%d:\n",
                   info.chvretry[0], info.chvretry[1], info.chvretry[2]);
       es_fprintf (fp, "sigcount:%lu:::\n", info.sig_counter);
       if (info.extcap.kdf)
         {
           const char *setup;
 
           if (info.kdf_do_enabled == 0)
             setup = "off";
           else if (info.kdf_do_enabled == 1)
             setup = "single";
           else
             setup = "on";
 
           es_fprintf (fp, "kdf:%s:\n", setup);
         }
       if (info.extcap.bt)
         {
           es_fprintf (fp, "uif:%d:%d:%d:\n",
                       info.uif[0], info.uif[1], info.uif[2]);
         }
 
       for (i=0; i < 4; i++)
         {
           if (info.private_do[i])
             {
               es_fprintf (fp, "private_do:%d:", i+1);
               es_write_sanitized (fp, info.private_do[i],
                                   strlen (info.private_do[i]), ":", NULL);
               es_fputs (":\n", fp);
             }
         }
 
       es_fputs ("cafpr:", fp);
       print_shax_fpr_colon (fp, info.cafpr1len? info.cafpr1:NULL,
                             info.cafpr2len);
       print_shax_fpr_colon (fp, info.cafpr2len? info.cafpr2:NULL,
                             info.cafpr2len);
       print_shax_fpr_colon (fp, info.cafpr3len? info.cafpr3:NULL,
                             info.cafpr3len);
       es_putc ('\n', fp);
       es_fputs ("fpr:", fp);
       print_shax_fpr_colon (fp, info.fpr1len? info.fpr1:NULL, info.fpr1len);
       print_shax_fpr_colon (fp, info.fpr2len? info.fpr2:NULL, info.fpr2len);
       print_shax_fpr_colon (fp, info.fpr3len? info.fpr3:NULL, info.fpr3len);
       es_putc ('\n', fp);
       es_fprintf (fp, "fprtime:%lu:%lu:%lu:\n",
                (unsigned long)info.fpr1time, (unsigned long)info.fpr2time,
                (unsigned long)info.fpr3time);
       es_fputs ("grp:", fp);
       print_shax_fpr_colon (fp, info.grp1, sizeof info.grp1);
       print_shax_fpr_colon (fp, info.grp2, sizeof info.grp2);
       print_shax_fpr_colon (fp, info.grp3, sizeof info.grp3);
       es_putc ('\n', fp);
     }
   else
     {
       tty_fprintf (fp, "Version ..........: %.1s%c.%.1s%c\n",
                    info.serialno[12] == '0'?"":info.serialno+12,
                    info.serialno[13],
                    info.serialno[14] == '0'?"":info.serialno+14,
                    info.serialno[15]);
       tty_fprintf (fp, "Manufacturer .....: %s\n",
                    info.manufacturer_name? info.manufacturer_name : "?");
       tty_fprintf (fp, "Serial number ....: %.8s\n", info.serialno+20);
 
       print_isoname (fp, "Name of cardholder: ", "name", info.disp_name);
       print_name (fp, "Language prefs ...: ", info.disp_lang);
       tty_fprintf (fp, "Salutation .......: %s\n",
                    info.disp_sex == 1? _("Mr."):
                    info.disp_sex == 2? _("Ms.") : "");
       print_name (fp, "URL of public key : ", info.pubkey_url);
       print_name (fp, "Login data .......: ", info.login_data);
       if (info.private_do[0])
         print_name (fp, "Private DO 1 .....: ", info.private_do[0]);
       if (info.private_do[1])
         print_name (fp, "Private DO 2 .....: ", info.private_do[1]);
       if (info.private_do[2])
         print_name (fp, "Private DO 3 .....: ", info.private_do[2]);
       if (info.private_do[3])
         print_name (fp, "Private DO 4 .....: ", info.private_do[3]);
       if (info.cafpr1len)
         {
           tty_fprintf (fp, "CA fingerprint %d .:", 1);
           print_shax_fpr (fp, info.cafpr1, info.cafpr1len);
         }
       if (info.cafpr2len)
         {
           tty_fprintf (fp, "CA fingerprint %d .:", 2);
           print_shax_fpr (fp, info.cafpr2, info.cafpr2len);
         }
       if (info.cafpr3len)
         {
           tty_fprintf (fp, "CA fingerprint %d .:", 3);
           print_shax_fpr (fp, info.cafpr3, info.cafpr3len);
         }
       tty_fprintf (fp,    "Signature PIN ....: %s\n",
                    info.chv1_cached? _("not forced"): _("forced"));
       if (info.key_attr[0].algo)
         {
           tty_fprintf (fp,    "Key attributes ...:");
           for (i=0; i < DIM (info.key_attr); i++)
             if (info.key_attr[i].algo == PUBKEY_ALGO_RSA)
               tty_fprintf (fp, " rsa%u", info.key_attr[i].nbits);
             else if (info.key_attr[i].algo == PUBKEY_ALGO_ECDH
                      || info.key_attr[i].algo == PUBKEY_ALGO_ECDSA
                      || info.key_attr[i].algo == PUBKEY_ALGO_EDDSA)
               {
                 const char *curve_for_print = "?";
 
                 if (info.key_attr[i].curve)
                   {
                     const char *oid;
                     oid = openpgp_curve_to_oid (info.key_attr[i].curve,
                                                 NULL, NULL);
                     if (oid)
                       curve_for_print = openpgp_oid_to_curve (oid, 0);
                   }
                 tty_fprintf (fp, " %s", curve_for_print);
               }
           tty_fprintf (fp, "\n");
         }
       tty_fprintf (fp,    "Max. PIN lengths .: %d %d %d\n",
                    info.chvmaxlen[0], info.chvmaxlen[1], info.chvmaxlen[2]);
       tty_fprintf (fp,    "PIN retry counter : %d %d %d\n",
                    info.chvretry[0], info.chvretry[1], info.chvretry[2]);
       tty_fprintf (fp,    "Signature counter : %lu\n", info.sig_counter);
       if (info.extcap.kdf)
         {
           const char *setup;
 
           if (info.kdf_do_enabled == 0)
             setup = "off";
           else if (info.kdf_do_enabled == 1)
             setup = "single";
           else
             setup = "on";
 
           tty_fprintf (fp, "KDF setting ......: %s\n", setup);
         }
       if (info.extcap.bt)
         {
           tty_fprintf (fp, "UIF setting ......: Sign=%s Decrypt=%s Auth=%s\n",
                        info.uif[0] ? "on" : "off", info.uif[1] ? "on" : "off",
                        info.uif[2] ? "on" : "off");
         }
       tty_fprintf (fp, "Signature key ....:");
       print_shax_fpr (fp, info.fpr1len? info.fpr1:NULL, info.fpr1len);
       if (info.fpr1len && info.fpr1time)
         {
           tty_fprintf (fp, "      created ....: %s\n",
                        isotimestamp (info.fpr1time));
           print_keygrip (fp, info.grp1);
         }
       tty_fprintf (fp, "Encryption key....:");
       print_shax_fpr (fp, info.fpr2len? info.fpr2:NULL, info.fpr2len);
       if (info.fpr2len && info.fpr2time)
         {
           tty_fprintf (fp, "      created ....: %s\n",
                        isotimestamp (info.fpr2time));
           print_keygrip (fp, info.grp2);
         }
       tty_fprintf (fp, "Authentication key:");
       print_shax_fpr (fp, info.fpr3len? info.fpr3:NULL, info.fpr3len);
       if (info.fpr3len && info.fpr3time)
         {
           tty_fprintf (fp, "      created ....: %s\n",
                        isotimestamp (info.fpr3time));
           print_keygrip (fp, info.grp3);
         }
       tty_fprintf (fp, "General key info..: ");
 
       thefpr = (info.fpr1len? info.fpr1 : info.fpr2len? info.fpr2 :
                 info.fpr3len? info.fpr3 : NULL);
       thefprlen = (info.fpr1len? info.fpr1len : info.fpr2len? info.fpr2len :
                    info.fpr3len? info.fpr3len : 0);
       /* If the fingerprint is all 0xff, the key has no associated
          OpenPGP certificate.  */
       if ( thefpr && !fpr_is_ff (thefpr, thefprlen)
            && !get_pubkey_byfprint (ctrl, pk, &keyblock, thefpr, thefprlen))
         {
           print_key_info (ctrl, fp, 0, pk, 0);
           print_card_key_info (fp, keyblock);
         }
       else
         tty_fprintf (fp, "[none]\n");
     }
 
   release_kbnode (keyblock);
   free_public_key (pk);
   agent_release_card_info (&info);
 }
 
 
 /* Print all available information for specific card with SERIALNO.
    Print all available information for current card when SERIALNO is NULL.
    Or print for all cards when SERIALNO is "all".  */
 void
 card_status (ctrl_t ctrl, estream_t fp, const char *serialno)
 {
   int err;
   strlist_t card_list, sl;
   char *serialno0 = NULL;
   int all_cards = 0;
   int any_card = 0;
 
   if (serialno == NULL)
     {
       current_card_status (ctrl, fp, NULL, 0);
       return;
     }
 
   if (!strcmp (serialno, "all"))
     all_cards = 1;
 
   err = agent_scd_serialno (&serialno0, NULL);
   if (err)
     {
       if (gpg_err_code (err) != GPG_ERR_ENODEV && opt.verbose)
         log_info (_("error getting serial number of card: %s\n"),
                   gpg_strerror (err));
       /* Nothing available.  */
       return;
     }
 
   err = agent_scd_cardlist (&card_list);
 
   for (sl = card_list; sl; sl = sl->next)
     {
       if (!all_cards && strcmp (serialno, sl->d))
         continue;
 
       if (any_card && !opt.with_colons)
         tty_fprintf (fp, "\n");
       any_card = 1;
 
       err = agent_scd_serialno (NULL, sl->d);
       if (err)
         {
           if (opt.verbose)
             log_info (_("error getting serial number of card: %s\n"),
                       gpg_strerror (err));
           continue;
         }
 
       current_card_status (ctrl, fp, NULL, 0);
 
       if (!all_cards)
         goto leave;
     }
 
   /* Select the original card again.  */
   err = agent_scd_serialno (NULL, serialno0);
 
  leave:
   xfree (serialno0);
   free_strlist (card_list);
 }
 
 
 static char *
 get_one_name (const char *prompt1, const char *prompt2)
 {
   char *name;
   int i;
 
   for (;;)
     {
       name = cpr_get (prompt1, prompt2);
       if (!name)
         return NULL;
       trim_spaces (name);
       cpr_kill_prompt ();
       for (i=0; name[i] && name[i] >= ' ' && name[i] <= 126; i++)
         ;
 
       /* The name must be in Latin-1 and not UTF-8 - lacking the code
          to ensure this we restrict it to ASCII. */
       if (name[i])
         tty_printf (_("Error: Only plain ASCII is currently allowed.\n"));
       else if (strchr (name, '<'))
         tty_printf (_("Error: The \"<\" character may not be used.\n"));
       else if (strstr (name, "  "))
         tty_printf (_("Error: Double spaces are not allowed.\n"));
       else
         return name;
       xfree (name);
     }
 }
 
 
 
 static int
 change_name (void)
 {
   char *surname = NULL, *givenname = NULL;
   char *isoname, *p;
   int rc;
 
   surname = get_one_name ("keygen.smartcard.surname",
                                     _("Cardholder's surname: "));
   givenname = get_one_name ("keygen.smartcard.givenname",
                                        _("Cardholder's given name: "));
   if (!surname || !givenname || (!*surname && !*givenname))
     {
       xfree (surname);
       xfree (givenname);
       return -1; /*canceled*/
     }
 
   isoname = xmalloc ( strlen (surname) + 2 + strlen (givenname) + 1);
   strcpy (stpcpy (stpcpy (isoname, surname), "<<"), givenname);
   xfree (surname);
   xfree (givenname);
   for (p=isoname; *p; p++)
     if (*p == ' ')
       *p = '<';
 
   if (strlen (isoname) > 39 )
     {
       tty_printf (_("Error: Combined name too long "
                     "(limit is %d characters).\n"), 39);
       xfree (isoname);
       return -1;
     }
 
   rc = agent_scd_setattr ("DISP-NAME", isoname, strlen (isoname));
   if (rc)
     log_error ("error setting Name: %s\n", gpg_strerror (rc));
 
   xfree (isoname);
   return rc;
 }
 
 
 static int
 change_url (void)
 {
   char *url;
   int rc;
 
   url = cpr_get ("cardedit.change_url", _("URL to retrieve public key: "));
   if (!url)
     return -1;
   trim_spaces (url);
   cpr_kill_prompt ();
 
   rc = agent_scd_setattr ("PUBKEY-URL", url, strlen (url));
   if (rc)
     log_error ("error setting URL: %s\n", gpg_strerror (rc));
   xfree (url);
   write_sc_op_status (rc);
   return rc;
 }
 
 
 /* Fetch the key from the URL given on the card or try to get it from
    the default keyserver.  */
 static int
 fetch_url (ctrl_t ctrl)
 {
   int rc;
   struct agent_card_info_s info;
 
   memset(&info,0,sizeof(info));
 
   rc=agent_scd_getattr("PUBKEY-URL",&info);
   if(rc)
     log_error("error retrieving URL from card: %s\n",gpg_strerror(rc));
   else
     {
       rc=agent_scd_getattr("KEY-FPR",&info);
       if(rc)
 	log_error("error retrieving key fingerprint from card: %s\n",
 		  gpg_strerror(rc));
       else if (info.pubkey_url && *info.pubkey_url)
         {
           strlist_t sl = NULL;
 
           add_to_strlist (&sl, info.pubkey_url);
           rc = keyserver_fetch (ctrl, sl, KEYORG_URL);
           free_strlist (sl);
         }
       else if (info.fpr1len)
 	{
           rc = keyserver_import_fprint (ctrl, info.fpr1, info.fpr1len,
                                         opt.keyserver, 0);
 	}
     }
 
   agent_release_card_info (&info);
   return rc;
 }
 
 
 #define MAX_GET_DATA_FROM_FILE 16384
 
 /* Read data from file FNAME up to MAX_GET_DATA_FROM_FILE characters.
    On error return -1 and store NULL at R_BUFFER; on success return
    the number of bytes read and store the address of a newly allocated
    buffer at R_BUFFER. */
 static int
 get_data_from_file (const char *fname, char **r_buffer)
 {
   estream_t fp;
   char *data;
   int n;
 
   *r_buffer = NULL;
 
   fp = es_fopen (fname, "rb");
 #if GNUPG_MAJOR_VERSION == 1
   if (fp && is_secured_file (fileno (fp)))
     {
       fclose (fp);
       fp = NULL;
       errno = EPERM;
     }
 #endif
   if (!fp)
     {
       tty_printf (_("can't open '%s': %s\n"), fname, strerror (errno));
       return -1;
     }
 
   data = xtrymalloc (MAX_GET_DATA_FROM_FILE);
   if (!data)
     {
       tty_printf (_("error allocating enough memory: %s\n"), strerror (errno));
       es_fclose (fp);
       return -1;
     }
 
   n = es_fread (data, 1, MAX_GET_DATA_FROM_FILE, fp);
   es_fclose (fp);
   if (n < 0)
     {
       tty_printf (_("error reading '%s': %s\n"), fname, strerror (errno));
       xfree (data);
       return -1;
     }
   *r_buffer = data;
   return n;
 }
 
 
 /* Write LENGTH bytes from BUFFER to file FNAME.  Return 0 on
    success.  */
 static int
 put_data_to_file (const char *fname, const void *buffer, size_t length)
 {
   estream_t fp;
 
   fp = es_fopen (fname, "wb");
 #if GNUPG_MAJOR_VERSION == 1
   if (fp && is_secured_file (fileno (fp)))
     {
       fclose (fp);
       fp = NULL;
       errno = EPERM;
     }
 #endif
   if (!fp)
     {
       tty_printf (_("can't create '%s': %s\n"), fname, strerror (errno));
       return -1;
     }
 
   if (length && es_fwrite (buffer, length, 1, fp) != 1)
     {
       tty_printf (_("error writing '%s': %s\n"), fname, strerror (errno));
       es_fclose (fp);
       return -1;
     }
   es_fclose (fp);
   return 0;
 }
 
 
 static int
 change_login (const char *args)
 {
   char *data;
   int n;
   int rc;
 
   if (args && *args == '<')  /* Read it from a file */
     {
       for (args++; spacep (args); args++)
         ;
       n = get_data_from_file (args, &data);
       if (n < 0)
         return -1;
     }
   else
     {
       data = cpr_get ("cardedit.change_login",
                       _("Login data (account name): "));
       if (!data)
         return -1;
       trim_spaces (data);
       cpr_kill_prompt ();
       n = strlen (data);
     }
 
   rc = agent_scd_setattr ("LOGIN-DATA", data, n);
   if (rc)
     log_error ("error setting login data: %s\n", gpg_strerror (rc));
   xfree (data);
   write_sc_op_status (rc);
   return rc;
 }
 
 static int
 change_private_do (const char *args, int nr)
 {
   char do_name[] = "PRIVATE-DO-X";
   char *data;
   int n;
   int rc;
 
   log_assert (nr >= 1 && nr <= 4);
   do_name[11] = '0' + nr;
 
   if (args && (args = strchr (args, '<')))  /* Read it from a file */
     {
       for (args++; spacep (args); args++)
         ;
       n = get_data_from_file (args, &data);
       if (n < 0)
         return -1;
     }
   else
     {
       data = cpr_get ("cardedit.change_private_do",
                       _("Private DO data: "));
       if (!data)
         return -1;
       trim_spaces (data);
       cpr_kill_prompt ();
       n = strlen (data);
     }
 
   rc = agent_scd_setattr (do_name, data, n);
   if (rc)
     log_error ("error setting private DO: %s\n", gpg_strerror (rc));
   xfree (data);
   write_sc_op_status (rc);
   return rc;
 }
 
 
 static int
 change_cert (const char *args)
 {
   char *data;
   int n;
   int rc;
 
   if (args && *args == '<')  /* Read it from a file */
     {
       for (args++; spacep (args); args++)
         ;
       n = get_data_from_file (args, &data);
       if (n < 0)
         return -1;
     }
   else
     {
       tty_printf ("usage error: redirection to file required\n");
       return -1;
     }
 
   rc = agent_scd_writecert ("OPENPGP.3", data, n);
   if (rc)
     log_error ("error writing certificate to card: %s\n", gpg_strerror (rc));
   xfree (data);
   write_sc_op_status (rc);
   return rc;
 }
 
 
 static int
 read_cert (const char *args)
 {
   const char *fname;
   void *buffer;
   size_t length;
   int rc;
 
   if (args && *args == '>')  /* Write it to a file */
     {
       for (args++; spacep (args); args++)
         ;
       fname = args;
     }
   else
     {
       tty_printf ("usage error: redirection to file required\n");
       return -1;
     }
 
   rc = agent_scd_readcert ("OPENPGP.3", &buffer, &length);
   if (rc)
     log_error ("error reading certificate from card: %s\n", gpg_strerror (rc));
   else
     rc = put_data_to_file (fname, buffer, length);
   xfree (buffer);
   write_sc_op_status (rc);
   return rc;
 }
 
 
 static int
 change_lang (void)
 {
   char *data, *p;
   int rc;
 
   data = cpr_get ("cardedit.change_lang",
                   _("Language preferences: "));
   if (!data)
     return -1;
   trim_spaces (data);
   cpr_kill_prompt ();
 
   if (strlen (data) > 8 || (strlen (data) & 1))
     {
       tty_printf (_("Error: invalid length of preference string.\n"));
       xfree (data);
       return -1;
     }
 
   for (p=data; *p && *p >= 'a' && *p <= 'z'; p++)
     ;
   if (*p)
     {
       tty_printf (_("Error: invalid characters in preference string.\n"));
       xfree (data);
       return -1;
     }
 
   rc = agent_scd_setattr ("DISP-LANG", data, strlen (data));
   if (rc)
     log_error ("error setting lang: %s\n", gpg_strerror (rc));
   xfree (data);
   write_sc_op_status (rc);
   return rc;
 }
 
 
 static int
 change_sex (void)
 {
   char *data;
   const char *str;
   int rc;
 
   data = cpr_get ("cardedit.change_sex",
                   _("Salutation (M = Mr., F = Ms., or space): "));
   if (!data)
     return -1;
   trim_spaces (data);
   cpr_kill_prompt ();
 
   if (!*data)
     str = "9";
   else if ((*data == 'M' || *data == 'm') && !data[1])
     str = "1";
   else if ((*data == 'F' || *data == 'f') && !data[1])
     str = "2";
   else
     {
       tty_printf (_("Error: invalid response.\n"));
       xfree (data);
       return -1;
     }
 
   rc = agent_scd_setattr ("DISP-SEX", str, 1);
   if (rc)
     log_error ("error setting salutation: %s\n", gpg_strerror (rc));
   xfree (data);
   write_sc_op_status (rc);
   return rc;
 }
 
 
 static int
 change_cafpr (int fprno)
 {
   char *data;
   const char *s;
   int i, c, rc;
   unsigned char fpr[MAX_FINGERPRINT_LEN];
   int fprlen;
 
   data = cpr_get ("cardedit.change_cafpr", _("CA fingerprint: "));
   if (!data)
     return -1;
   trim_spaces (data);
   cpr_kill_prompt ();
 
   for (i=0, s=data; i < MAX_FINGERPRINT_LEN && *s; )
     {
       while (spacep(s))
         s++;
       if (*s == ':')
         s++;
       while (spacep(s))
         s++;
       c = hextobyte (s);
       if (c == -1)
         break;
       fpr[i++] = c;
       s += 2;
     }
   fprlen = i;
   xfree (data);
   if ((fprlen != 20 && fprlen != 32) || *s)
     {
       tty_printf (_("Error: invalid formatted fingerprint.\n"));
       return -1;
     }
 
   rc = agent_scd_setattr (fprno==1?"CA-FPR-1":
                           fprno==2?"CA-FPR-2":
                           fprno==3?"CA-FPR-3":"x", fpr, fprlen);
   if (rc)
     log_error ("error setting cafpr: %s\n", gpg_strerror (rc));
   write_sc_op_status (rc);
   return rc;
 }
 
 
 
 static void
 toggle_forcesig (void)
 {
   struct agent_card_info_s info;
   int rc;
   int newstate;
 
   memset (&info, 0, sizeof info);
   rc = agent_scd_getattr ("CHV-STATUS", &info);
   if (rc)
     {
       log_error ("error getting current status: %s\n", gpg_strerror (rc));
       return;
     }
   newstate = !info.chv1_cached;
   agent_release_card_info (&info);
 
   rc = agent_scd_setattr ("CHV-STATUS-1", newstate? "\x01":"", 1);
   if (rc)
     log_error ("error toggling signature PIN flag: %s\n", gpg_strerror (rc));
   write_sc_op_status (rc);
 }
 
 
 /* Helper for the key generation/edit functions.  */
 static int
 get_info_for_key_operation (struct agent_card_info_s *info)
 {
   int rc;
 
   memset (info, 0, sizeof *info);
   rc = agent_scd_getattr ("SERIALNO", info);
   if (rc || !info->serialno || strncmp (info->serialno, "D27600012401", 12)
       || strlen (info->serialno) != 32 )
     {
       log_error (_("key operation not possible: %s\n"),
                  rc ? gpg_strerror (rc) : _("not an OpenPGP card"));
       return rc? rc: -1;
     }
   rc = agent_scd_getattr ("KEY-FPR", info);
   if (!rc)
     rc = agent_scd_getattr ("CHV-STATUS", info);
   if (!rc)
     rc = agent_scd_getattr ("DISP-NAME", info);
   if (!rc)
     rc = agent_scd_getattr ("EXTCAP", info);
   if (!rc)
     rc = agent_scd_getattr ("KEY-ATTR", info);
   if (rc)
     log_error (_("error getting current key info: %s\n"), gpg_strerror (rc));
   return rc;
 }
 
 
 /* Helper for the key generation/edit functions.  */
 static int
 check_pin_for_key_operation (struct agent_card_info_s *info, int *forced_chv1)
 {
   int rc = 0;
 
   *forced_chv1 = !info->chv1_cached;
   if (*forced_chv1)
     { /* Switch off the forced mode so that during key generation we
          don't get bothered with PIN queries for each
          self-signature. */
       rc = agent_scd_setattr ("CHV-STATUS-1", "\x01", 1);
       if (rc)
         {
           log_error ("error clearing forced signature PIN flag: %s\n",
                      gpg_strerror (rc));
           *forced_chv1 = 0;
         }
     }
 
   if (!rc)
     {
       /* Check the PIN now, so that we won't get asked later for each
          binding signature. */
       rc = agent_scd_checkpin (info->serialno);
       if (rc)
         {
           log_error ("error checking the PIN: %s\n", gpg_strerror (rc));
           write_sc_op_status (rc);
         }
   }
   return rc;
 }
 
 /* Helper for the key generation/edit functions.  */
 static void
 restore_forced_chv1 (int *forced_chv1)
 {
   int rc;
 
   if (*forced_chv1)
     { /* Switch back to forced state. */
       rc = agent_scd_setattr ("CHV-STATUS-1", "", 1);
       if (rc)
         {
           log_error ("error setting forced signature PIN flag: %s\n",
                      gpg_strerror (rc));
         }
     }
 }
 
 
 /* Helper for the key generation/edit functions.  */
 static void
 show_card_key_info (struct agent_card_info_s *info)
 {
   tty_fprintf (NULL, "Signature key ....:");
   print_shax_fpr (NULL, info->fpr1len? info->fpr1:NULL, info->fpr1len);
   tty_fprintf (NULL, "Encryption key....:");
   print_shax_fpr (NULL, info->fpr2len? info->fpr2:NULL, info->fpr2len);
   tty_fprintf (NULL, "Authentication key:");
   print_shax_fpr (NULL, info->fpr3len? info->fpr3:NULL, info->fpr3len);
   tty_printf ("\n");
 }
 
 
 /* Helper for the key generation/edit functions.  */
 static int
 replace_existing_key_p (struct agent_card_info_s *info, int keyno)
 {
   log_assert (keyno >= 0 && keyno <= 3);
 
   if ((keyno == 1 && info->fpr1len)
       || (keyno == 2 && info->fpr2len)
       || (keyno == 3 && info->fpr3len))
     {
       tty_printf ("\n");
       log_info ("WARNING: such a key has already been stored on the card!\n");
       tty_printf ("\n");
       if ( !cpr_get_answer_is_yes( "cardedit.genkeys.replace_key",
                                   _("Replace existing key? (y/N) ")))
         return -1;
       return 1;
     }
   return 0;
 }
 
 
 static void
 show_keysize_warning (void)
 {
   static int shown;
 
   if (shown)
     return;
   shown = 1;
   tty_printf
     (_("Note: There is no guarantee that the card supports the requested\n"
        "      key type or size.  If the key generation does not succeed,\n"
        "      please check the documentation of your card to see which\n"
        "      key types and sizes are supported.\n")
      );
 }
 
 
 /* Ask for the size of a card key.  NBITS is the current size
    configured for the card.  Returns 0 to use the default size
    (i.e. NBITS) or the selected size.  */
 static unsigned int
 ask_card_rsa_keysize (unsigned int nbits)
 {
   unsigned int min_nbits = 1024;
   unsigned int max_nbits = 4096;
   char *prompt, *answer;
   unsigned int req_nbits;
 
   for (;;)
     {
       prompt = xasprintf (_("What keysize do you want? (%u) "), nbits);
       answer = cpr_get ("cardedit.genkeys.size", prompt);
       cpr_kill_prompt ();
       req_nbits = *answer? atoi (answer): nbits;
       xfree (prompt);
       xfree (answer);
 
       if (req_nbits != nbits && (req_nbits % 32) )
         {
           req_nbits = ((req_nbits + 31) / 32) * 32;
           tty_printf (_("rounded up to %u bits\n"), req_nbits);
         }
 
       if (req_nbits == nbits)
         return 0;  /* Use default.  */
 
       if (req_nbits < min_nbits || req_nbits > max_nbits)
         {
           tty_printf (_("%s keysizes must be in the range %u-%u\n"),
                       "RSA", min_nbits, max_nbits);
         }
       else
         return req_nbits;
     }
 }
 
 /* Ask for the key attribute of a card key.  CURRENT is the current
    attribute configured for the card.  KEYNO is the number of the key
    used to select the prompt.  Returns NULL to use the default
    attribute or the selected attribute structure.  */
 static struct key_attr *
 ask_card_keyattr (int keyno, const struct key_attr *current)
 {
   struct key_attr *key_attr = NULL;
   char *answer = NULL;
   int algo;
 
   tty_printf (_("Changing card key attribute for: "));
   if (keyno == 0)
     tty_printf (_("Signature key\n"));
   else if (keyno == 1)
     tty_printf (_("Encryption key\n"));
   else
     tty_printf (_("Authentication key\n"));
 
   tty_printf (_("Please select what kind of key you want:\n"));
   tty_printf (_("   (%d) RSA\n"), 1 );
   tty_printf (_("   (%d) ECC\n"), 2 );
 
   for (;;)
     {
       xfree (answer);
       answer = cpr_get ("cardedit.genkeys.algo", _("Your selection? "));
       cpr_kill_prompt ();
       algo = *answer? atoi (answer) : 0;
 
       if (!*answer || algo == 1 || algo == 2)
-        break;
+        {
+          xfree (answer);
+          break;
+        }
       else
         tty_printf (_("Invalid selection.\n"));
     }
 
   if (algo == 0)
     goto leave;
 
   key_attr = xmalloc (sizeof (struct key_attr));
 
   if (algo == 1)
     {
       unsigned int nbits, result_nbits;
 
       if (current->algo == PUBKEY_ALGO_RSA)
         nbits = current->nbits;
       else
         nbits = 2048;
 
       result_nbits = ask_card_rsa_keysize (nbits);
       if (result_nbits == 0)
         {
           if (current->algo == PUBKEY_ALGO_RSA)
             {
               xfree (key_attr);
               key_attr = NULL;
             }
           else
             result_nbits = nbits;
         }
 
       if (key_attr)
         {
           key_attr->algo = PUBKEY_ALGO_RSA;
           key_attr->nbits = result_nbits;
         }
     }
   else
     {
       const char *curve;
       const char *oid_str;
 
       if (current->algo == PUBKEY_ALGO_RSA)
         {
           if (keyno == 1)
             /* Encryption key */
             algo = PUBKEY_ALGO_ECDH;
           else /* Signature key or Authentication key */
             algo = PUBKEY_ALGO_ECDSA;
           curve = NULL;
         }
       else
         {
           algo = current->algo;
           curve = current->curve;
         }
 
       curve = ask_curve (&algo, NULL, curve);
       if (curve)
         {
           key_attr->algo = algo;
           oid_str = openpgp_curve_to_oid (curve, NULL, NULL);
           key_attr->curve = openpgp_oid_to_curve (oid_str, 0);
         }
       else
         {
           xfree (key_attr);
           key_attr = NULL;
         }
     }
 
  leave:
   if (key_attr)
     {
       if (key_attr->algo == PUBKEY_ALGO_RSA)
         tty_printf (_("The card will now be re-configured"
                       " to generate a key of %u bits\n"), key_attr->nbits);
       else if (key_attr->algo == PUBKEY_ALGO_ECDH
                || key_attr->algo == PUBKEY_ALGO_ECDSA
                || key_attr->algo == PUBKEY_ALGO_EDDSA)
         tty_printf (_("The card will now be re-configured"
                       " to generate a key of type: %s\n"), key_attr->curve),
 
       show_keysize_warning ();
     }
 
   return key_attr;
 }
 
 
 
 /* Change the key attribute of key KEYNO (0..2) and show an error
  * message if that fails.  */
 static gpg_error_t
 do_change_keyattr (int keyno, const struct key_attr *key_attr)
 {
   gpg_error_t err = 0;
   char args[100];
 
   if (key_attr->algo == PUBKEY_ALGO_RSA)
     snprintf (args, sizeof args, "--force %d 1 rsa%u", keyno+1,
               key_attr->nbits);
   else if (key_attr->algo == PUBKEY_ALGO_ECDH
            || key_attr->algo == PUBKEY_ALGO_ECDSA
            || key_attr->algo == PUBKEY_ALGO_EDDSA)
     snprintf (args, sizeof args, "--force %d %d %s",
               keyno+1, key_attr->algo, key_attr->curve);
   else
     {
       log_error (_("public key algorithm %d (%s) is not supported\n"),
                  key_attr->algo, gcry_pk_algo_name (key_attr->algo));
       return gpg_error (GPG_ERR_PUBKEY_ALGO);
     }
 
   err = agent_scd_setattr ("KEY-ATTR", args, strlen (args));
   if (err)
     log_error (_("error changing key attribute for key %d: %s\n"),
                keyno+1, gpg_strerror (err));
   return err;
 }
 
 
 static void
 key_attr (void)
 {
   struct agent_card_info_s info;
   gpg_error_t err;
   int keyno;
 
   err = get_info_for_key_operation (&info);
   if (err)
     {
       log_error (_("error getting card info: %s\n"), gpg_strerror (err));
       return;
     }
 
   if (!(info.is_v2 && info.extcap.aac))
     {
       log_error (_("This command is not supported by this card\n"));
       goto leave;
     }
 
   for (keyno = 0; keyno < DIM (info.key_attr); keyno++)
     {
       struct key_attr *key_attr;
 
       if ((key_attr = ask_card_keyattr (keyno, &info.key_attr[keyno])))
         {
           err = do_change_keyattr (keyno, key_attr);
           xfree (key_attr);
           if (err)
             {
               /* Error: Better read the default key attribute again.  */
               agent_release_card_info (&info);
               if (get_info_for_key_operation (&info))
                 goto leave;
               /* Ask again for this key. */
               keyno--;
             }
         }
     }
 
  leave:
   agent_release_card_info (&info);
 }
 
 
 static void
 generate_card_keys (ctrl_t ctrl)
 {
   struct agent_card_info_s info;
   int forced_chv1;
   int want_backup;
 
   if (get_info_for_key_operation (&info))
     return;
 
   if (info.extcap.ki)
     {
       char *answer;
 
       /* FIXME: Should be something like cpr_get_bool so that a status
          GET_BOOL will be emitted.  */
       answer = cpr_get ("cardedit.genkeys.backup_enc",
                         _("Make off-card backup of encryption key? (Y/n) "));
 
       want_backup = answer_is_yes_no_default (answer, 1/*(default to Yes)*/);
       cpr_kill_prompt ();
       xfree (answer);
     }
   else
     want_backup = 0;
 
   if ( (info.fpr1len && !fpr_is_zero (info.fpr1, info.fpr1len))
        || (info.fpr2len && !fpr_is_zero (info.fpr2, info.fpr2len))
        || (info.fpr3len && !fpr_is_zero (info.fpr3, info.fpr3len)))
     {
       tty_printf ("\n");
       log_info (_("Note: keys are already stored on the card!\n"));
       tty_printf ("\n");
       if ( !cpr_get_answer_is_yes ("cardedit.genkeys.replace_keys",
                                    _("Replace existing keys? (y/N) ")))
         {
           agent_release_card_info (&info);
           return;
         }
     }
 
   /* If no displayed name has been set, we assume that this is a fresh
      card and print a hint about the default PINs.  */
   if (!info.disp_name || !*info.disp_name)
     {
       tty_printf ("\n");
       tty_printf (_("Please note that the factory settings of the PINs are\n"
                     "   PIN = '%s'     Admin PIN = '%s'\n"
                     "You should change them using the command --change-pin\n"),
                   "123456", "12345678");
       tty_printf ("\n");
     }
 
 
   if (check_pin_for_key_operation (&info, &forced_chv1))
     goto leave;
 
   generate_keypair (ctrl, 1, NULL, info.serialno, want_backup);
 
  leave:
   agent_release_card_info (&info);
   restore_forced_chv1 (&forced_chv1);
 }
 
 
 /* This function is used by the key edit menu to generate an arbitrary
    subkey. */
 gpg_error_t
 card_generate_subkey (ctrl_t ctrl, kbnode_t pub_keyblock)
 {
   gpg_error_t err;
   struct agent_card_info_s info;
   int forced_chv1 = 0;
   int keyno;
 
   err = get_info_for_key_operation (&info);
   if (err)
     return err;
 
   show_card_key_info (&info);
 
   tty_printf (_("Please select the type of key to generate:\n"));
 
   tty_printf (_("   (1) Signature key\n"));
   tty_printf (_("   (2) Encryption key\n"));
   tty_printf (_("   (3) Authentication key\n"));
 
   for (;;)
     {
       char *answer = cpr_get ("cardedit.genkeys.subkeytype",
                               _("Your selection? "));
       cpr_kill_prompt();
       if (*answer == CONTROL_D)
         {
           xfree (answer);
           err = gpg_error (GPG_ERR_CANCELED);
           goto leave;
         }
       keyno = *answer? atoi(answer): 0;
       xfree(answer);
       if (keyno >= 1 && keyno <= 3)
         break; /* Okay. */
       tty_printf(_("Invalid selection.\n"));
     }
 
   if (replace_existing_key_p (&info, keyno) < 0)
     {
       err = gpg_error (GPG_ERR_CANCELED);
       goto leave;
     }
 
   err = check_pin_for_key_operation (&info, &forced_chv1);
   if (err)
     goto leave;
 
   err = generate_card_subkeypair (ctrl, pub_keyblock, keyno, info.serialno);
 
  leave:
   agent_release_card_info (&info);
   restore_forced_chv1 (&forced_chv1);
   return err;
 }
 
 
 /* Store the key at NODE into the smartcard and modify NODE to
    carry the serialno stuff instead of the actual secret key
    parameters.  USE is the usage for that key; 0 means any
    usage. */
 int
 card_store_subkey (KBNODE node, int use)
 {
   struct agent_card_info_s info;
   int okay = 0;
   unsigned int nbits;
   int allow_keyno[3];
   int  keyno;
   PKT_public_key *pk;
   gpg_error_t err;
   char *hexgrip;
   int rc;
   gnupg_isotime_t timebuf;
 
   log_assert (node->pkt->pkttype == PKT_PUBLIC_KEY
               || node->pkt->pkttype == PKT_PUBLIC_SUBKEY);
 
   pk = node->pkt->pkt.public_key;
 
   if (get_info_for_key_operation (&info))
     return 0;
 
   if (!info.extcap.ki)
     {
       tty_printf ("The card does not support the import of keys\n");
       tty_printf ("\n");
       goto leave;
     }
 
   nbits = nbits_from_pk (pk);
 
   if (!info.is_v2 && nbits != 1024)
     {
       tty_printf ("You may only store a 1024 bit RSA key on the card\n");
       tty_printf ("\n");
       goto leave;
     }
 
   allow_keyno[0] = (!use || (use & (PUBKEY_USAGE_SIG|PUBKEY_USAGE_CERT)));
   allow_keyno[1] = (!use || (use & (PUBKEY_USAGE_ENC)));
   allow_keyno[2] = (!use || (use & (PUBKEY_USAGE_SIG|PUBKEY_USAGE_AUTH)));
 
   tty_printf (_("Please select where to store the key:\n"));
 
   if (allow_keyno[0])
     tty_printf (_("   (1) Signature key\n"));
   if (allow_keyno[1])
     tty_printf (_("   (2) Encryption key\n"));
   if (allow_keyno[2])
     tty_printf (_("   (3) Authentication key\n"));
 
   for (;;)
     {
       char *answer = cpr_get ("cardedit.genkeys.storekeytype",
                               _("Your selection? "));
       cpr_kill_prompt();
       if (*answer == CONTROL_D || !*answer)
         {
           xfree (answer);
           goto leave;
         }
       keyno = *answer? atoi(answer): 0;
       xfree(answer);
       if (keyno >= 1 && keyno <= 3 && allow_keyno[keyno-1])
         {
           if (info.is_v2 && !info.extcap.aac
               && info.key_attr[keyno-1].nbits != nbits)
             {
               tty_printf ("Key does not match the card's capability.\n");
             }
           else
             break; /* Okay. */
         }
       else
         tty_printf(_("Invalid selection.\n"));
     }
 
   if ((rc = replace_existing_key_p (&info, keyno)) < 0)
     goto leave;
 
   err = hexkeygrip_from_pk (pk, &hexgrip);
   if (err)
     goto leave;
 
   epoch2isotime (timebuf, (time_t)pk->timestamp);
   rc = agent_keytocard (hexgrip, keyno, rc, info.serialno, timebuf);
 
   if (rc)
     log_error (_("KEYTOCARD failed: %s\n"), gpg_strerror (rc));
   else
     okay = 1;
   xfree (hexgrip);
 
  leave:
   agent_release_card_info (&info);
   return okay;
 }
 
 
 
 /* Direct sending of an hex encoded APDU with error printing.  */
 static gpg_error_t
 send_apdu (const char *hexapdu, const char *desc, unsigned int ignore)
 {
   gpg_error_t err;
   unsigned int sw;
 
   err = agent_scd_apdu (hexapdu, &sw);
   if (err)
     tty_printf ("sending card command %s failed: %s\n", desc,
                 gpg_strerror (err));
   else if (!hexapdu
            || !strcmp (hexapdu, "undefined")
            || !strcmp (hexapdu, "reset-keep-lock")
            || !strcmp (hexapdu, "lock")
            || !strcmp (hexapdu, "trylock")
            || !strcmp (hexapdu, "unlock"))
     ; /* Ignore pseudo APDUs.  */
   else if (ignore == 0xffff)
     ; /* Ignore all status words.  */
   else if (sw != 0x9000)
     {
       switch (sw)
         {
         case 0x6285: err = gpg_error (GPG_ERR_OBJ_TERM_STATE); break;
         case 0x6982: err = gpg_error (GPG_ERR_BAD_PIN); break;
         case 0x6985: err = gpg_error (GPG_ERR_USE_CONDITIONS); break;
         default: err = gpg_error (GPG_ERR_CARD);
         }
       if (!(ignore && ignore == sw))
         tty_printf ("card command %s failed: %s (0x%04x)\n", desc,
                     gpg_strerror (err),  sw);
     }
   return err;
 }
 
 
 /* Do a factory reset after confirmation.  */
 static void
 factory_reset (void)
 {
   struct agent_card_info_s info;
   gpg_error_t err;
   char *answer = NULL;
   int termstate = 0;
   int i;
   int locked = 0;
 
   /*  The code below basically does the same what this
       gpg-connect-agent script does:
 
         scd reset
         scd serialno undefined
         scd apdu 00 A4 04 00 06 D2 76 00 01 24 01
         scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
         scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
         scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
         scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
         scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
         scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
         scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
         scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
         scd apdu 00 e6 00 00
         scd apdu 00 44 00 00
         scd reset
         /echo Card has been reset to factory defaults
 
       but tries to find out something about the card first.
    */
 
   err = agent_scd_learn (&info, 0);
   if (gpg_err_code (err) == GPG_ERR_OBJ_TERM_STATE
       && gpg_err_source (err) == GPG_ERR_SOURCE_SCD)
     termstate = 1;
   else if (err)
     {
       log_error (_("OpenPGP card not available: %s\n"), gpg_strerror (err));
       goto leave;
     }
 
   if (!termstate)
     {
       log_info (_("OpenPGP card no. %s detected\n"),
                 info.serialno? info.serialno : "[none]");
       if (!(info.status_indicator == 3 || info.status_indicator == 5))
         {
           /* Note: We won't see status-indicator 3 here because it is not
              possible to select a card application in termination state.  */
           log_error (_("This command is not supported by this card\n"));
           goto leave;
         }
 
       tty_printf ("\n");
       log_info (_("Note: This command destroys all keys stored on the card!\n"));
       tty_printf ("\n");
       if (!cpr_get_answer_is_yes ("cardedit.factory-reset.proceed",
                                   _("Continue? (y/N) ")))
         goto leave;
 
 
       answer = cpr_get ("cardedit.factory-reset.really",
                         _("Really do a factory reset? (enter \"yes\") "));
       cpr_kill_prompt ();
       trim_spaces (answer);
       if (strcmp (answer, "yes"))
         goto leave;
 
       /* We need to select a card application before we can send APDUs
          to the card without scdaemon doing anything on its own.  We
          then lock the connection so that other tools (e.g. Kleopatra)
          don't try a new select.  */
       err = send_apdu ("lock", "locking connection ", 0);
       if (err)
         goto leave;
       locked = 1;
       err = send_apdu ("reset-keep-lock", "reset", 0);
       if (err)
         goto leave;
       err = send_apdu ("undefined", "dummy select ", 0);
       if (err)
         goto leave;
 
       /* Select the OpenPGP application.  */
       err = send_apdu ("00A4040006D27600012401", "SELECT AID", 0);
       if (err)
         goto leave;
 
       /* Do some dummy verifies with wrong PINs to set the retry
          counter to zero.  We can't easily use the card version 2.1
          feature of presenting the admin PIN to allow the terminate
          command because there is no machinery in scdaemon to catch
          the verify command and ask for the PIN when the "APDU"
          command is used. */
       /* Here, the length of dummy wrong PIN is 32-byte, also
          supporting authentication with KDF DO.  */
       for (i=0; i < 4; i++)
         send_apdu ("0020008120"
                    "40404040404040404040404040404040"
                    "40404040404040404040404040404040", "VERIFY", 0xffff);
       for (i=0; i < 4; i++)
         send_apdu ("0020008320"
                    "40404040404040404040404040404040"
                    "40404040404040404040404040404040", "VERIFY", 0xffff);
 
       /* Send terminate datafile command.  */
       err = send_apdu ("00e60000", "TERMINATE DF", 0x6985);
       if (err)
         goto leave;
     }
 
   /* Send activate datafile command.  This is used without
      confirmation if the card is already in termination state.  */
   err = send_apdu ("00440000", "ACTIVATE DF", 0);
   if (err)
     goto leave;
 
   /* Finally we reset the card reader once more.  */
   err = send_apdu ("reset-keep-lock", "reset", 0);
 
   /* Then, connect the card again.  */
   if (!err)
     err = agent_scd_serialno (NULL, NULL);
 
  leave:
   if (locked)
     send_apdu ("unlock", "unlocking connection ", 0);
   xfree (answer);
   agent_release_card_info (&info);
 }
 
 
 #define USER_PIN_DEFAULT "123456"
 #define ADMIN_PIN_DEFAULT "12345678"
 #define KDF_DATA_LENGTH_MIN  90
 #define KDF_DATA_LENGTH_MAX 110
 
 /* Generate KDF data.  */
 static gpg_error_t
 gen_kdf_data (unsigned char *data, int single_salt)
 {
   const unsigned char h0[] = { 0x81, 0x01, 0x03,
                                0x82, 0x01, 0x08,
                                0x83, 0x04 };
   const unsigned char h1[] = { 0x84, 0x08 };
   const unsigned char h2[] = { 0x85, 0x08 };
   const unsigned char h3[] = { 0x86, 0x08 };
   const unsigned char h4[] = { 0x87, 0x20 };
   const unsigned char h5[] = { 0x88, 0x20 };
   unsigned char *p, *salt_user, *salt_admin;
   unsigned char s2k_char;
   unsigned int iterations;
   unsigned char count_4byte[4];
   gpg_error_t err = 0;
 
   p = data;
 
   s2k_char = encode_s2k_iterations (agent_get_s2k_count ());
   iterations = S2K_DECODE_COUNT (s2k_char);
   count_4byte[0] = (iterations >> 24) & 0xff;
   count_4byte[1] = (iterations >> 16) & 0xff;
   count_4byte[2] = (iterations >>  8) & 0xff;
   count_4byte[3] = (iterations & 0xff);
 
   memcpy (p, h0, sizeof h0);
   p += sizeof h0;
   memcpy (p, count_4byte, sizeof count_4byte);
   p += sizeof count_4byte;
   memcpy (p, h1, sizeof h1);
   salt_user = (p += sizeof h1);
   gcry_randomize (p, 8, GCRY_STRONG_RANDOM);
   p += 8;
 
   if (single_salt)
     salt_admin = salt_user;
   else
     {
       memcpy (p, h2, sizeof h2);
       p += sizeof h2;
       gcry_randomize (p, 8, GCRY_STRONG_RANDOM);
       p += 8;
       memcpy (p, h3, sizeof h3);
       salt_admin = (p += sizeof h3);
       gcry_randomize (p, 8, GCRY_STRONG_RANDOM);
       p += 8;
     }
 
   memcpy (p, h4, sizeof h4);
   p += sizeof h4;
   err = gcry_kdf_derive (USER_PIN_DEFAULT, strlen (USER_PIN_DEFAULT),
                          GCRY_KDF_ITERSALTED_S2K, DIGEST_ALGO_SHA256,
                          salt_user, 8, iterations, 32, p);
   p += 32;
   if (!err)
     {
       memcpy (p, h5, sizeof h5);
       p += sizeof h5;
       err = gcry_kdf_derive (ADMIN_PIN_DEFAULT, strlen (ADMIN_PIN_DEFAULT),
                              GCRY_KDF_ITERSALTED_S2K, DIGEST_ALGO_SHA256,
                              salt_admin, 8, iterations, 32, p);
     }
 
   return err;
 }
 
 /* Setup KDF data object which is used for PIN authentication.  */
 static void
 kdf_setup (const char *args)
 {
   struct agent_card_info_s info;
   gpg_error_t err;
   unsigned char kdf_data[KDF_DATA_LENGTH_MAX];
   size_t len;
 
   memset (&info, 0, sizeof info);
 
   err = agent_scd_getattr ("EXTCAP", &info);
   if (err)
     {
       log_error (_("error getting card info: %s\n"), gpg_strerror (err));
       return;
     }
 
   if (!info.extcap.kdf)
     {
       log_error (_("This command is not supported by this card\n"));
       goto leave;
     }
 
   if (!strcmp (args, "off"))
     {
       len = 3;
       memcpy (kdf_data, "\x81\x01\x00", len);
     }
   else
     {
       int single = 0;
 
       if (*args != 0)
         single = 1;
 
       len = single ? KDF_DATA_LENGTH_MIN: KDF_DATA_LENGTH_MAX;
       err = gen_kdf_data (kdf_data, single);
       if (err)
         goto leave_error;
     }
 
   err = agent_scd_setattr ("KDF", kdf_data, len);
   if (err)
     goto leave_error;
 
   err = agent_scd_getattr ("KDF", &info);
 
  leave_error:
   if (err)
     log_error (_("error for setup KDF: %s\n"), gpg_strerror (err));
 
  leave:
   agent_release_card_info (&info);
 }
 
 static void
 uif (int arg_number, const char *arg_rest)
 {
   struct agent_card_info_s info;
   int feature_available;
   gpg_error_t err;
   char name[100];
   unsigned char data[2];
 
   memset (&info, 0, sizeof info);
 
   err = agent_scd_getattr ("EXTCAP", &info);
   if (err)
     {
       log_error (_("error getting card info: %s\n"), gpg_strerror (err));
       return;
     }
 
   feature_available = info.extcap.bt;
   agent_release_card_info (&info);
 
   if (!feature_available)
     {
       log_error (_("This command is not supported by this card\n"));
       tty_printf ("\n");
       return;
     }
 
   snprintf (name, sizeof name, "UIF-%d", arg_number);
   if ( !strcmp (arg_rest, "off") )
     data[0] = 0x00;
   else if ( !strcmp (arg_rest, "on") )
     data[0] = 0x01;
   else if ( !strcmp (arg_rest, "permanent") )
     data[0] = 0x02;
 
   data[1] = 0x20;
 
   err = agent_scd_setattr (name, data, 2);
   if (err)
     log_error (_("error for setup UIF: %s\n"), gpg_strerror (err));
 }
 
 /* Data used by the command parser.  This needs to be outside of the
    function scope to allow readline based command completion.  */
 enum cmdids
   {
     cmdNOP = 0,
     cmdQUIT, cmdADMIN, cmdHELP, cmdLIST, cmdDEBUG, cmdVERIFY,
     cmdNAME, cmdURL, cmdFETCH, cmdLOGIN, cmdLANG, cmdSEX, cmdCAFPR,
     cmdFORCESIG, cmdGENERATE, cmdPASSWD, cmdPRIVATEDO, cmdWRITECERT,
     cmdREADCERT, cmdUNBLOCK, cmdFACTORYRESET, cmdKDFSETUP,
     cmdKEYATTR, cmdUIF,
     cmdINVCMD
   };
 
 static struct
 {
   const char *name;
   enum cmdids id;
   int admin_only;
   const char *desc;
 } cmds[] =
   {
     { "quit"    , cmdQUIT  , 0, N_("quit this menu")},
     { "q"       , cmdQUIT  , 0, NULL },
     { "admin"   , cmdADMIN , 0, N_("show admin commands")},
     { "help"    , cmdHELP  , 0, N_("show this help")},
     { "?"       , cmdHELP  , 0, NULL },
     { "list"    , cmdLIST  , 0, N_("list all available data")},
     { "l"       , cmdLIST  , 0, NULL },
     { "debug"   , cmdDEBUG , 0, NULL },
     { "name"    , cmdNAME  , 1, N_("change card holder's name")},
     { "url"     , cmdURL   , 1, N_("change URL to retrieve key")},
     { "fetch"   , cmdFETCH , 0, N_("fetch the key specified in the card URL")},
     { "login"   , cmdLOGIN , 1, N_("change the login name")},
     { "lang"    , cmdLANG  , 1, N_("change the language preferences")},
     { "salutation",cmdSEX  , 1, N_("change card holder's salutation")},
     { "sex"       ,cmdSEX  , 1, NULL },  /* Backward compatibility.  */
     { "cafpr"   , cmdCAFPR , 1, N_("change a CA fingerprint")},
     { "forcesig", cmdFORCESIG, 1, N_("toggle the signature force PIN flag")},
     { "generate", cmdGENERATE, 1, N_("generate new keys")},
     { "passwd"  , cmdPASSWD, 0, N_("menu to change or unblock the PIN")},
     { "verify"  , cmdVERIFY, 0, N_("verify the PIN and list all data")},
     { "unblock" , cmdUNBLOCK,0, N_("unblock the PIN using a Reset Code")},
     { "factory-reset", cmdFACTORYRESET, 1, N_("destroy all keys and data")},
     { "kdf-setup", cmdKDFSETUP, 1,
       N_("setup KDF for PIN authentication (on/single/off)")},
     { "key-attr", cmdKEYATTR, 1, N_("change the key attribute")},
     { "uif", cmdUIF, 1, N_("change the User Interaction Flag")},
     /* Note, that we do not announce these command yet. */
     { "privatedo", cmdPRIVATEDO, 0, NULL },
     { "readcert", cmdREADCERT, 0, NULL },
     { "writecert", cmdWRITECERT, 1, NULL },
     { NULL, cmdINVCMD, 0, NULL }
   };
 
 
 #ifdef HAVE_LIBREADLINE
 
 /* These two functions are used by readline for command completion. */
 
 static char *
 command_generator(const char *text,int state)
 {
   static int list_index,len;
   const char *name;
 
   /* If this is a new word to complete, initialize now.  This includes
      saving the length of TEXT for efficiency, and initializing the
      index variable to 0. */
   if(!state)
     {
       list_index=0;
       len=strlen(text);
     }
 
   /* Return the next partial match */
   while((name=cmds[list_index].name))
     {
       /* Only complete commands that have help text */
       if(cmds[list_index++].desc && strncmp(name,text,len)==0)
 	return strdup(name);
     }
 
   return NULL;
 }
 
 static char **
 card_edit_completion(const char *text, int start, int end)
 {
   (void)end;
   /* If we are at the start of a line, we try and command-complete.
      If not, just do nothing for now. */
 
   if(start==0)
     return rl_completion_matches(text,command_generator);
 
   rl_attempted_completion_over=1;
 
   return NULL;
 }
 #endif /*HAVE_LIBREADLINE*/
 
 /* Menu to edit all user changeable values on an OpenPGP card.  Only
    Key creation is not handled here. */
 void
 card_edit (ctrl_t ctrl, strlist_t commands)
 {
   enum cmdids cmd = cmdNOP;
   int have_commands = !!commands;
   int redisplay = 1;
   char *answer = NULL;
   int allow_admin=0;
   char serialnobuf[50];
 
 
   if (opt.command_fd != -1)
     ;
   else if (opt.batch && !have_commands)
     {
       log_error(_("can't do this in batch mode\n"));
       goto leave;
     }
 
   for (;;)
     {
       int arg_number;
       const char *arg_string = "";
       const char *arg_rest = "";
       char *p;
       int i;
       int cmd_admin_only;
 
       tty_printf("\n");
       if (redisplay)
         {
           if (opt.with_colons)
             {
               current_card_status (ctrl, es_stdout,
                                    serialnobuf, DIM (serialnobuf));
               fflush (stdout);
             }
           else
             {
               current_card_status (ctrl, NULL,
                                    serialnobuf, DIM (serialnobuf));
               tty_printf("\n");
             }
           redisplay = 0;
 	}
 
       do
         {
           xfree (answer);
           if (have_commands)
             {
               if (commands)
                 {
                   answer = xstrdup (commands->d);
                   commands = commands->next;
 		}
               else if (opt.batch)
                 {
                   answer = xstrdup ("quit");
 		}
               else
                 have_commands = 0;
 	    }
 
 	    if (!have_commands)
               {
 		tty_enable_completion (card_edit_completion);
 		answer = cpr_get_no_help("cardedit.prompt", _("gpg/card> "));
 		cpr_kill_prompt();
 		tty_disable_completion ();
               }
 	    trim_spaces(answer);
 	}
       while ( *answer == '#' );
 
       arg_number = 0; /* Yes, here is the init which egcc complains about */
       cmd_admin_only = 0;
       if (!*answer)
         cmd = cmdLIST; /* Default to the list command */
       else if (*answer == CONTROL_D)
         cmd = cmdQUIT;
       else
         {
           if ((p=strchr (answer,' ')))
             {
               *p++ = 0;
               trim_spaces (answer);
               trim_spaces (p);
               arg_number = atoi(p);
               arg_string = p;
               arg_rest = p;
               while (digitp (arg_rest))
                 arg_rest++;
               while (spacep (arg_rest))
                 arg_rest++;
             }
 
           for (i=0; cmds[i].name; i++ )
             if (!ascii_strcasecmp (answer, cmds[i].name ))
               break;
 
           cmd = cmds[i].id;
           cmd_admin_only = cmds[i].admin_only;
         }
 
       if (!allow_admin && cmd_admin_only)
 	{
           tty_printf ("\n");
           tty_printf (_("Admin-only command\n"));
           continue;
         }
 
       switch (cmd)
         {
         case cmdHELP:
           for (i=0; cmds[i].name; i++ )
             if(cmds[i].desc
 	       && (!cmds[i].admin_only || (cmds[i].admin_only && allow_admin)))
               tty_printf("%-14s %s\n", cmds[i].name, _(cmds[i].desc) );
           break;
 
 	case cmdADMIN:
           if ( !strcmp (arg_string, "on") )
             allow_admin = 1;
           else if ( !strcmp (arg_string, "off") )
             allow_admin = 0;
           else if ( !strcmp (arg_string, "verify") )
             {
               /* Force verification of the Admin Command.  However,
                  this is only done if the retry counter is at initial
                  state.  */
               char *tmp = xmalloc (strlen (serialnobuf) + 6 + 1);
               strcpy (stpcpy (tmp, serialnobuf), "[CHV3]");
               allow_admin = !agent_scd_checkpin (tmp);
               xfree (tmp);
             }
           else /* Toggle. */
             allow_admin=!allow_admin;
 	  if(allow_admin)
 	    tty_printf(_("Admin commands are allowed\n"));
 	  else
 	    tty_printf(_("Admin commands are not allowed\n"));
 	  break;
 
         case cmdVERIFY:
           agent_scd_checkpin (serialnobuf);
           redisplay = 1;
           break;
 
         case cmdLIST:
           redisplay = 1;
           break;
 
         case cmdNAME:
 	  change_name ();
           break;
 
         case cmdURL:
 	  change_url ();
           break;
 
 	case cmdFETCH:
 	  fetch_url (ctrl);
 	  break;
 
         case cmdLOGIN:
 	  change_login (arg_string);
           break;
 
         case cmdLANG:
 	  change_lang ();
           break;
 
         case cmdSEX:
 	  change_sex ();
           break;
 
         case cmdCAFPR:
           if ( arg_number < 1 || arg_number > 3 )
             tty_printf ("usage: cafpr N\n"
                         "       1 <= N <= 3\n");
           else
             change_cafpr (arg_number);
           break;
 
         case cmdPRIVATEDO:
           if ( arg_number < 1 || arg_number > 4 )
             tty_printf ("usage: privatedo N\n"
                         "       1 <= N <= 4\n");
           else
             change_private_do (arg_string, arg_number);
           break;
 
         case cmdWRITECERT:
           if ( arg_number != 3 )
             tty_printf ("usage: writecert 3 < FILE\n");
           else
             change_cert (arg_rest);
           break;
 
         case cmdREADCERT:
           if ( arg_number != 3 )
             tty_printf ("usage: readcert 3 > FILE\n");
           else
             read_cert (arg_rest);
           break;
 
         case cmdFORCESIG:
           toggle_forcesig ();
           break;
 
         case cmdGENERATE:
           generate_card_keys (ctrl);
           break;
 
         case cmdPASSWD:
           change_pin (0, allow_admin);
           break;
 
         case cmdUNBLOCK:
           change_pin (1, allow_admin);
           break;
 
         case cmdFACTORYRESET:
           factory_reset ();
           break;
 
         case cmdKDFSETUP:
           kdf_setup (arg_string);
           break;
 
         case cmdKEYATTR:
           key_attr ();
           break;
 
         case cmdUIF:
           if ( arg_number < 1 || arg_number > 3 )
             tty_printf ("usage: uif N [on|off|permanent]\n"
                         "       1 <= N <= 3\n");
           else
             uif (arg_number, arg_rest);
           break;
 
         case cmdQUIT:
           goto leave;
 
         case cmdNOP:
           break;
 
         case cmdINVCMD:
         default:
           tty_printf ("\n");
           tty_printf (_("Invalid command  (try \"help\")\n"));
           break;
         } /* End command switch. */
     } /* End of main menu loop. */
 
  leave:
   xfree (answer);
 }
diff --git a/g10/cpr.c b/g10/cpr.c
index 5a39913c5..002656b82 100644
--- a/g10/cpr.c
+++ b/g10/cpr.c
@@ -1,708 +1,712 @@
 /* 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);
 }
 
 
 /* Write a status line with code NO followed by the remaining
  * arguments which must be a list of strings terminated by a NULL.
  * Embedded CR and LFs in the strings are C-style escaped.  All
  * strings are printed with a space as delimiter.  */
 gpg_error_t
 write_status_strings2 (ctrl_t dummy, int no, ...)
 {
   va_list arg_ptr;
   const char *s;
 
   (void)dummy;
 
   if (!statusfp || !status_currently_allowed (no) )
     return 0;  /* Not enabled or allowed. */
 
   va_start (arg_ptr, no);
 
   es_fputs ("[GNUPG:] ", statusfp);
   es_fputs (get_status_string (no), statusfp);
   while ((s = va_arg (arg_ptr, const char*)))
     {
       if (*s)
         es_putc (' ', statusfp);
       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);
         }
     }
   es_putc ('\n', statusfp);
 
   va_end (arg_ptr);
 
   if (es_fflush (statusfp) && opt.exit_on_status_write_error)
     g10_exit (0);
 
   return 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 && !esc; s++, n--)
         {
           if (*s == '%' || *(const byte*)s <= lower_limit
               || *(const byte*)s == 127 )
             esc = 1;
           if (wrap && ++count > wrap)
             {
               dowrap=1;
               break;
             }
         }
       if (esc)
         {
           s--; n++;
         }
       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;
+    {
+      char *rv = (string[0] == 'Y' || string[0] == 'y') ? "" : NULL;
+      xfree (string);
+      return rv;
+    }
 
   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;
 	}
     }
 }
diff --git a/g10/gpg.c b/g10/gpg.c
index 9787ca15f..733d4440a 100644
--- a/g10/gpg.c
+++ b/g10/gpg.c
@@ -1,5705 +1,5706 @@
 /* gpg.c - The GnuPG OpenPGP tool
  * Copyright (C) 1998-2020 Free Software Foundation, Inc.
  * Copyright (C) 1997-2019 Werner Koch
  * Copyright (C) 2015-2021 g10 Code GmbH
  *
  * 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/>.
  * SPDX-License-Identifier: GPL-3.0-or-later
  */
 
 #include <config.h>
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <ctype.h>
 #include <unistd.h>
 #ifdef HAVE_STAT
 #include <sys/stat.h> /* for stat() */
 #endif
 #include <fcntl.h>
 #ifdef HAVE_W32_SYSTEM
 # ifdef HAVE_WINSOCK2_H
 #  include <winsock2.h>
 # endif
 # include <windows.h>
 #endif
 #include <npth.h>
 
 #define INCLUDED_BY_MAIN_MODULE 1
 #include "gpg.h"
 #include <assuan.h>
 #include "../common/iobuf.h"
 #include "../common/util.h"
 #include "packet.h"
 #include "../common/membuf.h"
 #include "main.h"
 #include "options.h"
 #include "keydb.h"
 #include "trustdb.h"
 #include "filter.h"
 #include "../common/ttyio.h"
 #include "../common/i18n.h"
 #include "../common/sysutils.h"
 #include "../common/status.h"
 #include "keyserver-internal.h"
 #include "exec.h"
 #include "../common/gc-opt-flags.h"
 #include "../common/asshelp.h"
 #include "call-dirmngr.h"
 #include "tofu.h"
 #include "objcache.h"
 #include "../common/init.h"
 #include "../common/mbox-util.h"
 #include "../common/shareddefs.h"
 #include "../common/compliance.h"
 #include "../common/comopt.h"
 
 #if defined(HAVE_DOSISH_SYSTEM) || defined(__CYGWIN__)
 #define MY_O_BINARY  O_BINARY
 #ifndef S_IRGRP
 # define S_IRGRP 0
 # define S_IWGRP 0
 #endif
 #else
 #define MY_O_BINARY  0
 #endif
 
 enum cmd_and_opt_values
   {
     aNull = 0,
     oArmor	  = 'a',
     aDetachedSign = 'b',
     aSym	  = 'c',
     aDecrypt	  = 'd',
     aEncr	  = 'e',
     oRecipientFile       = 'f',
     oHiddenRecipientFile = 'F',
     oInteractive  = 'i',
     aListKeys	  = 'k',
     oDryRun	  = 'n',
     oOutput	  = 'o',
     oQuiet	  = 'q',
     oRecipient	  = 'r',
     oHiddenRecipient = 'R',
     aSign	  = 's',
     oTextmodeShort= 't',
     oLocalUser	  = 'u',
     oVerbose	  = 'v',
     oCompress	  = 'z',
     oSetNotation  = 'N',
     aListSecretKeys = 'K',
     oBatch	  = 500,
     oMaxOutput,
     oInputSizeHint,
     oChunkSize,
     oSigNotation,
     oCertNotation,
     oShowNotation,
     oNoShowNotation,
     oKnownNotation,
     aEncrFiles,
     aEncrSym,
     aDecryptFiles,
     aClearsign,
     aStore,
     aQuickKeygen,
     aFullKeygen,
     aKeygen,
     aSignEncr,
     aSignEncrSym,
     aSignSym,
     aSignKey,
     aLSignKey,
     aQuickSignKey,
     aQuickLSignKey,
     aQuickRevSig,
     aQuickAddUid,
     aQuickAddKey,
     aQuickRevUid,
     aQuickSetExpire,
     aQuickSetPrimaryUid,
     aListConfig,
     aListGcryptConfig,
     aGPGConfList,
     aGPGConfTest,
     aListPackets,
     aEditKey,
     aDeleteKeys,
     aDeleteSecretKeys,
     aDeleteSecretAndPublicKeys,
     aImport,
     aFastImport,
     aVerify,
     aVerifyFiles,
     aListSigs,
     aSendKeys,
     aRecvKeys,
     aLocateKeys,
     aLocateExtKeys,
     aSearchKeys,
     aRefreshKeys,
     aFetchKeys,
     aShowKeys,
     aExport,
     aExportSecret,
     aExportSecretSub,
     aExportSshKey,
     aCheckKeys,
     aGenRevoke,
     aDesigRevoke,
     aPrimegen,
     aPrintMD,
     aPrintMDs,
     aCheckTrustDB,
     aUpdateTrustDB,
     aFixTrustDB,
     aListTrustDB,
     aListTrustPath,
     aExportOwnerTrust,
     aImportOwnerTrust,
     aDeArmor,
     aEnArmor,
     aGenRandom,
     aRebuildKeydbCaches,
     aCardStatus,
     aCardEdit,
     aChangePIN,
     aPasswd,
     aServer,
     aTOFUPolicy,
 
     oMimemode,
     oTextmode,
     oNoTextmode,
     oExpert,
     oNoExpert,
     oDefSigExpire,
     oAskSigExpire,
     oNoAskSigExpire,
     oDefCertExpire,
     oAskCertExpire,
     oNoAskCertExpire,
     oDefCertLevel,
     oMinCertLevel,
     oAskCertLevel,
     oNoAskCertLevel,
     oFingerprint,
     oWithFingerprint,
     oWithSubkeyFingerprint,
     oWithICAOSpelling,
     oWithKeygrip,
     oWithKeyScreening,
     oWithSecret,
     oWithWKDHash,
     oWithColons,
     oWithKeyData,
     oWithKeyOrigin,
     oWithTofuInfo,
     oWithSigList,
     oWithSigCheck,
     oAnswerYes,
     oAnswerNo,
     oKeyring,
     oPrimaryKeyring,
     oSecretKeyring,
     oShowKeyring,
     oDefaultKey,
     oDefRecipient,
     oDefRecipientSelf,
     oNoDefRecipient,
     oTrySecretKey,
     oOptions,
     oDebug,
     oDebugLevel,
     oDebugAll,
     oDebugIOLBF,
     oDebugSetIobufSize,
     oDebugAllowLargeChunks,
     oStatusFD,
     oStatusFile,
     oAttributeFD,
     oAttributeFile,
     oEmitVersion,
     oNoEmitVersion,
     oCompletesNeeded,
     oMarginalsNeeded,
     oMaxCertDepth,
     oLoadExtension,
     oCompliance,
     oGnuPG,
     oRFC2440,
     oRFC4880,
     oRFC4880bis,
     oOpenPGP,
     oPGP7,
     oPGP8,
     oDE_VS,
     oRFC2440Text,
     oNoRFC2440Text,
     oCipherAlgo,
     oAEADAlgo,
     oDigestAlgo,
     oCertDigestAlgo,
     oCompressAlgo,
     oCompressLevel,
     oBZ2CompressLevel,
     oBZ2DecompressLowmem,
     oPassphrase,
     oPassphraseFD,
     oPassphraseFile,
     oPassphraseRepeat,
     oPinentryMode,
     oCommandFD,
     oCommandFile,
     oQuickRandom,
     oNoVerbose,
     oTrustDBName,
     oNoSecmemWarn,
     oRequireSecmem,
     oNoRequireSecmem,
     oNoPermissionWarn,
     oNoArmor,
     oNoDefKeyring,
     oNoKeyring,
     oNoGreeting,
     oNoTTY,
     oNoOptions,
     oNoBatch,
     oHomedir,
     oSkipVerify,
     oSkipHiddenRecipients,
     oNoSkipHiddenRecipients,
     oAlwaysTrust,
     oTrustModel,
     oForceOwnertrust,
     oNoAutoTrustNewKey,
     oSetFilename,
     oForYourEyesOnly,
     oNoForYourEyesOnly,
     oSetPolicyURL,
     oSigPolicyURL,
     oCertPolicyURL,
     oShowPolicyURL,
     oNoShowPolicyURL,
     oSigKeyserverURL,
     oUseEmbeddedFilename,
     oNoUseEmbeddedFilename,
     oComment,
     oDefaultComment,
     oNoComments,
     oThrowKeyids,
     oNoThrowKeyids,
     oShowPhotos,
     oNoShowPhotos,
     oPhotoViewer,
     oForceAEAD,
     oS2KMode,
     oS2KDigest,
     oS2KCipher,
     oS2KCount,
     oDisplayCharset,
     oNotDashEscaped,
     oEscapeFrom,
     oNoEscapeFrom,
     oLockOnce,
     oLockMultiple,
     oLockNever,
     oKeyServer,
     oKeyServerOptions,
     oImportOptions,
     oImportFilter,
     oExportOptions,
     oExportFilter,
     oListOptions,
     oVerifyOptions,
     oTempDir,
     oExecPath,
     oEncryptTo,
     oHiddenEncryptTo,
     oNoEncryptTo,
     oEncryptToDefaultKey,
     oLoggerFD,
     oLoggerFile,
     oUtf8Strings,
     oNoUtf8Strings,
     oDisableCipherAlgo,
     oDisablePubkeyAlgo,
     oAllowNonSelfsignedUID,
     oNoAllowNonSelfsignedUID,
     oAllowFreeformUID,
     oNoAllowFreeformUID,
     oAllowSecretKeyImport,
     oAllowOldCipherAlgos,
     oEnableSpecialFilenames,
     oNoLiteral,
     oSetFilesize,
     oHonorHttpProxy,
     oFastListMode,
     oListOnly,
     oIgnoreTimeConflict,
     oIgnoreValidFrom,
     oIgnoreCrcError,
     oIgnoreMDCError,
     oShowSessionKey,
     oOverrideSessionKey,
     oOverrideSessionKeyFD,
     oNoRandomSeedFile,
     oAutoKeyRetrieve,
     oNoAutoKeyRetrieve,
     oAutoKeyImport,
     oNoAutoKeyImport,
     oUseAgent,
     oNoUseAgent,
     oGpgAgentInfo,
     oUseKeyboxd,
     oMergeOnly,
     oTryAllSecrets,
     oTrustedKey,
     oNoExpensiveTrustChecks,
     oFixedListMode,
     oLegacyListMode,
     oNoSigCache,
     oAutoCheckTrustDB,
     oNoAutoCheckTrustDB,
     oPreservePermissions,
     oDefaultPreferenceList,
     oDefaultKeyserverURL,
     oPersonalCipherPreferences,
     oPersonalAEADPreferences,
     oPersonalDigestPreferences,
     oPersonalCompressPreferences,
     oAgentProgram,
     oKeyboxdProgram,
     oDirmngrProgram,
     oDisableDirmngr,
     oDisplay,
     oTTYname,
     oTTYtype,
     oLCctype,
     oLCmessages,
     oXauthority,
     oGroup,
     oUnGroup,
     oNoGroups,
     oStrict,
     oNoStrict,
     oMangleDosFilenames,
     oNoMangleDosFilenames,
     oEnableProgressFilter,
     oMultifile,
     oKeyidFormat,
     oExitOnStatusWriteError,
     oLimitCardInsertTries,
     oReaderPort,
     octapiDriver,
     opcscDriver,
     oDisableCCID,
     oRequireCrossCert,
     oNoRequireCrossCert,
     oAutoKeyLocate,
     oNoAutoKeyLocate,
     oEnableLargeRSA,
     oDisableLargeRSA,
     oEnableDSA2,
     oDisableDSA2,
     oAllowWeakDigestAlgos,
     oAllowWeakKeySignatures,
     oFakedSystemTime,
     oNoAutostart,
     oPrintDANERecords,
     oTOFUDefaultPolicy,
     oTOFUDBFormat,
     oDefaultNewKeyAlgo,
     oWeakDigest,
     oUnwrap,
     oOnlySignTextIDs,
     oDisableSignerUID,
     oSender,
     oKeyOrigin,
     oRequestOrigin,
     oNoSymkeyCache,
     oUseOnlyOpenPGPCard,
     oFullTimestrings,
     oIncludeKeyBlock,
     oNoIncludeKeyBlock,
     oChUid,
     oForceSignKey,
 
     oNoop
   };
 
 
 static gpgrt_opt_t opts[] = {
 
   ARGPARSE_group (300, N_("@Commands:\n ")),
 
   ARGPARSE_c (aSign, "sign", N_("make a signature")),
   ARGPARSE_c (aClearsign, "clear-sign", N_("make a clear text signature")),
   ARGPARSE_c (aClearsign, "clearsign", "@"),
   ARGPARSE_c (aDetachedSign, "detach-sign", N_("make a detached signature")),
   ARGPARSE_c (aEncr, "encrypt",   N_("encrypt data")),
   ARGPARSE_c (aEncrFiles, "encrypt-files", "@"),
   ARGPARSE_c (aSym, "symmetric", N_("encryption only with symmetric cipher")),
   ARGPARSE_c (aStore, "store",     "@"),
   ARGPARSE_c (aDecrypt, "decrypt",   N_("decrypt data (default)")),
   ARGPARSE_c (aDecryptFiles, "decrypt-files", "@"),
   ARGPARSE_c (aVerify, "verify"   , N_("verify a signature")),
   ARGPARSE_c (aVerifyFiles, "verify-files" , "@" ),
   ARGPARSE_c (aListKeys, "list-keys", N_("list keys")),
   ARGPARSE_c (aListKeys, "list-public-keys", "@" ),
   ARGPARSE_c (aListSigs, "list-signatures", N_("list keys and signatures")),
   ARGPARSE_c (aListSigs, "list-sigs", "@"),
   ARGPARSE_c (aCheckKeys, "check-signatures",
 	      N_("list and check key signatures")),
   ARGPARSE_c (aCheckKeys, "check-sigs", "@"),
   ARGPARSE_c (oFingerprint, "fingerprint", N_("list keys and fingerprints")),
   ARGPARSE_c (aListSecretKeys, "list-secret-keys", N_("list secret keys")),
   ARGPARSE_c (aKeygen,	    "generate-key",
               N_("generate a new key pair")),
   ARGPARSE_c (aKeygen,	    "gen-key", "@"),
   ARGPARSE_c (aQuickKeygen, "quick-generate-key" ,
               N_("quickly generate a new key pair")),
   ARGPARSE_c (aQuickKeygen, "quick-gen-key", "@"),
   ARGPARSE_c (aQuickAddUid,  "quick-add-uid",
               N_("quickly add a new user-id")),
   ARGPARSE_c (aQuickAddUid,  "quick-adduid", "@"),
   ARGPARSE_c (aQuickAddKey,  "quick-add-key", "@"),
   ARGPARSE_c (aQuickAddKey,  "quick-addkey", "@"),
   ARGPARSE_c (aQuickRevUid,  "quick-revoke-uid",
               N_("quickly revoke a user-id")),
   ARGPARSE_c (aQuickRevUid,  "quick-revuid", "@"),
   ARGPARSE_c (aQuickSetExpire,  "quick-set-expire",
               N_("quickly set a new expiration date")),
   ARGPARSE_c (aQuickSetPrimaryUid,  "quick-set-primary-uid", "@"),
   ARGPARSE_c (aFullKeygen,  "full-generate-key" ,
               N_("full featured key pair generation")),
   ARGPARSE_c (aFullKeygen,  "full-gen-key", "@"),
   ARGPARSE_c (aGenRevoke, "generate-revocation",
 	      N_("generate a revocation certificate")),
   ARGPARSE_c (aGenRevoke, "gen-revoke", "@"),
   ARGPARSE_c (aDeleteKeys,"delete-keys",
               N_("remove keys from the public keyring")),
   ARGPARSE_c (aDeleteSecretKeys, "delete-secret-keys",
               N_("remove keys from the secret keyring")),
   ARGPARSE_c (aQuickSignKey,  "quick-sign-key" ,
               N_("quickly sign a key")),
   ARGPARSE_c (aQuickLSignKey, "quick-lsign-key",
               N_("quickly sign a key locally")),
   ARGPARSE_c (aQuickRevSig,   "quick-revoke-sig" ,
               N_("quickly revoke a key signature")),
   ARGPARSE_c (aSignKey,  "sign-key"   ,N_("sign a key")),
   ARGPARSE_c (aLSignKey, "lsign-key"  ,N_("sign a key locally")),
   ARGPARSE_c (aEditKey,  "edit-key"   ,N_("sign or edit a key")),
   ARGPARSE_c (aEditKey,  "key-edit"   ,"@"),
   ARGPARSE_c (aPasswd,   "change-passphrase", N_("change a passphrase")),
   ARGPARSE_c (aPasswd,   "passwd", "@"),
   ARGPARSE_c (aDesigRevoke, "generate-designated-revocation", "@"),
   ARGPARSE_c (aDesigRevoke, "desig-revoke","@" ),
   ARGPARSE_c (aExport, "export"           , N_("export keys") ),
   ARGPARSE_c (aSendKeys, "send-keys"     , N_("export keys to a keyserver") ),
   ARGPARSE_c (aRecvKeys, "receive-keys" , N_("import keys from a keyserver") ),
   ARGPARSE_c (aRecvKeys, "recv-keys"     , "@"),
   ARGPARSE_c (aSearchKeys, "search-keys" ,
               N_("search for keys on a keyserver") ),
   ARGPARSE_c (aRefreshKeys, "refresh-keys",
               N_("update all keys from a keyserver")),
   ARGPARSE_c (aLocateKeys, "locate-keys", "@"),
   ARGPARSE_c (aLocateExtKeys, "locate-external-keys", "@"),
   ARGPARSE_c (aFetchKeys, "fetch-keys" , "@" ),
   ARGPARSE_c (aShowKeys, "show-keys" , "@" ),
   ARGPARSE_c (aExportSecret, "export-secret-keys" , "@" ),
   ARGPARSE_c (aExportSecretSub, "export-secret-subkeys" , "@" ),
   ARGPARSE_c (aExportSshKey, "export-ssh-key", "@" ),
   ARGPARSE_c (aImport, "import", N_("import/merge keys")),
   ARGPARSE_c (aFastImport, "fast-import", "@"),
 #ifdef ENABLE_CARD_SUPPORT
   ARGPARSE_c (aCardStatus,  "card-status", N_("print the card status")),
   ARGPARSE_c (aCardEdit,   "edit-card",  N_("change data on a card")),
   ARGPARSE_c (aCardEdit,   "card-edit", "@"),
   ARGPARSE_c (aChangePIN,  "change-pin", N_("change a card's PIN")),
 #endif
   ARGPARSE_c (aListConfig, "list-config", "@"),
   ARGPARSE_c (aListGcryptConfig, "list-gcrypt-config", "@"),
   ARGPARSE_c (aGPGConfList, "gpgconf-list", "@" ),
   ARGPARSE_c (aGPGConfTest, "gpgconf-test", "@" ),
   ARGPARSE_c (aListPackets, "list-packets","@"),
 
 #ifndef NO_TRUST_MODELS
   ARGPARSE_c (aExportOwnerTrust, "export-ownertrust", "@"),
   ARGPARSE_c (aImportOwnerTrust, "import-ownertrust", "@"),
   ARGPARSE_c (aUpdateTrustDB,"update-trustdb",
               N_("update the trust database")),
   ARGPARSE_c (aCheckTrustDB, "check-trustdb", "@"),
   ARGPARSE_c (aFixTrustDB, "fix-trustdb", "@"),
   ARGPARSE_c (aListTrustDB, "list-trustdb", "@"),
 #endif
 
   ARGPARSE_c (aDeArmor, "dearmor", "@"),
   ARGPARSE_c (aDeArmor, "dearmour", "@"),
   ARGPARSE_c (aEnArmor, "enarmor", "@"),
   ARGPARSE_c (aEnArmor, "enarmour", "@"),
   ARGPARSE_c (aPrintMD, "print-md", N_("print message digests")),
   ARGPARSE_c (aPrintMDs, "print-mds", "@"), /* old */
   ARGPARSE_c (aPrimegen, "gen-prime", "@" ),
   ARGPARSE_c (aGenRandom,"gen-random", "@" ),
   ARGPARSE_c (aServer,   "server",  N_("run in server mode")),
   ARGPARSE_c (aTOFUPolicy, "tofu-policy",
 	      N_("|VALUE|set the TOFU policy for a key")),
   /* Not yet used:
      ARGPARSE_c (aListTrustPath, "list-trust-path", "@"), */
   ARGPARSE_c (aDeleteSecretAndPublicKeys,
               "delete-secret-and-public-keys", "@"),
   ARGPARSE_c (aRebuildKeydbCaches, "rebuild-keydb-caches", "@"),
   ARGPARSE_c (aListKeys, "list-key", "@"),   /* alias */
   ARGPARSE_c (aListSigs, "list-sig", "@"),   /* alias */
   ARGPARSE_c (aCheckKeys, "check-sig", "@"), /* alias */
   ARGPARSE_c (aShowKeys,  "show-key", "@"), /* alias */
 
 
 
   ARGPARSE_header ("Monitor", N_("Options controlling the diagnostic output")),
 
   ARGPARSE_s_n (oVerbose, "verbose", N_("verbose")),
   ARGPARSE_s_n (oNoVerbose, "no-verbose", "@"),
   ARGPARSE_s_n (oQuiet,	  "quiet",   N_("be somewhat more quiet")),
   ARGPARSE_s_n (oNoTTY,   "no-tty",  "@"),
   ARGPARSE_s_n (oNoGreeting, "no-greeting", "@"),
   ARGPARSE_s_s (oDebug, "debug", "@"),
   ARGPARSE_s_s (oDebugLevel, "debug-level", "@"),
   ARGPARSE_s_n (oDebugAll, "debug-all", "@"),
   ARGPARSE_s_n (oDebugIOLBF, "debug-iolbf", "@"),
   ARGPARSE_s_u (oDebugSetIobufSize, "debug-set-iobuf-size", "@"),
   ARGPARSE_s_u (oDebugAllowLargeChunks, "debug-allow-large-chunks", "@"),
   ARGPARSE_s_s (oDisplayCharset, "display-charset", "@"),
   ARGPARSE_s_s (oDisplayCharset, "charset", "@"),
   ARGPARSE_conffile (oOptions, "options", N_("|FILE|read options from FILE")),
   ARGPARSE_noconffile (oNoOptions, "no-options", "@"),
   ARGPARSE_s_i (oLoggerFD,   "logger-fd", "@"),
   ARGPARSE_s_s (oLoggerFile, "log-file",
                 N_("|FILE|write server mode logs to FILE")),
   ARGPARSE_s_s (oLoggerFile, "logger-file", "@"),  /* 1.4 compatibility.  */
   ARGPARSE_s_n (oQuickRandom, "debug-quick-random", "@"),
 
 
   ARGPARSE_header ("Configuration",
                    N_("Options controlling the configuration")),
 
   ARGPARSE_s_s (oHomedir, "homedir", "@"),
   ARGPARSE_s_s (oFakedSystemTime, "faked-system-time", "@"),
   ARGPARSE_s_s (oDefaultKey, "default-key",
                 N_("|NAME|use NAME as default secret key")),
   ARGPARSE_s_s (oEncryptTo,      "encrypt-to",
                 N_("|NAME|encrypt to user ID NAME as well")),
   ARGPARSE_s_n (oNoEncryptTo, "no-encrypt-to", "@"),
   ARGPARSE_s_s (oHiddenEncryptTo, "hidden-encrypt-to", "@"),
   ARGPARSE_s_n (oEncryptToDefaultKey, "encrypt-to-default-key", "@"),
   ARGPARSE_s_s (oDefRecipient, "default-recipient", "@"),
   ARGPARSE_s_n (oDefRecipientSelf,  "default-recipient-self", "@"),
   ARGPARSE_s_n (oNoDefRecipient, "no-default-recipient", "@"),
   ARGPARSE_s_s (oGroup,      "group",
                 N_("|SPEC|set up email aliases")),
   ARGPARSE_s_s (oUnGroup,    "ungroup",    "@"),
   ARGPARSE_s_n (oNoGroups,   "no-groups",  "@"),
   ARGPARSE_s_s (oCompliance, "compliance",   "@"),
   ARGPARSE_s_n (oGnuPG, "gnupg",   "@"),
   ARGPARSE_s_n (oGnuPG, "no-pgp2", "@"),
   ARGPARSE_s_n (oGnuPG, "no-pgp6", "@"),
   ARGPARSE_s_n (oGnuPG, "no-pgp7", "@"),
   ARGPARSE_s_n (oGnuPG, "no-pgp8", "@"),
   ARGPARSE_s_n (oRFC2440, "rfc2440", "@"),
   ARGPARSE_s_n (oRFC4880, "rfc4880", "@"),
   ARGPARSE_s_n (oRFC4880bis, "rfc4880bis", "@"),
   ARGPARSE_s_n (oOpenPGP, "openpgp", N_("use strict OpenPGP behavior")),
   ARGPARSE_s_n (oPGP7, "pgp6", "@"),
   ARGPARSE_s_n (oPGP7, "pgp7", "@"),
   ARGPARSE_s_n (oPGP8, "pgp8", "@"),
   ARGPARSE_s_s (oDefaultNewKeyAlgo, "default-new-key-algo", "@"),
 #ifndef NO_TRUST_MODELS
   ARGPARSE_s_n (oAlwaysTrust, "always-trust", "@"),
 #endif
   ARGPARSE_s_s (oTrustModel, "trust-model", "@"),
   ARGPARSE_s_s (oPhotoViewer,  "photo-viewer", "@"),
   ARGPARSE_s_s (oKnownNotation, "known-notation", "@"),
   ARGPARSE_s_s (oAgentProgram, "agent-program", "@"),
   ARGPARSE_s_s (oKeyboxdProgram, "keyboxd-program", "@"),
   ARGPARSE_s_s (oDirmngrProgram, "dirmngr-program", "@"),
   ARGPARSE_s_n (oExitOnStatusWriteError, "exit-on-status-write-error", "@"),
   ARGPARSE_s_i (oLimitCardInsertTries, "limit-card-insert-tries", "@"),
   ARGPARSE_s_n (oEnableProgressFilter, "enable-progress-filter", "@"),
   ARGPARSE_s_s (oTempDir,  "temp-directory", "@"),
   ARGPARSE_s_s (oExecPath, "exec-path", "@"),
   ARGPARSE_s_n (oExpert,      "expert", "@"),
   ARGPARSE_s_n (oNoExpert, "no-expert", "@"),
   ARGPARSE_s_n (oNoSecmemWarn, "no-secmem-warning", "@"),
   ARGPARSE_s_n (oRequireSecmem, "require-secmem", "@"),
   ARGPARSE_s_n (oNoRequireSecmem, "no-require-secmem", "@"),
   ARGPARSE_s_n (oNoPermissionWarn, "no-permission-warning", "@"),
   ARGPARSE_s_n (oDryRun, "dry-run", N_("do not make any changes")),
   ARGPARSE_s_n (oInteractive, "interactive", N_("prompt before overwriting")),
   ARGPARSE_s_s (oDefSigExpire, "default-sig-expire", "@"),
   ARGPARSE_s_n (oAskSigExpire,      "ask-sig-expire", "@"),
   ARGPARSE_s_n (oNoAskSigExpire, "no-ask-sig-expire", "@"),
   ARGPARSE_s_s (oDefCertExpire, "default-cert-expire", "@"),
   ARGPARSE_s_n (oAskCertExpire,      "ask-cert-expire", "@"),
   ARGPARSE_s_n (oNoAskCertExpire, "no-ask-cert-expire", "@"),
   ARGPARSE_s_i (oDefCertLevel, "default-cert-level", "@"),
   ARGPARSE_s_i (oMinCertLevel, "min-cert-level", "@"),
   ARGPARSE_s_n (oAskCertLevel,      "ask-cert-level", "@"),
   ARGPARSE_s_n (oNoAskCertLevel, "no-ask-cert-level", "@"),
   ARGPARSE_s_n (oOnlySignTextIDs, "only-sign-text-ids", "@"),
   ARGPARSE_s_n (oEnableLargeRSA, "enable-large-rsa", "@"),
   ARGPARSE_s_n (oDisableLargeRSA, "disable-large-rsa", "@"),
   ARGPARSE_s_n (oEnableDSA2, "enable-dsa2", "@"),
   ARGPARSE_s_n (oDisableDSA2, "disable-dsa2", "@"),
   ARGPARSE_s_s (oPersonalCipherPreferences, "personal-cipher-preferences","@"),
   ARGPARSE_s_s (oPersonalAEADPreferences, "personal-aead-preferences","@"),
   ARGPARSE_s_s (oPersonalDigestPreferences, "personal-digest-preferences","@"),
   ARGPARSE_s_s (oPersonalCompressPreferences,
                                          "personal-compress-preferences", "@"),
   ARGPARSE_s_s (oDefaultPreferenceList,  "default-preference-list", "@"),
   ARGPARSE_s_s (oDefaultKeyserverURL,  "default-keyserver-url", "@"),
   ARGPARSE_s_n (oNoExpensiveTrustChecks, "no-expensive-trust-checks", "@"),
   ARGPARSE_s_n (oAllowNonSelfsignedUID,      "allow-non-selfsigned-uid", "@"),
   ARGPARSE_s_n (oNoAllowNonSelfsignedUID, "no-allow-non-selfsigned-uid", "@"),
   ARGPARSE_s_n (oAllowFreeformUID,      "allow-freeform-uid", "@"),
   ARGPARSE_s_n (oNoAllowFreeformUID, "no-allow-freeform-uid", "@"),
   ARGPARSE_s_n (oPreservePermissions, "preserve-permissions", "@"),
   ARGPARSE_s_i (oDefCertLevel, "default-cert-check-level", "@"), /* old */
   ARGPARSE_s_s (oTOFUDefaultPolicy, "tofu-default-policy", "@"),
   ARGPARSE_s_n (oLockOnce,     "lock-once", "@"),
   ARGPARSE_s_n (oLockMultiple, "lock-multiple", "@"),
   ARGPARSE_s_n (oLockNever,    "lock-never", "@"),
   ARGPARSE_s_s (oCompressAlgo,"compress-algo", "@"),
   ARGPARSE_s_s (oCompressAlgo, "compression-algo", "@"), /* Alias */
   ARGPARSE_s_n (oBZ2DecompressLowmem, "bzip2-decompress-lowmem", "@"),
   ARGPARSE_s_i (oCompletesNeeded, "completes-needed", "@"),
   ARGPARSE_s_i (oMarginalsNeeded, "marginals-needed", "@"),
   ARGPARSE_s_i (oMaxCertDepth,	"max-cert-depth", "@" ),
 #ifndef NO_TRUST_MODELS
   ARGPARSE_s_s (oTrustDBName, "trustdb-name", "@"),
   ARGPARSE_s_n (oAutoCheckTrustDB, "auto-check-trustdb", "@"),
   ARGPARSE_s_n (oNoAutoCheckTrustDB, "no-auto-check-trustdb", "@"),
   ARGPARSE_s_s (oForceOwnertrust, "force-ownertrust", "@"),
   ARGPARSE_s_n (oNoAutoTrustNewKey, "no-auto-trust-new-key", "@"),
 #endif
 
 
   ARGPARSE_header ("Input", N_("Options controlling the input")),
 
   ARGPARSE_s_n (oMultifile, "multifile", "@"),
   ARGPARSE_s_s (oInputSizeHint, "input-size-hint", "@"),
   ARGPARSE_s_n (oUtf8Strings,      "utf8-strings", "@"),
   ARGPARSE_s_n (oNoUtf8Strings, "no-utf8-strings", "@"),
   ARGPARSE_p_u (oSetFilesize, "set-filesize", "@"),
   ARGPARSE_s_n (oNoLiteral, "no-literal", "@"),
   ARGPARSE_s_s (oSetNotation,  "set-notation", "@"),
   ARGPARSE_s_s (oSigNotation,  "sig-notation", "@"),
   ARGPARSE_s_s (oCertNotation, "cert-notation", "@"),
   ARGPARSE_s_s (oSetPolicyURL,  "set-policy-url", "@"),
   ARGPARSE_s_s (oSigPolicyURL,  "sig-policy-url", "@"),
   ARGPARSE_s_s (oCertPolicyURL, "cert-policy-url", "@"),
   ARGPARSE_s_s (oSigKeyserverURL, "sig-keyserver-url", "@"),
 
 
 
   ARGPARSE_header ("Output", N_("Options controlling the output")),
 
   ARGPARSE_s_n (oArmor, "armor", N_("create ascii armored output")),
   ARGPARSE_s_n (oArmor, "armour", "@"),
   ARGPARSE_s_n (oNoArmor, "no-armor", "@"),
   ARGPARSE_s_n (oNoArmor, "no-armour", "@"),
   ARGPARSE_s_s (oOutput, "output", N_("|FILE|write output to FILE")),
   ARGPARSE_p_u (oMaxOutput, "max-output", "@"),
   ARGPARSE_s_s (oComment, "comment", "@"),
   ARGPARSE_s_n (oDefaultComment, "default-comment", "@"),
   ARGPARSE_s_n (oNoComments, "no-comments", "@"),
   ARGPARSE_s_n (oEmitVersion,      "emit-version", "@"),
   ARGPARSE_s_n (oNoEmitVersion, "no-emit-version", "@"),
   ARGPARSE_s_n (oNoEmitVersion, "no-version", "@"), /* alias */
   ARGPARSE_s_n (oNotDashEscaped, "not-dash-escaped", "@"),
   ARGPARSE_s_n (oEscapeFrom,      "escape-from-lines", "@"),
   ARGPARSE_s_n (oNoEscapeFrom, "no-escape-from-lines", "@"),
   ARGPARSE_s_n (oMimemode, "mimemode", "@"),
   ARGPARSE_s_n (oTextmodeShort, NULL, "@"),
   ARGPARSE_s_n (oTextmode,   "textmode", N_("use canonical text mode")),
   ARGPARSE_s_n (oNoTextmode, "no-textmode", "@"),
   ARGPARSE_s_s (oSetFilename, "set-filename", "@"),
   ARGPARSE_s_n (oForYourEyesOnly, "for-your-eyes-only", "@"),
   ARGPARSE_s_n (oNoForYourEyesOnly, "no-for-your-eyes-only", "@"),
   ARGPARSE_s_n (oShowNotation,      "show-notation", "@"),
   ARGPARSE_s_n (oNoShowNotation, "no-show-notation", "@"),
   ARGPARSE_s_n (oShowSessionKey, "show-session-key", "@"),
   ARGPARSE_s_n (oUseEmbeddedFilename,      "use-embedded-filename", "@"),
   ARGPARSE_s_n (oNoUseEmbeddedFilename, "no-use-embedded-filename", "@"),
   ARGPARSE_s_n (oUnwrap, "unwrap", "@"),
   ARGPARSE_s_n (oMangleDosFilenames,      "mangle-dos-filenames", "@"),
   ARGPARSE_s_n (oNoMangleDosFilenames, "no-mangle-dos-filenames", "@"),
   ARGPARSE_s_i (oChunkSize, "chunk-size", "@"),
   ARGPARSE_s_n (oNoSymkeyCache, "no-symkey-cache", "@"),
   ARGPARSE_s_n (oSkipVerify, "skip-verify", "@"),
   ARGPARSE_s_n (oListOnly, "list-only", "@"),
   ARGPARSE_s_i (oCompress, NULL,
                 N_("|N|set compress level to N (0 disables)")),
   ARGPARSE_s_i (oCompressLevel, "compress-level", "@"),
   ARGPARSE_s_i (oBZ2CompressLevel, "bzip2-compress-level", "@"),
   ARGPARSE_s_n (oDisableSignerUID, "disable-signer-uid", "@"),
 
   ARGPARSE_header ("ImportExport",
                    N_("Options controlling key import and export")),
 
   ARGPARSE_s_s (oAutoKeyLocate, "auto-key-locate",
               N_("|MECHANISMS|use MECHANISMS to locate keys by mail address")),
   ARGPARSE_s_n (oNoAutoKeyLocate, "no-auto-key-locate", "@"),
   ARGPARSE_s_n (oAutoKeyImport,   "auto-key-import",
                 N_("import missing key from a signature")),
   ARGPARSE_s_n (oNoAutoKeyImport, "no-auto-key-import", "@"),
   ARGPARSE_s_n (oAutoKeyRetrieve, "auto-key-retrieve", "@"),
   ARGPARSE_s_n (oNoAutoKeyRetrieve, "no-auto-key-retrieve", "@"),
   ARGPARSE_s_n (oIncludeKeyBlock, "include-key-block",
                 N_("include the public key in signatures")),
   ARGPARSE_s_n (oNoIncludeKeyBlock, "no-include-key-block", "@"),
   ARGPARSE_s_n (oDisableDirmngr, "disable-dirmngr",
                 N_("disable all access to the dirmngr")),
   ARGPARSE_s_s (oKeyServer, "keyserver", "@"), /* Deprecated.  */
   ARGPARSE_s_s (oKeyServerOptions, "keyserver-options", "@"),
   ARGPARSE_s_s (oKeyOrigin, "key-origin", "@"),
   ARGPARSE_s_s (oImportOptions, "import-options", "@"),
   ARGPARSE_s_s (oImportFilter,  "import-filter", "@"),
   ARGPARSE_s_s (oExportOptions, "export-options", "@"),
   ARGPARSE_s_s (oExportFilter,  "export-filter", "@"),
   ARGPARSE_s_n (oMergeOnly,	  "merge-only", "@" ),
   ARGPARSE_s_n (oAllowSecretKeyImport, "allow-secret-key-import", "@"),
 
 
   ARGPARSE_header ("Keylist", N_("Options controlling key listings")),
 
   ARGPARSE_s_s (oListOptions,   "list-options", "@"),
   ARGPARSE_s_n (oFullTimestrings, "full-timestrings", "@"),
   ARGPARSE_s_n (oShowPhotos,   "show-photos", "@"),
   ARGPARSE_s_n (oNoShowPhotos, "no-show-photos", "@"),
   ARGPARSE_s_n (oShowPolicyURL,      "show-policy-url", "@"),
   ARGPARSE_s_n (oNoShowPolicyURL, "no-show-policy-url", "@"),
   ARGPARSE_s_n (oWithColons, "with-colons", "@"),
   ARGPARSE_s_n (oWithTofuInfo,"with-tofu-info", "@"),
   ARGPARSE_s_n (oWithKeyData,"with-key-data", "@"),
   ARGPARSE_s_n (oWithSigList,"with-sig-list", "@"),
   ARGPARSE_s_n (oWithSigCheck,"with-sig-check", "@"),
   ARGPARSE_s_n (oWithFingerprint, "with-fingerprint", "@"),
   ARGPARSE_s_n (oWithSubkeyFingerprint, "with-subkey-fingerprint", "@"),
   ARGPARSE_s_n (oWithSubkeyFingerprint, "with-subkey-fingerprints", "@"),
   ARGPARSE_s_n (oWithICAOSpelling, "with-icao-spelling", "@"),
   ARGPARSE_s_n (oWithKeygrip,     "with-keygrip", "@"),
   ARGPARSE_s_n (oWithKeyScreening,"with-key-screening", "@"),
   ARGPARSE_s_n (oWithSecret,      "with-secret", "@"),
   ARGPARSE_s_n (oWithWKDHash,     "with-wkd-hash", "@"),
   ARGPARSE_s_n (oWithKeyOrigin,   "with-key-origin", "@"),
   ARGPARSE_s_n (oFastListMode, "fast-list-mode", "@"),
   ARGPARSE_s_n (oFixedListMode, "fixed-list-mode", "@"),
   ARGPARSE_s_n (oLegacyListMode, "legacy-list-mode", "@"),
   ARGPARSE_s_n (oPrintDANERecords, "print-dane-records", "@"),
   ARGPARSE_s_s (oKeyidFormat, "keyid-format", "@"),
   ARGPARSE_s_n (oShowKeyring, "show-keyring", "@"),
 
 
   ARGPARSE_header (NULL, N_("Options to specify keys")),
 
   ARGPARSE_s_s (oRecipient, "recipient", N_("|USER-ID|encrypt for USER-ID")),
   ARGPARSE_s_s (oHiddenRecipient, "hidden-recipient", "@"),
   ARGPARSE_s_s (oRecipientFile, "recipient-file", "@"),
   ARGPARSE_s_s (oHiddenRecipientFile, "hidden-recipient-file", "@"),
   ARGPARSE_s_s (oRecipient, "remote-user", "@"),  /* (old option name) */
   ARGPARSE_s_n (oThrowKeyids, "throw-keyids", "@"),
   ARGPARSE_s_n (oNoThrowKeyids, "no-throw-keyids", "@"),
   ARGPARSE_s_s (oLocalUser, "local-user",
                 N_("|USER-ID|use USER-ID to sign or decrypt")),
   ARGPARSE_s_s (oTrustedKey, "trusted-key", "@"),
   ARGPARSE_s_s (oSender, "sender", "@"),
   ARGPARSE_s_s (oTrySecretKey, "try-secret-key", "@"),
   ARGPARSE_s_n (oTryAllSecrets,  "try-all-secrets", "@"),
   ARGPARSE_s_n (oNoDefKeyring, "no-default-keyring", "@"),
   ARGPARSE_s_n (oNoKeyring, "no-keyring", "@"),
   ARGPARSE_s_s (oKeyring, "keyring", "@"),
   ARGPARSE_s_s (oPrimaryKeyring, "primary-keyring", "@"),
   ARGPARSE_s_s (oSecretKeyring, "secret-keyring", "@"),
   ARGPARSE_s_n (oSkipHiddenRecipients, "skip-hidden-recipients", "@"),
   ARGPARSE_s_n (oNoSkipHiddenRecipients, "no-skip-hidden-recipients", "@"),
   ARGPARSE_s_s (oOverrideSessionKey, "override-session-key", "@"),
   ARGPARSE_s_i (oOverrideSessionKeyFD, "override-session-key-fd", "@"),
 
 
   ARGPARSE_header ("Security", N_("Options controlling the security")),
 
   ARGPARSE_s_i (oS2KMode, "s2k-mode", "@"),
   ARGPARSE_s_s (oS2KDigest, "s2k-digest-algo", "@"),
   ARGPARSE_s_s (oS2KCipher, "s2k-cipher-algo", "@"),
   ARGPARSE_s_i (oS2KCount, "s2k-count", "@"),
   ARGPARSE_s_n (oForceAEAD, "force-aead", "@"),
   ARGPARSE_s_n (oRequireCrossCert, "require-backsigs", "@"),
   ARGPARSE_s_n (oRequireCrossCert, "require-cross-certification", "@"),
   ARGPARSE_s_n (oNoRequireCrossCert, "no-require-backsigs", "@"),
   ARGPARSE_s_n (oNoRequireCrossCert, "no-require-cross-certification", "@"),
   /* Options to override new security defaults.  */
   ARGPARSE_s_n (oAllowWeakKeySignatures, "allow-weak-key-signatures", "@"),
   ARGPARSE_s_n (oAllowWeakDigestAlgos, "allow-weak-digest-algos", "@"),
   ARGPARSE_s_n (oAllowOldCipherAlgos, "allow-old-cipher-algos", "@"),
   ARGPARSE_s_s (oWeakDigest, "weak-digest","@"),
   ARGPARSE_s_s (oVerifyOptions, "verify-options", "@"),
   ARGPARSE_s_n (oEnableSpecialFilenames, "enable-special-filenames", "@"),
   ARGPARSE_s_n (oNoRandomSeedFile,  "no-random-seed-file", "@"),
   ARGPARSE_s_n (oNoSigCache,         "no-sig-cache", "@"),
   ARGPARSE_s_n (oIgnoreTimeConflict, "ignore-time-conflict", "@"),
   ARGPARSE_s_n (oIgnoreValidFrom,    "ignore-valid-from", "@"),
   ARGPARSE_s_n (oIgnoreCrcError, "ignore-crc-error", "@"),
   ARGPARSE_s_n (oIgnoreMDCError, "ignore-mdc-error", "@"),
   ARGPARSE_s_s (oDisableCipherAlgo,  "disable-cipher-algo", "@"),
   ARGPARSE_s_s (oDisablePubkeyAlgo,  "disable-pubkey-algo", "@"),
   ARGPARSE_s_s (oCipherAlgo, "cipher-algo", "@"),
   ARGPARSE_s_s (oAEADAlgo,   "aead-algo", "@"),
   ARGPARSE_s_s (oDigestAlgo, "digest-algo", "@"),
   ARGPARSE_s_s (oCertDigestAlgo, "cert-digest-algo", "@"),
 
 
   ARGPARSE_header (NULL, N_("Options for unattended use")),
 
   ARGPARSE_s_n (oBatch, "batch", "@"),
   ARGPARSE_s_n (oNoBatch, "no-batch", "@"),
   ARGPARSE_s_n (oAnswerYes, "yes", "@"),
   ARGPARSE_s_n (oAnswerNo, "no", "@"),
   ARGPARSE_s_i (oStatusFD, "status-fd", "@"),
   ARGPARSE_s_s (oStatusFile, "status-file", "@"),
   ARGPARSE_s_i (oAttributeFD, "attribute-fd", "@"),
   ARGPARSE_s_s (oAttributeFile, "attribute-file", "@"),
   ARGPARSE_s_i (oCommandFD, "command-fd", "@"),
   ARGPARSE_s_s (oCommandFile, "command-file", "@"),
   ARGPARSE_o_s (oPassphrase,      "passphrase", "@"),
   ARGPARSE_s_i (oPassphraseFD,    "passphrase-fd", "@"),
   ARGPARSE_s_s (oPassphraseFile,  "passphrase-file", "@"),
   ARGPARSE_s_i (oPassphraseRepeat,"passphrase-repeat", "@"),
   ARGPARSE_s_s (oPinentryMode,    "pinentry-mode", "@"),
   ARGPARSE_s_n (oForceSignKey,    "force-sign-key", "@"),
 
   ARGPARSE_header (NULL, N_("Other options")),
 
   ARGPARSE_s_s (oRequestOrigin,   "request-origin", "@"),
   ARGPARSE_s_s (oDisplay,    "display",    "@"),
   ARGPARSE_s_s (oTTYname,    "ttyname",    "@"),
   ARGPARSE_s_s (oTTYtype,    "ttytype",    "@"),
   ARGPARSE_s_s (oLCctype,    "lc-ctype",   "@"),
   ARGPARSE_s_s (oLCmessages, "lc-messages","@"),
   ARGPARSE_s_s (oXauthority, "xauthority", "@"),
   ARGPARSE_s_s (oChUid,      "chuid",      "@"),
   ARGPARSE_s_n (oNoAutostart, "no-autostart", "@"),
   ARGPARSE_s_n (oUseKeyboxd,    "use-keyboxd", "@"),
   /* Options which can be used in special circumstances. They are not
    * published and we hope they are never required.  */
   ARGPARSE_s_n (oUseOnlyOpenPGPCard, "use-only-openpgp-card", "@"),
   /* Esoteric compatibility options.  */
   ARGPARSE_s_n (oRFC2440Text,      "rfc2440-text", "@"),
   ARGPARSE_s_n (oNoRFC2440Text, "no-rfc2440-text", "@"),
 
   ARGPARSE_header (NULL, ""),  /* Stop the header group.  */
 
   /* Aliases.  I constantly mistype these, and assume other people do
      as well. */
   ARGPARSE_s_s (oPersonalCipherPreferences, "personal-cipher-prefs", "@"),
   ARGPARSE_s_s (oPersonalAEADPreferences,   "personal-aead-prefs", "@"),
   ARGPARSE_s_s (oPersonalDigestPreferences, "personal-digest-prefs", "@"),
   ARGPARSE_s_s (oPersonalCompressPreferences, "personal-compress-prefs", "@"),
 
   /* These two are aliases to help users of the PGP command line
      product use gpg with minimal pain.  Many commands are common
      already as they seem to have borrowed commands from us.  Now I'm
      returning the favor. */
   ARGPARSE_s_s (oLocalUser, "sign-with", "@"),
   ARGPARSE_s_s (oRecipient, "user", "@"),
 
 
   /* Dummy options with warnings.  */
   ARGPARSE_s_n (oUseAgent,      "use-agent", "@"),
   ARGPARSE_s_n (oNoUseAgent, "no-use-agent", "@"),
   ARGPARSE_s_s (oGpgAgentInfo, "gpg-agent-info", "@"),
   ARGPARSE_s_s (oReaderPort, "reader-port", "@"),
   ARGPARSE_s_s (octapiDriver, "ctapi-driver", "@"),
   ARGPARSE_s_s (opcscDriver, "pcsc-driver", "@"),
   ARGPARSE_s_n (oDisableCCID, "disable-ccid", "@"),
   ARGPARSE_s_n (oHonorHttpProxy, "honor-http-proxy", "@"),
   ARGPARSE_s_s (oTOFUDBFormat, "tofu-db-format", "@"),
 
   /* Dummy options.  */
   ARGPARSE_ignore (oStrict,     "strict"),
   ARGPARSE_ignore (oNoStrict,   "no-strict"),
   ARGPARSE_ignore (oLoadExtension, "load-extension"),  /* from 1.4. */
 
   ARGPARSE_s_n (oNoop, "sk-comments", "@"),
   ARGPARSE_s_n (oNoop, "no-sk-comments", "@"),
   ARGPARSE_s_n (oNoop, "compress-keys", "@"),
   ARGPARSE_s_n (oNoop, "compress-sigs", "@"),
   ARGPARSE_s_n (oNoop, "force-v3-sigs", "@"),
   ARGPARSE_s_n (oNoop, "no-force-v3-sigs", "@"),
   ARGPARSE_s_n (oNoop, "force-v4-certs", "@"),
   ARGPARSE_s_n (oNoop, "no-force-v4-certs", "@"),
   ARGPARSE_s_n (oNoop, "no-mdc-warning", "@"),
   ARGPARSE_s_n (oNoop, "force-mdc", "@"),
   ARGPARSE_s_n (oNoop, "no-force-mdc", "@"),
   ARGPARSE_s_n (oNoop, "disable-mdc", "@"),
   ARGPARSE_s_n (oNoop, "no-disable-mdc", "@"),
   ARGPARSE_s_n (oNoop, "allow-multisig-verification", "@"),
   ARGPARSE_s_n (oNoop, "allow-multiple-messages", "@"),
   ARGPARSE_s_n (oNoop, "no-allow-multiple-messages", "@"),
 
 
   ARGPARSE_group (302, N_(
   "@\n(See the man page for a complete listing of all commands and options)\n"
 		      )),
 
   ARGPARSE_group (303, N_("@\nExamples:\n\n"
     " -se -r Bob [file]          sign and encrypt for user Bob\n"
     " --clear-sign [file]        make a clear text signature\n"
     " --detach-sign [file]       make a detached signature\n"
     " --list-keys [names]        show keys\n"
     " --fingerprint [names]      show fingerprints\n")),
 
 
   ARGPARSE_end ()
 };
 
 
 /* The list of supported debug flags.  */
 static struct debug_flags_s debug_flags [] =
   {
     { DBG_PACKET_VALUE , "packet"  },
     { DBG_MPI_VALUE    , "mpi"     },
     { DBG_CRYPTO_VALUE , "crypto"  },
     { DBG_FILTER_VALUE , "filter"  },
     { DBG_IOBUF_VALUE  , "iobuf"   },
     { DBG_MEMORY_VALUE , "memory"  },
     { DBG_CACHE_VALUE  , "cache"   },
     { DBG_MEMSTAT_VALUE, "memstat" },
     { DBG_TRUST_VALUE  , "trust"   },
     { DBG_HASHING_VALUE, "hashing" },
     { DBG_IPC_VALUE    , "ipc"     },
     { DBG_CLOCK_VALUE  , "clock"   },
     { DBG_LOOKUP_VALUE , "lookup"  },
     { DBG_EXTPROG_VALUE, "extprog" },
     { 0, NULL }
   };
 
 
 #ifdef ENABLE_SELINUX_HACKS
 #define ALWAYS_ADD_KEYRINGS 1
 #else
 #define ALWAYS_ADD_KEYRINGS 0
 #endif
 
 /* The list of the default AKL methods.  */
 #define DEFAULT_AKL_LIST "local,wkd"
 
 
 int g10_errors_seen = 0;
 
 static int utf8_strings =
 #ifdef HAVE_W32_SYSTEM
   1
 #else
   0
 #endif
   ;
 static int maybe_setuid = 1;
 static unsigned int opt_set_iobuf_size;
 static unsigned int opt_set_iobuf_size_used;
 
 static char *build_list( const char *text, char letter,
 			 const char *(*mapf)(int), int (*chkf)(int) );
 static void set_cmd( enum cmd_and_opt_values *ret_cmd,
 			enum cmd_and_opt_values new_cmd );
 static void print_mds( const char *fname, int algo );
 static void add_notation_data( const char *string, int which );
 static void add_policy_url( const char *string, int which );
 static void add_keyserver_url( const char *string, int which );
 static void emergency_cleanup (void);
 static void read_sessionkey_from_fd (int fd);
 
 /* NPth wrapper function definitions. */
 ASSUAN_SYSTEM_NPTH_IMPL;
 
 
 static char *
 make_libversion (const char *libname, const char *(*getfnc)(const char*))
 {
   const char *s;
   char *result;
 
   if (maybe_setuid)
     {
       gcry_control (GCRYCTL_INIT_SECMEM, 0, 0);  /* Drop setuid. */
       maybe_setuid = 0;
     }
   s = getfnc (NULL);
   result = xmalloc (strlen (libname) + 1 + strlen (s) + 1);
   strcpy (stpcpy (stpcpy (result, libname), " "), s);
   return result;
 }
 
 
 static int
 build_list_pk_test_algo (int algo)
 {
   /* Show only one "RSA" string.  If RSA_E or RSA_S is available RSA
      is also available.  */
   if (algo == PUBKEY_ALGO_RSA_E
       || algo == PUBKEY_ALGO_RSA_S)
     return GPG_ERR_DIGEST_ALGO;
 
   return openpgp_pk_test_algo (algo);
 }
 
 static const char *
 build_list_pk_algo_name (int algo)
 {
   return openpgp_pk_algo_name (algo);
 }
 
 static int
 build_list_cipher_test_algo (int algo)
 {
   return openpgp_cipher_test_algo (algo);
 }
 
 static const char *
 build_list_cipher_algo_name (int algo)
 {
   return openpgp_cipher_algo_name (algo);
 }
 
 static int
 build_list_aead_test_algo (int algo)
 {
   return openpgp_aead_test_algo (algo);
 }
 
 static const char *
 build_list_aead_algo_name (int algo)
 {
   return openpgp_aead_algo_name (algo);
 }
 
 static int
 build_list_md_test_algo (int algo)
 {
   /* By default we do not accept MD5 based signatures.  To avoid
      confusion we do not announce support for it either.  */
   if (algo == DIGEST_ALGO_MD5)
     return GPG_ERR_DIGEST_ALGO;
 
   return openpgp_md_test_algo (algo);
 }
 
 static const char *
 build_list_md_algo_name (int algo)
 {
   return openpgp_md_algo_name (algo);
 }
 
 
 static const char *
 my_strusage( int level )
 {
   static char *digests, *pubkeys, *ciphers, *zips, *aeads, *ver_gcry;
   const char *p;
 
   switch( level ) {
       case  9: p = "GPL-3.0-or-later"; break;
       case 11: p = "@GPG@ (@GNUPG@)";
 	break;
       case 13: p = VERSION; break;
       case 14: p = GNUPG_DEF_COPYRIGHT_LINE; break;
 
       case 17: p = PRINTABLE_OS_NAME; break;
       case 19: p = _("Please report bugs to <@EMAIL@>.\n"); break;
 
     case 20:
       if (!ver_gcry)
         ver_gcry = make_libversion ("libgcrypt", gcry_check_version);
       p = ver_gcry;
       break;
 
 #ifdef IS_DEVELOPMENT_VERSION
       case 25:
 	p="NOTE: THIS IS A DEVELOPMENT VERSION!";
 	break;
       case 26:
 	p="It is only intended for test purposes and should NOT be";
 	break;
       case 27:
 	p="used in a production environment or with production keys!";
 	break;
 #endif
 
       case 1:
       case 40:	p =
 	    _("Usage: @GPG@ [options] [files] (-h for help)");
 	break;
       case 41:	p =
 	    _("Syntax: @GPG@ [options] [files]\n"
 	      "Sign, check, encrypt or decrypt\n"
 	      "Default operation depends on the input data\n");
 	break;
 
       case 31: p = "\nHome: "; break;
 #ifndef __riscos__
       case 32: p = gnupg_homedir (); break;
 #else /* __riscos__ */
       case 32: p = make_filename(gnupg_homedir (), NULL); break;
 #endif /* __riscos__ */
       case 33: p = _("\nSupported algorithms:\n"); break;
       case 34:
 	if (!pubkeys)
             pubkeys = build_list (_("Pubkey: "), 1,
                                   build_list_pk_algo_name,
                                   build_list_pk_test_algo );
 	p = pubkeys;
 	break;
       case 35:
 	if( !ciphers )
 	    ciphers = build_list(_("Cipher: "), 'S',
                                  build_list_cipher_algo_name,
                                  build_list_cipher_test_algo );
 	p = ciphers;
 	break;
       case 36:
 	if (!aeads)
           aeads = build_list ("AEAD: ", 'A',
                               build_list_aead_algo_name,
                               build_list_aead_test_algo);
 	p = aeads;
 	break;
       case 37:
 	if( !digests )
 	    digests = build_list(_("Hash: "), 'H',
                                  build_list_md_algo_name,
                                  build_list_md_test_algo );
 	p = digests;
 	break;
       case 38:
 	if( !zips )
 	    zips = build_list(_("Compression: "),'Z',
                               compress_algo_to_string,
                               check_compress_algo);
 	p = zips;
 	break;
 
       case 95:
         p = "1"; /* <-- Enable globbing under Windows (see init.c) */
         break;
 
       default:	p = NULL;
     }
     return p;
 }
 
 
 static char *
 build_list (const char *text, char letter,
 	    const char * (*mapf)(int), int (*chkf)(int))
 {
   membuf_t mb;
   int indent;
   int i, j, len;
   int limit;
   const char *s;
   char *string;
 
   if (maybe_setuid)
     gcry_control (GCRYCTL_INIT_SECMEM, 0, 0);  /* Drop setuid. */
 
   indent = utf8_charcount (text, -1);
   len = 0;
   init_membuf (&mb, 512);
 
   limit = (letter == 'A')? 4 : 110;
   for (i=0; i <= limit; i++ )
     {
       if (!chkf (i) && (s = mapf (i)))
         {
           if (mb.len - len > 60)
             {
               put_membuf_str (&mb, ",\n");
               len = mb.len;
               for (j=0; j < indent; j++)
                 put_membuf_str (&mb, " ");
 	    }
           else if (mb.len)
             put_membuf_str (&mb, ", ");
           else
             put_membuf_str (&mb, text);
 
           put_membuf_str (&mb, s);
           if (opt.verbose && letter)
             {
               char num[20];
               if (letter == 1)
                 snprintf (num, sizeof num, " (%d)", i);
               else
                 snprintf (num, sizeof num, " (%c%d)", letter, i);
               put_membuf_str (&mb, num);
             }
 	}
     }
   if (mb.len)
     put_membuf_str (&mb, "\n");
   put_membuf (&mb, "", 1);
 
   string = get_membuf (&mb, NULL);
   return xrealloc (string, strlen (string)+1);
 }
 
 
 static void
 wrong_args( const char *text)
 {
   es_fprintf (es_stderr, _("usage: %s [options] %s\n"), GPG_NAME, text);
   log_inc_errorcount ();
   g10_exit(2);
 }
 
 
 static char *
 make_username( const char *string )
 {
     char *p;
     if( utf8_strings )
 	p = xstrdup(string);
     else
 	p = native_to_utf8( string );
     return p;
 }
 
 
 static void
 set_opt_session_env (const char *name, const char *value)
 {
   gpg_error_t err;
 
   err = session_env_setenv (opt.session_env, name, value);
   if (err)
     log_fatal ("error setting session environment: %s\n",
                gpg_strerror (err));
 }
 
 
 /* Setup the debugging.  With a LEVEL of NULL only the active debug
    flags are propagated to the subsystems.  With LEVEL set, a specific
    set of debug flags is set; thus overriding all flags already
    set. */
 static void
 set_debug (const char *level)
 {
   int numok = (level && digitp (level));
   int numlvl = numok? atoi (level) : 0;
 
   if (!level)
     ;
   else if (!strcmp (level, "none") || (numok && numlvl < 1))
     opt.debug = 0;
   else if (!strcmp (level, "basic") || (numok && numlvl <= 2))
     opt.debug = DBG_MEMSTAT_VALUE;
   else if (!strcmp (level, "advanced") || (numok && numlvl <= 5))
     opt.debug = DBG_MEMSTAT_VALUE|DBG_TRUST_VALUE|DBG_EXTPROG_VALUE;
   else if (!strcmp (level, "expert")  || (numok && numlvl <= 8))
     opt.debug = (DBG_MEMSTAT_VALUE|DBG_TRUST_VALUE|DBG_EXTPROG_VALUE
                  |DBG_CACHE_VALUE|DBG_LOOKUP|DBG_FILTER_VALUE|DBG_PACKET_VALUE);
   else if (!strcmp (level, "guru") || numok)
     {
       opt.debug = ~0;
       /* Unless the "guru" string has been used we don't want to allow
          hashing debugging.  The rationale is that people tend to
          select the highest debug value and would then clutter their
          disk with debug files which may reveal confidential data.  */
       if (numok)
         opt.debug &= ~(DBG_HASHING_VALUE);
     }
   else
     {
       log_error (_("invalid debug-level '%s' given\n"), level);
       g10_exit (2);
     }
 
   if ((opt.debug & DBG_MEMORY_VALUE))
     memory_debug_mode = 1;
   if ((opt.debug & DBG_MEMSTAT_VALUE))
     memory_stat_debug_mode = 1;
   if (DBG_MPI)
     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 2);
   if (DBG_CRYPTO)
     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
   if ((opt.debug & DBG_IOBUF_VALUE))
     iobuf_debug_mode = 1;
   gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
 
   if (opt.debug)
     parse_debug_flag (NULL, &opt.debug, debug_flags);
 
   if (opt_set_iobuf_size || opt_set_iobuf_size_used)
     log_debug ("iobuf buffer size is %uk\n",
                iobuf_set_buffer_size (opt_set_iobuf_size));
 }
 
 
 /* We set the screen dimensions for UI purposes.  Do not allow screens
    smaller than 80x24 for the sake of simplicity. */
 static void
 set_screen_dimensions(void)
 {
 #ifndef HAVE_W32_SYSTEM
   char *str;
 
   str=getenv("COLUMNS");
   if(str)
     opt.screen_columns=atoi(str);
 
   str=getenv("LINES");
   if(str)
     opt.screen_lines=atoi(str);
 #endif
 
   if(opt.screen_columns<80 || opt.screen_columns>255)
     opt.screen_columns=80;
 
   if(opt.screen_lines<24 || opt.screen_lines>255)
     opt.screen_lines=24;
 }
 
 
 /* Helper to open a file FNAME either for reading or writing to be
    used with --status-file etc functions.  Not generally useful but it
    avoids the riscos specific functions and well some Windows people
    might like it too.  Prints an error message and returns -1 on
    error.  On success the file descriptor is returned.  */
 static int
 open_info_file (const char *fname, int for_write, int binary)
 {
 #ifdef __riscos__
   return riscos_fdopenfile (fname, for_write);
 #elif defined (ENABLE_SELINUX_HACKS)
   /* We can't allow these even when testing for a secured filename
      because files to be secured might not yet been secured.  This is
      similar to the option file but in that case it is unlikely that
      sensitive information may be retrieved by means of error
      messages.  */
   (void)fname;
   (void)for_write;
   (void)binary;
   return -1;
 #else
   int fd;
 
   if (binary)
     binary = MY_O_BINARY;
 
 /*   if (is_secured_filename (fname)) */
 /*     { */
 /*       fd = -1; */
 /*       gpg_err_set_errno (EPERM); */
 /*     } */
 /*   else */
 /*     { */
       do
         {
           if (for_write)
             fd = gnupg_open (fname, O_CREAT | O_TRUNC | O_WRONLY | binary,
                              S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
           else
             fd = gnupg_open (fname, O_RDONLY | binary, 0);
         }
       while (fd == -1 && errno == EINTR);
 /*     } */
   if ( fd == -1)
     log_error ( for_write? _("can't create '%s': %s\n")
                          : _("can't open '%s': %s\n"), fname, strerror(errno));
 
   return fd;
 #endif
 }
 
 static void
 set_cmd( enum cmd_and_opt_values *ret_cmd, enum cmd_and_opt_values new_cmd )
 {
     enum cmd_and_opt_values cmd = *ret_cmd;
 
     if( !cmd || cmd == new_cmd )
 	cmd = new_cmd;
     else if( cmd == aSign && new_cmd == aEncr )
 	cmd = aSignEncr;
     else if( cmd == aEncr && new_cmd == aSign )
 	cmd = aSignEncr;
     else if( cmd == aSign && new_cmd == aSym )
 	cmd = aSignSym;
     else if( cmd == aSym && new_cmd == aSign )
 	cmd = aSignSym;
     else if( cmd == aSym && new_cmd == aEncr )
 	cmd = aEncrSym;
     else if( cmd == aEncr && new_cmd == aSym )
 	cmd = aEncrSym;
     else if (cmd == aSignEncr && new_cmd == aSym)
         cmd = aSignEncrSym;
     else if (cmd == aSignSym && new_cmd == aEncr)
         cmd = aSignEncrSym;
     else if (cmd == aEncrSym && new_cmd == aSign)
         cmd = aSignEncrSym;
     else if(	( cmd == aSign	   && new_cmd == aClearsign )
 	     || ( cmd == aClearsign && new_cmd == aSign )  )
 	cmd = aClearsign;
     else {
 	log_error(_("conflicting commands\n"));
 	g10_exit(2);
     }
 
     *ret_cmd = cmd;
 }
 
 
 static void
 add_group(char *string)
 {
   char *name,*value;
   struct groupitem *item;
 
   /* Break off the group name */
   name=strsep(&string,"=");
   if(string==NULL)
     {
       log_error(_("no = sign found in group definition '%s'\n"),name);
       return;
     }
 
   trim_trailing_ws(name,strlen(name));
 
   /* Does this group already exist? */
   for(item=opt.grouplist;item;item=item->next)
     if(strcasecmp(item->name,name)==0)
       break;
 
   if(!item)
     {
       item=xmalloc(sizeof(struct groupitem));
       item->name=name;
       item->next=opt.grouplist;
       item->values=NULL;
       opt.grouplist=item;
     }
 
   /* Break apart the values */
   while ((value= strsep(&string," \t")))
     {
       if (*value)
         add_to_strlist2(&item->values,value,utf8_strings);
     }
 }
 
 
 static void
 rm_group(char *name)
 {
   struct groupitem *item,*last=NULL;
 
   trim_trailing_ws(name,strlen(name));
 
   for(item=opt.grouplist;item;last=item,item=item->next)
     {
       if(strcasecmp(item->name,name)==0)
 	{
 	  if(last)
 	    last->next=item->next;
 	  else
 	    opt.grouplist=item->next;
 
 	  free_strlist(item->values);
 	  xfree(item);
 	  break;
 	}
     }
 }
 
 
 /* We need to check three things.
 
    0) The homedir.  It must be x00, a directory, and owned by the
    user.
 
    1) The options/gpg.conf file.  Okay unless it or its containing
    directory is group or other writable or not owned by us.  Disable
    exec in this case.
 
    2) Extensions.  Same as #1.
 
    Returns true if the item is unsafe. */
 static int
 check_permissions (const char *path, int item)
 {
 #if defined(HAVE_STAT) && !defined(HAVE_DOSISH_SYSTEM)
   static int homedir_cache=-1;
   char *tmppath,*dir;
   struct stat statbuf,dirbuf;
   int homedir=0,ret=0,checkonly=0;
   int perm=0,own=0,enc_dir_perm=0,enc_dir_own=0;
 
   if(opt.no_perm_warn)
     return 0;
 
   log_assert(item==0 || item==1 || item==2);
 
   /* extensions may attach a path */
   if(item==2 && path[0]!=DIRSEP_C)
     {
       if(strchr(path,DIRSEP_C))
 	tmppath=make_filename(path,NULL);
       else
 	tmppath=make_filename(gnupg_libdir (),path,NULL);
     }
   else
     tmppath=xstrdup(path);
 
   /* If the item is located in the homedir, but isn't the homedir,
      don't continue if we already checked the homedir itself.  This is
      to avoid user confusion with an extra options file warning which
      could be rectified if the homedir itself had proper
      permissions. */
   if(item!=0 && homedir_cache>-1
      && !ascii_strncasecmp (gnupg_homedir (), tmppath,
                             strlen (gnupg_homedir ())))
     {
       ret=homedir_cache;
       goto end;
     }
 
   /* It's okay if the file or directory doesn't exist */
   if (gnupg_stat (tmppath,&statbuf))
     {
       ret=0;
       goto end;
     }
 
   /* Now check the enclosing directory.  Theoretically, we could walk
      this test up to the root directory /, but for the sake of sanity,
      I'm stopping at one level down. */
   dir=make_dirname(tmppath);
 
   if (gnupg_stat (dir,&dirbuf) || !S_ISDIR (dirbuf.st_mode))
     {
       /* Weird error */
+      xfree(dir);
       ret=1;
       goto end;
     }
 
   xfree(dir);
 
   /* Assume failure */
   ret=1;
 
   if(item==0)
     {
       /* The homedir must be x00, a directory, and owned by the user. */
 
       if(S_ISDIR(statbuf.st_mode))
 	{
 	  if(statbuf.st_uid==getuid())
 	    {
 	      if((statbuf.st_mode & (S_IRWXG|S_IRWXO))==0)
 		ret=0;
 	      else
 		perm=1;
 	    }
 	  else
 	    own=1;
 
 	  homedir_cache=ret;
 	}
     }
   else if(item==1 || item==2)
     {
       /* The options or extension file.  Okay unless it or its
 	 containing directory is group or other writable or not owned
 	 by us or root. */
 
       if(S_ISREG(statbuf.st_mode))
 	{
 	  if(statbuf.st_uid==getuid() || statbuf.st_uid==0)
 	    {
 	      if((statbuf.st_mode & (S_IWGRP|S_IWOTH))==0)
 		{
 		  /* it's not writable, so make sure the enclosing
                      directory is also not writable */
 		  if(dirbuf.st_uid==getuid() || dirbuf.st_uid==0)
 		    {
 		      if((dirbuf.st_mode & (S_IWGRP|S_IWOTH))==0)
 			ret=0;
 		      else
 			enc_dir_perm=1;
 		    }
 		  else
 		    enc_dir_own=1;
 		}
 	      else
 		{
 		  /* it's writable, so the enclosing directory had
                      better not let people get to it. */
 		  if(dirbuf.st_uid==getuid() || dirbuf.st_uid==0)
 		    {
 		      if((dirbuf.st_mode & (S_IRWXG|S_IRWXO))==0)
 			ret=0;
 		      else
 			perm=enc_dir_perm=1; /* unclear which one to fix! */
 		    }
 		  else
 		    enc_dir_own=1;
 		}
 	    }
 	  else
 	    own=1;
 	}
     }
   else
     BUG();
 
   if(!checkonly)
     {
       if(own)
 	{
 	  if(item==0)
 	    log_info(_("WARNING: unsafe ownership on"
 		       " homedir '%s'\n"),tmppath);
 	  else if(item==1)
 	    log_info(_("WARNING: unsafe ownership on"
 		       " configuration file '%s'\n"),tmppath);
 	  else
 	    log_info(_("WARNING: unsafe ownership on"
 		       " extension '%s'\n"),tmppath);
 	}
       if(perm)
 	{
 	  if(item==0)
 	    log_info(_("WARNING: unsafe permissions on"
 		       " homedir '%s'\n"),tmppath);
 	  else if(item==1)
 	    log_info(_("WARNING: unsafe permissions on"
 		       " configuration file '%s'\n"),tmppath);
 	  else
 	    log_info(_("WARNING: unsafe permissions on"
 		       " extension '%s'\n"),tmppath);
 	}
       if(enc_dir_own)
 	{
 	  if(item==0)
 	    log_info(_("WARNING: unsafe enclosing directory ownership on"
 		       " homedir '%s'\n"),tmppath);
 	  else if(item==1)
 	    log_info(_("WARNING: unsafe enclosing directory ownership on"
 		       " configuration file '%s'\n"),tmppath);
 	  else
 	    log_info(_("WARNING: unsafe enclosing directory ownership on"
 		       " extension '%s'\n"),tmppath);
 	}
       if(enc_dir_perm)
 	{
 	  if(item==0)
 	    log_info(_("WARNING: unsafe enclosing directory permissions on"
 		       " homedir '%s'\n"),tmppath);
 	  else if(item==1)
 	    log_info(_("WARNING: unsafe enclosing directory permissions on"
 		       " configuration file '%s'\n"),tmppath);
 	  else
 	    log_info(_("WARNING: unsafe enclosing directory permissions on"
 		       " extension '%s'\n"),tmppath);
 	}
     }
 
  end:
   xfree(tmppath);
 
   if(homedir)
     homedir_cache=ret;
 
   return ret;
 
 #else /*!(HAVE_STAT && !HAVE_DOSISH_SYSTEM)*/
   (void)path;
   (void)item;
   return 0;
 #endif /*!(HAVE_STAT && !HAVE_DOSISH_SYSTEM)*/
 }
 
 
 /* Print the OpenPGP defined algo numbers.  */
 static void
 print_algo_numbers(int (*checker)(int))
 {
   int i,first=1;
 
   for(i=0;i<=110;i++)
     {
       if(!checker(i))
 	{
 	  if(first)
 	    first=0;
 	  else
 	    es_printf (";");
 	  es_printf ("%d",i);
 	}
     }
 }
 
 
 static void
 print_algo_names(int (*checker)(int),const char *(*mapper)(int))
 {
   int i,first=1;
 
   for(i=0;i<=110;i++)
     {
       if(!checker(i))
 	{
 	  if(first)
 	    first=0;
 	  else
 	    es_printf (";");
 	  es_printf ("%s",mapper(i));
 	}
     }
 }
 
 /* In the future, we can do all sorts of interesting configuration
    output here.  For now, just give "group" as the Enigmail folks need
    it, and pubkey, cipher, hash, and compress as they may be useful
    for frontends. */
 static void
 list_config(char *items)
 {
   int show_all = !items;
   char *name = NULL;
   const char *s;
   struct groupitem *giter;
   int first, iter;
 
   if(!opt.with_colons)
     return;
 
   while(show_all || (name=strsep(&items," ")))
     {
       int any=0;
 
       if(show_all || ascii_strcasecmp(name,"group")==0)
 	{
 	  for (giter = opt.grouplist; giter; giter = giter->next)
 	    {
 	      strlist_t sl;
 
 	      es_fprintf (es_stdout, "cfg:group:");
 	      es_write_sanitized (es_stdout, giter->name, strlen(giter->name),
                                   ":", NULL);
 	      es_putc (':', es_stdout);
 
 	      for(sl=giter->values; sl; sl=sl->next)
 		{
 		  es_write_sanitized (es_stdout, sl->d, strlen (sl->d),
                                       ":;", NULL);
 		  if(sl->next)
                     es_printf(";");
 		}
 
               es_printf("\n");
 	    }
 
 	  any=1;
 	}
 
       if(show_all || ascii_strcasecmp(name,"version")==0)
 	{
 	  es_printf("cfg:version:");
 	  es_write_sanitized (es_stdout, VERSION, strlen(VERSION), ":", NULL);
           es_printf ("\n");
 	  any=1;
 	}
 
       if(show_all || ascii_strcasecmp(name,"pubkey")==0)
 	{
 	  es_printf ("cfg:pubkey:");
 	  print_algo_numbers (build_list_pk_test_algo);
 	  es_printf ("\n");
 	  any=1;
 	}
 
       if(show_all || ascii_strcasecmp(name,"pubkeyname")==0)
 	{
 	  es_printf ("cfg:pubkeyname:");
 	  print_algo_names (build_list_pk_test_algo,
                             build_list_pk_algo_name);
 	  es_printf ("\n");
 	  any=1;
 	}
 
       if(show_all || ascii_strcasecmp(name,"cipher")==0)
 	{
 	  es_printf ("cfg:cipher:");
 	  print_algo_numbers (build_list_cipher_test_algo);
 	  es_printf ("\n");
 	  any=1;
 	}
 
       if (show_all || !ascii_strcasecmp (name,"ciphername"))
 	{
 	  es_printf ("cfg:ciphername:");
 	  print_algo_names (build_list_cipher_test_algo,
                             build_list_cipher_algo_name);
 	  es_printf ("\n");
 	  any = 1;
 	}
 
       if(show_all
 	 || ascii_strcasecmp(name,"digest")==0
 	 || ascii_strcasecmp(name,"hash")==0)
 	{
 	  es_printf ("cfg:digest:");
 	  print_algo_numbers (build_list_md_test_algo);
 	  es_printf ("\n");
 	  any=1;
 	}
 
       if (show_all
           || !ascii_strcasecmp(name,"digestname")
           || !ascii_strcasecmp(name,"hashname"))
 	{
 	  es_printf ("cfg:digestname:");
 	  print_algo_names (build_list_md_test_algo,
                             build_list_md_algo_name);
 	  es_printf ("\n");
 	  any=1;
 	}
 
       if(show_all || ascii_strcasecmp(name,"compress")==0)
 	{
 	  es_printf ("cfg:compress:");
 	  print_algo_numbers(check_compress_algo);
 	  es_printf ("\n");
 	  any=1;
 	}
 
       if(show_all || ascii_strcasecmp (name, "compressname") == 0)
 	{
 	  es_printf ("cfg:compressname:");
 	  print_algo_names (check_compress_algo,
 			    compress_algo_to_string);
 	  es_printf ("\n");
 	  any=1;
 	}
 
       if (show_all || !ascii_strcasecmp(name,"ccid-reader-id"))
 	{
           /* We ignore this for GnuPG 1.4 backward compatibility.  */
 	  any=1;
 	}
 
       if (show_all || !ascii_strcasecmp (name,"curve"))
 	{
 	  es_printf ("cfg:curve:");
           for (iter=0, first=1; (s = openpgp_enum_curves (&iter)); first=0)
             es_printf ("%s%s", first?"":";", s);
 	  es_printf ("\n");
 	  any=1;
 	}
 
       /* Curve OIDs are rarely useful and thus only printed if requested.  */
       if (name && !ascii_strcasecmp (name,"curveoid"))
 	{
 	  es_printf ("cfg:curveoid:");
           for (iter=0, first=1; (s = openpgp_enum_curves (&iter)); first = 0)
             {
               s = openpgp_curve_to_oid (s, NULL, NULL);
               es_printf ("%s%s", first?"":";", s? s:"[?]");
             }
 	  es_printf ("\n");
 	  any=1;
 	}
 
       if(show_all)
 	break;
 
       if(!any)
 	log_error(_("unknown configuration item '%s'\n"),name);
     }
 }
 
 
 /* List default values for use by gpgconf.  */
 static void
 gpgconf_list (void)
 {
   es_printf ("debug-level:%lu:\"none:\n", GC_OPT_FLAG_DEFAULT);
   es_printf ("compliance:%lu:\"%s:\n", GC_OPT_FLAG_DEFAULT, "gnupg");
 
   /* The next one is an info only item and should match the macros at
      the top of keygen.c  */
   es_printf ("default_pubkey_algo:%lu:\"%s:\n", GC_OPT_FLAG_DEFAULT,
              get_default_pubkey_algo ());
   /* This info only mode tells whether the we are running in de-vs
    * compliance mode.  This does not test all parameters but the basic
    * conditions like a proper RNG and Libgcrypt.  AS of now we always
    * return 0 because this version of gnupg has not yet received an
    * appoval. */
   es_printf ("compliance_de_vs:%lu:%d:\n", GC_OPT_FLAG_DEFAULT,
              0 /*gnupg_rng_is_compliant (CO_DE_VS)*/);
 
   es_printf ("use_keyboxd:%lu:%d:\n", GC_OPT_FLAG_DEFAULT, opt.use_keyboxd);
 
 }
 
 
 static int
 parse_subpacket_list(char *list)
 {
   char *tok;
   byte subpackets[128],i;
   int count=0;
 
   if(!list)
     {
       /* No arguments means all subpackets */
       memset(subpackets+1,1,sizeof(subpackets)-1);
       count=127;
     }
   else
     {
       memset(subpackets,0,sizeof(subpackets));
 
       /* Merge with earlier copy */
       if(opt.show_subpackets)
 	{
 	  byte *in;
 
 	  for(in=opt.show_subpackets;*in;in++)
 	    {
 	      if(*in>127 || *in<1)
 		BUG();
 
 	      if(!subpackets[*in])
 		count++;
 	      subpackets[*in]=1;
 	    }
 	}
 
       while((tok=strsep(&list," ,")))
 	{
 	  if(!*tok)
 	    continue;
 
 	  i=atoi(tok);
 	  if(i>127 || i<1)
 	    return 0;
 
 	  if(!subpackets[i])
 	    count++;
 	  subpackets[i]=1;
 	}
     }
 
   xfree(opt.show_subpackets);
   opt.show_subpackets=xmalloc(count+1);
   opt.show_subpackets[count--]=0;
 
   for(i=1;i<128 && count>=0;i++)
     if(subpackets[i])
       opt.show_subpackets[count--]=i;
 
   return 1;
 }
 
 
 static int
 parse_list_options(char *str)
 {
   char *subpackets=""; /* something that isn't NULL */
   struct parse_options lopts[]=
     {
       {"show-photos",LIST_SHOW_PHOTOS,NULL,
        N_("display photo IDs during key listings")},
       {"show-usage",LIST_SHOW_USAGE,NULL,
        N_("show key usage information during key listings")},
       {"show-policy-urls",LIST_SHOW_POLICY_URLS,NULL,
        N_("show policy URLs during signature listings")},
       {"show-notations",LIST_SHOW_NOTATIONS,NULL,
        N_("show all notations during signature listings")},
       {"show-std-notations",LIST_SHOW_STD_NOTATIONS,NULL,
        N_("show IETF standard notations during signature listings")},
       {"show-standard-notations",LIST_SHOW_STD_NOTATIONS,NULL,
        NULL},
       {"show-user-notations",LIST_SHOW_USER_NOTATIONS,NULL,
        N_("show user-supplied notations during signature listings")},
       {"show-keyserver-urls",LIST_SHOW_KEYSERVER_URLS,NULL,
        N_("show preferred keyserver URLs during signature listings")},
       {"show-uid-validity",LIST_SHOW_UID_VALIDITY,NULL,
        N_("show user ID validity during key listings")},
       {"show-unusable-uids",LIST_SHOW_UNUSABLE_UIDS,NULL,
        N_("show revoked and expired user IDs in key listings")},
       {"show-unusable-subkeys",LIST_SHOW_UNUSABLE_SUBKEYS,NULL,
        N_("show revoked and expired subkeys in key listings")},
       {"show-keyring",LIST_SHOW_KEYRING,NULL,
        N_("show the keyring name in key listings")},
       {"show-sig-expire",LIST_SHOW_SIG_EXPIRE,NULL,
        N_("show expiration dates during signature listings")},
       {"show-sig-subpackets",LIST_SHOW_SIG_SUBPACKETS,NULL,
        NULL},
       {"show-only-fpr-mbox",LIST_SHOW_ONLY_FPR_MBOX, NULL,
        NULL},
       {"sort-sigs", LIST_SORT_SIGS, NULL,
        NULL},
       {NULL,0,NULL,NULL}
     };
 
   /* C99 allows for non-constant initializers, but we'd like to
      compile everywhere, so fill in the show-sig-subpackets argument
      here.  Note that if the parse_options array changes, we'll have
      to change the subscript here. */
   lopts[13].value=&subpackets;
 
   if(parse_options(str,&opt.list_options,lopts,1))
     {
       if(opt.list_options&LIST_SHOW_SIG_SUBPACKETS)
 	{
 	  /* Unset so users can pass multiple lists in. */
 	  opt.list_options&=~LIST_SHOW_SIG_SUBPACKETS;
 	  if(!parse_subpacket_list(subpackets))
 	    return 0;
 	}
       else if(subpackets==NULL && opt.show_subpackets)
 	{
 	  /* User did 'no-show-subpackets' */
 	  xfree(opt.show_subpackets);
 	  opt.show_subpackets=NULL;
 	}
 
       return 1;
     }
   else
     return 0;
 }
 
 
 /* Collapses argc/argv into a single string that must be freed */
 static char *
 collapse_args(int argc,char *argv[])
 {
   char *str=NULL;
   int i,first=1,len=0;
 
   for(i=0;i<argc;i++)
     {
       len+=strlen(argv[i])+2;
       str=xrealloc(str,len);
       if(first)
 	{
 	  str[0]='\0';
 	  first=0;
 	}
       else
 	strcat(str," ");
 
       strcat(str,argv[i]);
     }
 
   return str;
 }
 
 
 #ifndef NO_TRUST_MODELS
 static void
 parse_trust_model(const char *model)
 {
   if(ascii_strcasecmp(model,"pgp")==0)
     opt.trust_model=TM_PGP;
   else if(ascii_strcasecmp(model,"classic")==0)
     opt.trust_model=TM_CLASSIC;
   else if(ascii_strcasecmp(model,"always")==0)
     opt.trust_model=TM_ALWAYS;
   else if(ascii_strcasecmp(model,"direct")==0)
     opt.trust_model=TM_DIRECT;
 #ifdef USE_TOFU
   else if(ascii_strcasecmp(model,"tofu")==0)
     opt.trust_model=TM_TOFU;
   else if(ascii_strcasecmp(model,"tofu+pgp")==0)
     opt.trust_model=TM_TOFU_PGP;
 #endif /*USE_TOFU*/
   else if(ascii_strcasecmp(model,"auto")==0)
     opt.trust_model=TM_AUTO;
   else
     log_error("unknown trust model '%s'\n",model);
 }
 #endif /*NO_TRUST_MODELS*/
 
 
 static int
 parse_tofu_policy (const char *policystr)
 {
 #ifdef USE_TOFU
   struct { const char *keyword; int policy; } list[] = {
     { "auto",    TOFU_POLICY_AUTO },
     { "good",    TOFU_POLICY_GOOD },
     { "unknown", TOFU_POLICY_UNKNOWN },
     { "bad",     TOFU_POLICY_BAD },
     { "ask",     TOFU_POLICY_ASK }
   };
   int i;
 
   if (!ascii_strcasecmp (policystr, "help"))
     {
       log_info (_("valid values for option '%s':\n"), "--tofu-policy");
       for (i=0; i < DIM (list); i++)
         log_info ("  %s\n", list[i].keyword);
       g10_exit (1);
     }
 
   for (i=0; i < DIM (list); i++)
     if (!ascii_strcasecmp (policystr, list[i].keyword))
       return list[i].policy;
 #endif /*USE_TOFU*/
 
   log_error (_("unknown TOFU policy '%s'\n"), policystr);
   if (!opt.quiet)
     log_info (_("(use \"help\" to list choices)\n"));
   g10_exit (1);
 }
 
 
 static struct gnupg_compliance_option compliance_options[] =
   {
     { "gnupg",      oGnuPG },
     { "openpgp",    oOpenPGP },
     { "rfc4880bis", oRFC4880bis },
     { "rfc4880",    oRFC4880 },
     { "rfc2440",    oRFC2440 },
     { "pgp6",       oPGP7 },
     { "pgp7",       oPGP7 },
     { "pgp8",       oPGP8 },
     { "de-vs",      oDE_VS }
   };
 
 
 /* Helper to set compliance related options.  This is a separate
  * function so that it can also be used by the --compliance option
  * parser.  */
 static void
 set_compliance_option (enum cmd_and_opt_values option)
 {
   opt.flags.rfc4880bis = 0;  /* Clear because it is initially set.  */
 
   switch (option)
     {
     case oRFC4880bis:
       opt.flags.rfc4880bis = 1;
       opt.compliance = CO_RFC4880;
       opt.flags.dsa2 = 1;
       opt.flags.require_cross_cert = 1;
       opt.rfc2440_text = 0;
       opt.allow_non_selfsigned_uid = 1;
       opt.allow_freeform_uid = 1;
       opt.escape_from = 1;
       opt.not_dash_escaped = 0;
       opt.def_cipher_algo = 0;
       opt.def_aead_algo = 0;
       opt.def_digest_algo = 0;
       opt.cert_digest_algo = 0;
       opt.compress_algo = -1;
       opt.s2k_mode = 3; /* iterated+salted */
       opt.s2k_digest_algo = DIGEST_ALGO_SHA256;
       opt.s2k_cipher_algo = CIPHER_ALGO_AES256;
       break;
     case oOpenPGP:
     case oRFC4880:
       /* This is effectively the same as RFC2440, but with
          "--enable-dsa2 --no-rfc2440-text --escape-from-lines
          --require-cross-certification". */
       opt.compliance = CO_RFC4880;
       opt.flags.dsa2 = 1;
       opt.flags.require_cross_cert = 1;
       opt.rfc2440_text = 0;
       opt.allow_non_selfsigned_uid = 1;
       opt.allow_freeform_uid = 1;
       opt.escape_from = 1;
       opt.not_dash_escaped = 0;
       opt.def_cipher_algo = 0;
       opt.def_aead_algo = 0;
       opt.def_digest_algo = 0;
       opt.cert_digest_algo = 0;
       opt.compress_algo = -1;
       opt.s2k_mode = 3; /* iterated+salted */
       opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
       opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
       opt.flags.allow_old_cipher_algos = 1;
       break;
     case oRFC2440:
       opt.compliance = CO_RFC2440;
       opt.flags.dsa2 = 0;
       opt.rfc2440_text = 1;
       opt.allow_non_selfsigned_uid = 1;
       opt.allow_freeform_uid = 1;
       opt.escape_from = 0;
       opt.not_dash_escaped = 0;
       opt.def_cipher_algo = 0;
       opt.def_aead_algo = 0;
       opt.def_digest_algo = 0;
       opt.cert_digest_algo = 0;
       opt.compress_algo = -1;
       opt.s2k_mode = 3; /* iterated+salted */
       opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
       opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
       opt.flags.allow_old_cipher_algos = 1;
       break;
     case oPGP7:  opt.compliance = CO_PGP7;  break;
     case oPGP8:  opt.compliance = CO_PGP8;  break;
     case oGnuPG:
       opt.compliance = CO_GNUPG;
       opt.flags.rfc4880bis = 1;
       break;
 
     case oDE_VS:
       set_compliance_option (oOpenPGP);
       opt.compliance = CO_DE_VS;
       opt.def_aead_algo = 0;
       /* We divert here from the backward compatible rfc4880 algos.  */
       opt.s2k_digest_algo = DIGEST_ALGO_SHA256;
       opt.s2k_cipher_algo = CIPHER_ALGO_AES256;
       break;
 
     default:
       BUG ();
     }
 }
 
 
 
 
 
 
 /* This function called to initialized a new control object.  It is
    assumed that this object has been zeroed out before calling this
    function. */
 static void
 gpg_init_default_ctrl (ctrl_t ctrl)
 {
   ctrl->magic = SERVER_CONTROL_MAGIC;
 }
 
 
 /* This function is called to deinitialize a control object.  It is
    not deallocated. */
 static void
 gpg_deinit_default_ctrl (ctrl_t ctrl)
 {
 #ifdef USE_TOFU
   tofu_closedbs (ctrl);
 #endif
   gpg_dirmngr_deinit_session_data (ctrl);
 
   keydb_release (ctrl->cached_getkey_kdb);
   gpg_keyboxd_deinit_session_data (ctrl);
   xfree (ctrl->secret_keygrips);
   ctrl->secret_keygrips = NULL;
 }
 
 
 int
 main (int argc, char **argv)
 {
     gpgrt_argparse_t pargs;
     IOBUF a;
     int rc=0;
     int orig_argc;
     char **orig_argv;
     const char *fname;
     char *username;
     int may_coredump;
     strlist_t sl;
     strlist_t remusr = NULL;
     strlist_t locusr = NULL;
     strlist_t nrings = NULL;
     armor_filter_context_t *afx = NULL;
     int detached_sig = 0;
     char *last_configname = NULL;
     const char *configname = NULL; /* NULL or points to last_configname.
                                     * NULL also indicates that we are
                                     * processing options from the cmdline.  */
     int debug_argparser = 0;
     int default_keyring = 1;
     int greeting = 0;
     int nogreeting = 0;
     char *logfile = NULL;
     int use_random_seed = 1;
     enum cmd_and_opt_values cmd = 0;
     const char *debug_level = NULL;
 #ifndef NO_TRUST_MODELS
     const char *trustdb_name = NULL;
 #endif /*!NO_TRUST_MODELS*/
     char *def_cipher_string = NULL;
     char *def_aead_string = NULL;
     char *def_digest_string = NULL;
     char *compress_algo_string = NULL;
     char *cert_digest_string = NULL;
     char *s2k_cipher_string = NULL;
     char *s2k_digest_string = NULL;
     char *pers_cipher_list = NULL;
     char *pers_aead_list = NULL;
     char *pers_digest_list = NULL;
     char *pers_compress_list = NULL;
     int eyes_only=0;
     int multifile=0;
     int pwfd = -1;
     int ovrseskeyfd = -1;
     int fpr_maybe_cmd = 0; /* --fingerprint maybe a command.  */
     int any_explicit_recipient = 0;
     int default_akl = 1;
     int require_secmem = 0;
     int got_secmem = 0;
     struct assuan_malloc_hooks malloc_hooks;
     ctrl_t ctrl;
 
     static int print_dane_records;
     static int allow_large_chunks;
     static const char *homedirvalue;
     static const char *changeuser;
 
 
 #ifdef __riscos__
     opt.lock_once = 1;
 #endif /* __riscos__ */
 
     /* Please note that we may running SUID(ROOT), so be very CAREFUL
        when adding any stuff between here and the call to
        secmem_init() somewhere after the option parsing. */
     early_system_init ();
     gnupg_reopen_std (GPG_NAME);
     trap_unaligned ();
     gnupg_rl_initialize ();
     gpgrt_set_strusage (my_strusage);
     gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
     log_set_prefix (GPG_NAME, GPGRT_LOG_WITH_PREFIX);
 
     /* Make sure that our subsystems are ready.  */
     i18n_init();
     init_common_subsystems (&argc, &argv);
 
     /* Use our own logging handler for Libcgrypt.  */
     setup_libgcrypt_logging ();
 
     /* Put random number into secure memory */
     gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
 
     may_coredump = disable_core_dumps();
 
     gnupg_init_signals (0, emergency_cleanup);
 
     dotlock_create (NULL, 0); /* Register lock file cleanup. */
 
     /* Tell the compliance module who we are.  */
     gnupg_initialize_compliance (GNUPG_MODULE_NAME_GPG);
 
     opt.autostart = 1;
     opt.session_env = session_env_new ();
     if (!opt.session_env)
       log_fatal ("error allocating session environment block: %s\n",
                  strerror (errno));
 
     opt.command_fd = -1; /* no command fd */
     opt.compress_level = -1; /* defaults to standard compress level */
     opt.bz2_compress_level = -1; /* defaults to standard compress level */
     /* note: if you change these lines, look at oOpenPGP */
     opt.def_cipher_algo = 0;
     opt.def_aead_algo = 0;
     opt.def_digest_algo = 0;
     opt.cert_digest_algo = 0;
     opt.compress_algo = -1; /* defaults to DEFAULT_COMPRESS_ALGO */
     opt.s2k_mode = 3; /* iterated+salted */
     opt.s2k_count = 0; /* Auto-calibrate when needed.  */
     opt.s2k_cipher_algo = DEFAULT_CIPHER_ALGO;
     opt.completes_needed = 1;
     opt.marginals_needed = 3;
     opt.max_cert_depth = 5;
     opt.escape_from = 1;
     opt.flags.require_cross_cert = 1;
     opt.import_options = (IMPORT_REPAIR_KEYS
                           | IMPORT_COLLAPSE_UIDS
                           | IMPORT_COLLAPSE_SUBKEYS);
     opt.export_options = EXPORT_ATTRIBUTES;
     opt.keyserver_options.import_options = (IMPORT_REPAIR_KEYS
 					    | IMPORT_REPAIR_PKS_SUBKEY_BUG
                                             | IMPORT_SELF_SIGS_ONLY
                                             | IMPORT_COLLAPSE_UIDS
                                             | IMPORT_COLLAPSE_SUBKEYS
                                             | IMPORT_CLEAN);
     opt.keyserver_options.export_options = EXPORT_ATTRIBUTES;
     opt.keyserver_options.options = 0;
     opt.verify_options = (LIST_SHOW_UID_VALIDITY
                           | VERIFY_SHOW_POLICY_URLS
                           | VERIFY_SHOW_STD_NOTATIONS
                           | VERIFY_SHOW_KEYSERVER_URLS);
     opt.list_options   = (LIST_SHOW_UID_VALIDITY
                           | LIST_SORT_SIGS
                           | LIST_SHOW_USAGE);
 #ifdef NO_TRUST_MODELS
     opt.trust_model = TM_ALWAYS;
 #else
     opt.trust_model = TM_AUTO;
 #endif
     opt.tofu_default_policy = TOFU_POLICY_AUTO;
     opt.mangle_dos_filenames = 0;
     opt.min_cert_level = 2;
     set_screen_dimensions ();
     opt.keyid_format = KF_NONE;
     opt.def_sig_expire = "0";
     opt.def_cert_expire = "0";
     opt.passphrase_repeat = 1;
     opt.emit_version = 0;
     opt.weak_digests = NULL;
     opt.compliance = CO_GNUPG;
     opt.flags.rfc4880bis = 1;
 
     /* Check special options given on the command line.  */
     orig_argc = argc;
     orig_argv = argv;
     pargs.argc = &argc;
     pargs.argv = &argv;
     pargs.flags= (ARGPARSE_FLAG_KEEP | ARGPARSE_FLAG_NOVERSION);
     while (gpgrt_argparse (NULL, &pargs, opts))
       {
 	switch (pargs.r_opt)
           {
           case oDebug:
           case oDebugAll:
             debug_argparser++;
             break;
 
           case oDebugIOLBF:
             es_setvbuf (es_stdout, NULL, _IOLBF, 0);
             break;
 
           case oNoOptions:
             /* Set here here because the homedir would otherwise be
              * created before main option parsing starts.  */
             opt.no_homedir_creation = 1;
             break;
 
           case oHomedir:
             homedirvalue = pargs.r.ret_str;
             break;
 
           case oChUid:
             changeuser = pargs.r.ret_str;
             break;
 
           case oNoPermissionWarn:
             opt.no_perm_warn = 1;
             break;
           }
       }
     /* Reset the flags.  */
     pargs.flags &= ~(ARGPARSE_FLAG_KEEP | ARGPARSE_FLAG_NOVERSION);
 
 #ifdef HAVE_DOSISH_SYSTEM
     /* FIXME: Do we still need this?  No: gnupg_homedir calls
      * make_filename which changes the slashed anyway.  IsDBCSLeadByte still
      * needed?  See bug #561.  */
     if ( strchr (gnupg_homedir (), '\\') ) {
       char *d, *buf = xmalloc (strlen (gnupg_homedir ())+1);
       const char *s;
       for (d=buf, s = gnupg_homedir (); *s; s++)
           {
             *d++ = *s == '\\'? '/': *s;
 #ifdef HAVE_W32_SYSTEM
             if (s[1] && IsDBCSLeadByte (*s))
               *d++ = *++s;
 #endif
           }
         *d = 0;
         gnupg_set_homedir (buf);
     }
 #endif
 
     /* Initialize the secure memory. */
     if (!gcry_control (GCRYCTL_INIT_SECMEM, SECMEM_BUFFER_SIZE, 0))
       got_secmem = 1;
 #if defined(HAVE_GETUID) && defined(HAVE_GETEUID)
     /* There should be no way to get to this spot while still carrying
        setuid privs.  Just in case, bomb out if we are. */
     if ( getuid () != geteuid () )
       BUG ();
 #endif
     maybe_setuid = 0;
 
     /* Okay, we are now working under our real uid */
 
     /* malloc hooks go here ... */
     malloc_hooks.malloc = gcry_malloc;
     malloc_hooks.realloc = gcry_realloc;
     malloc_hooks.free = gcry_free;
     assuan_set_malloc_hooks (&malloc_hooks);
     assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
     setup_libassuan_logging (&opt.debug, NULL);
 
     /* Change UID and then set the homedir.  */
     if (changeuser && gnupg_chuid (changeuser, 0))
       log_inc_errorcount (); /* Force later termination.  */
     gnupg_set_homedir (homedirvalue);
 
     /* Set default options which require that malloc stuff is ready.  */
     additional_weak_digest ("MD5");
     parse_auto_key_locate (DEFAULT_AKL_LIST);
 
     argc = orig_argc;
     argv = orig_argv;
     pargs.argc = &argc;
     pargs.argv = &argv;
     /* We are re-using the struct, thus the reset flag.  We OR the
      * flags so that the internal intialized flag won't be cleared. */
     pargs.flags |= (ARGPARSE_FLAG_RESET
                     | ARGPARSE_FLAG_KEEP
                     | ARGPARSE_FLAG_SYS
                     | ARGPARSE_FLAG_USER
                     | ARGPARSE_FLAG_USERVERS);
 
     /* By this point we have a homedir, and cannot change it. */
     check_permissions (gnupg_homedir (), 0);
 
     /* The configuraton directories for use by gpgrt_argparser.  */
     gpgrt_set_confdir (GPGRT_CONFDIR_SYS, gnupg_sysconfdir ());
     gpgrt_set_confdir (GPGRT_CONFDIR_USER, gnupg_homedir ());
 
     while (gpgrt_argparser (&pargs, opts, GPG_NAME EXTSEP_S "conf" ))
       {
 	switch (pargs.r_opt)
 	  {
           case ARGPARSE_CONFFILE:
             if (debug_argparser)
               log_info (_("reading options from '%s'\n"),
                          pargs.r_type? pargs.r.ret_str: "[cmdline]");
             if (pargs.r_type)
               {
                 xfree (last_configname);
                 last_configname = xstrdup (pargs.r.ret_str);
                 configname = last_configname;
                 if (is_secured_filename (configname))
                   {
                     pargs.r_opt = ARGPARSE_PERMISSION_ERROR;
                     pargs.err = ARGPARSE_PRINT_ERROR;
                   }
                 else if (strncmp (configname, gnupg_sysconfdir (),
                                   strlen (gnupg_sysconfdir ())))
                   {
                     /* This is not the global config file and thus we
                      * need to check the permissions: If the file is
                      * unsafe, then disable any external programs for
                      * keyserver calls or photo IDs.  Since the
                      * external program to call is set in the options
                      * file, a unsafe options file can lead to an
                      * arbitrary program being run. */
                     if (check_permissions (configname, 1))
                       opt.exec_disable=1;
                   }
               }
             else
               configname = NULL;
             break;
 
             /* case oOptions: */
             /* case oNoOptions: */
             /* We will never see these options here because
              * gpgrt_argparse handles them for us.  */
             /* break */
 
 	  case aListConfig:
 	  case aListGcryptConfig:
           case aGPGConfList:
           case aGPGConfTest:
             set_cmd (&cmd, pargs.r_opt);
             /* Do not register a keyring for these commands.  */
             default_keyring = -1;
             break;
 
 	  case aCheckKeys:
 	  case aListPackets:
 	  case aImport:
 	  case aFastImport:
 	  case aSendKeys:
 	  case aRecvKeys:
 	  case aSearchKeys:
 	  case aRefreshKeys:
 	  case aFetchKeys:
 	  case aExport:
 #ifdef ENABLE_CARD_SUPPORT
           case aCardStatus:
           case aCardEdit:
           case aChangePIN:
 #endif /* ENABLE_CARD_SUPPORT*/
 	  case aListKeys:
 	  case aLocateKeys:
 	  case aLocateExtKeys:
 	  case aListSigs:
 	  case aExportSecret:
 	  case aExportSecretSub:
 	  case aExportSshKey:
 	  case aSym:
 	  case aClearsign:
 	  case aGenRevoke:
 	  case aDesigRevoke:
 	  case aPrimegen:
 	  case aGenRandom:
 	  case aPrintMD:
 	  case aPrintMDs:
 	  case aListTrustDB:
 	  case aCheckTrustDB:
 	  case aUpdateTrustDB:
 	  case aFixTrustDB:
 	  case aListTrustPath:
 	  case aDeArmor:
 	  case aEnArmor:
 	  case aSign:
 	  case aQuickSignKey:
 	  case aQuickLSignKey:
 	  case aQuickRevSig:
 	  case aSignKey:
 	  case aLSignKey:
 	  case aStore:
 	  case aQuickKeygen:
 	  case aQuickAddUid:
 	  case aQuickAddKey:
 	  case aQuickRevUid:
 	  case aQuickSetExpire:
 	  case aQuickSetPrimaryUid:
 	  case aExportOwnerTrust:
 	  case aImportOwnerTrust:
           case aRebuildKeydbCaches:
             set_cmd (&cmd, pargs.r_opt);
             break;
 
 	  case aKeygen:
 	  case aFullKeygen:
 	  case aEditKey:
 	  case aDeleteSecretKeys:
 	  case aDeleteSecretAndPublicKeys:
 	  case aDeleteKeys:
           case aPasswd:
             set_cmd (&cmd, pargs.r_opt);
             greeting=1;
             break;
 
 	  case aShowKeys:
             set_cmd (&cmd, pargs.r_opt);
             opt.import_options |= IMPORT_SHOW;
             opt.import_options |= IMPORT_DRY_RUN;
             opt.import_options &= ~IMPORT_REPAIR_KEYS;
             opt.list_options |= LIST_SHOW_UNUSABLE_UIDS;
             opt.list_options |= LIST_SHOW_UNUSABLE_SUBKEYS;
             opt.list_options |= LIST_SHOW_NOTATIONS;
             opt.list_options |= LIST_SHOW_POLICY_URLS;
             break;
 
 	  case aDetachedSign: detached_sig = 1; set_cmd( &cmd, aSign ); break;
 
 	  case aDecryptFiles: multifile=1; /* fall through */
 	  case aDecrypt: set_cmd( &cmd, aDecrypt); break;
 
 	  case aEncrFiles: multifile=1; /* fall through */
 	  case aEncr: set_cmd( &cmd, aEncr); break;
 
 	  case aVerifyFiles: multifile=1; /* fall through */
 	  case aVerify: set_cmd( &cmd, aVerify); break;
 
           case aServer:
             set_cmd (&cmd, pargs.r_opt);
             opt.batch = 1;
             break;
 
           case aTOFUPolicy:
             set_cmd (&cmd, pargs.r_opt);
             break;
 
 	  case oArmor: opt.armor = 1; opt.no_armor=0; break;
 	  case oOutput: opt.outfile = pargs.r.ret_str; break;
 
 	  case oMaxOutput: opt.max_output = pargs.r.ret_ulong; break;
 
           case oInputSizeHint:
             opt.input_size_hint = string_to_u64 (pargs.r.ret_str);
             break;
 
           case oChunkSize:
             opt.chunk_size = pargs.r.ret_int;
             break;
 
 	  case oQuiet: opt.quiet = 1; break;
 	  case oNoTTY: tty_no_terminal(1); break;
 	  case oDryRun: opt.dry_run = 1; break;
 	  case oInteractive: opt.interactive = 1; break;
 	  case oVerbose:
 	    opt.verbose++;
             gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
 	    opt.list_options|=LIST_SHOW_UNUSABLE_UIDS;
 	    opt.list_options|=LIST_SHOW_UNUSABLE_SUBKEYS;
 	    break;
 
 	  case oBatch:
             opt.batch = 1;
             nogreeting = 1;
             break;
 
           case oUseAgent: /* Dummy. */
             break;
 
           case oNoUseAgent:
 	    obsolete_option (configname, pargs.lineno, "no-use-agent");
             break;
 	  case oGpgAgentInfo:
 	    obsolete_option (configname, pargs.lineno, "gpg-agent-info");
             break;
 
           case oUseKeyboxd:
             opt.use_keyboxd = 1;
             break;
 
           case oReaderPort:
 	    obsolete_scdaemon_option (configname, pargs.lineno, "reader-port");
             break;
           case octapiDriver:
 	    obsolete_scdaemon_option (configname, pargs.lineno, "ctapi-driver");
             break;
           case opcscDriver:
 	    obsolete_scdaemon_option (configname, pargs.lineno, "pcsc-driver");
             break;
           case oDisableCCID:
 	    obsolete_scdaemon_option (configname, pargs.lineno, "disable-ccid");
             break;
           case oHonorHttpProxy:
 	    obsolete_option (configname, pargs.lineno, "honor-http-proxy");
             break;
 
 	  case oAnswerYes: opt.answer_yes = 1; break;
 	  case oAnswerNo: opt.answer_no = 1; break;
 
           case oForceSignKey: opt.flags.force_sign_key = 1; break;
 
 	  case oKeyring: append_to_strlist( &nrings, pargs.r.ret_str); break;
 	  case oPrimaryKeyring:
 	    sl = append_to_strlist (&nrings, pargs.r.ret_str);
 	    sl->flags = KEYDB_RESOURCE_FLAG_PRIMARY;
 	    break;
 	  case oShowKeyring:
 	    deprecated_warning(configname,pargs.lineno,"--show-keyring",
 			       "--list-options ","show-keyring");
 	    opt.list_options|=LIST_SHOW_KEYRING;
 	    break;
 
 	  case oDebug:
             if (parse_debug_flag (pargs.r.ret_str, &opt.debug, debug_flags))
               {
                 pargs.r_opt = ARGPARSE_INVALID_ARG;
                 pargs.err = ARGPARSE_PRINT_ERROR;
               }
             break;
 
 	  case oDebugAll: opt.debug = ~0; break;
           case oDebugLevel: debug_level = pargs.r.ret_str; break;
 
           case oDebugIOLBF: break; /* Already set in pre-parse step.  */
 
           case oDebugSetIobufSize:
             opt_set_iobuf_size = pargs.r.ret_ulong;
             opt_set_iobuf_size_used = 1;
             break;
 
           case oDebugAllowLargeChunks:
             allow_large_chunks = 1;
             break;
 
 	  case oStatusFD:
             set_status_fd ( translate_sys2libc_fd_int (pargs.r.ret_int, 1) );
             break;
 	  case oStatusFile:
             set_status_fd ( open_info_file (pargs.r.ret_str, 1, 0) );
             break;
 	  case oAttributeFD:
             set_attrib_fd ( translate_sys2libc_fd_int (pargs.r.ret_int, 1) );
             break;
 	  case oAttributeFile:
             set_attrib_fd ( open_info_file (pargs.r.ret_str, 1, 1) );
             break;
 	  case oLoggerFD:
             log_set_fd (translate_sys2libc_fd_int (pargs.r.ret_int, 1));
             break;
           case oLoggerFile:
             logfile = pargs.r.ret_str;
             break;
 
 	  case oWithFingerprint:
             opt.with_fingerprint = 1;
             opt.fingerprint++;
             break;
 	  case oWithSubkeyFingerprint:
             opt.with_subkey_fingerprint = 1;
             break;
 	  case oWithICAOSpelling:
             opt.with_icao_spelling = 1;
             break;
 	  case oFingerprint:
             opt.fingerprint++;
             fpr_maybe_cmd = 1;
             break;
 
 	  case oWithKeygrip:
             opt.with_keygrip = 1;
             break;
 
 	  case oWithKeyScreening:
             opt.with_key_screening = 1;
             break;
 
 	  case oWithSecret:
             opt.with_secret = 1;
             break;
 
 	  case oWithWKDHash:
             opt.with_wkd_hash = 1;
             break;
 
 	  case oWithKeyOrigin:
             opt.with_key_origin = 1;
             break;
 
 	  case oSecretKeyring:
             /* Ignore this old option.  */
             break;
 
 	  case oNoArmor: opt.no_armor=1; opt.armor=0; break;
 
 	  case oNoDefKeyring:
             if (default_keyring > 0)
               default_keyring = 0;
             break;
 	  case oNoKeyring:
             default_keyring = -1;
             break;
 
 	  case oNoGreeting: nogreeting = 1; break;
 	  case oNoVerbose:
             opt.verbose = 0;
             gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
             opt.list_sigs=0;
             break;
           case oQuickRandom:
             gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
             break;
 	  case oEmitVersion: opt.emit_version++; break;
 	  case oNoEmitVersion: opt.emit_version=0; break;
 	  case oCompletesNeeded: opt.completes_needed = pargs.r.ret_int; break;
 	  case oMarginalsNeeded: opt.marginals_needed = pargs.r.ret_int; break;
 	  case oMaxCertDepth: opt.max_cert_depth = pargs.r.ret_int; break;
 
 #ifndef NO_TRUST_MODELS
 	  case oTrustDBName: trustdb_name = pargs.r.ret_str; break;
 
 #endif /*!NO_TRUST_MODELS*/
 	  case oDefaultKey:
             sl = add_to_strlist (&opt.def_secret_key, pargs.r.ret_str);
             sl->flags = (pargs.r_opt << PK_LIST_SHIFT);
             if (configname)
               sl->flags |= PK_LIST_CONFIG;
             break;
 	  case oDefRecipient:
             if( *pargs.r.ret_str )
 	      {
 		xfree (opt.def_recipient);
 		opt.def_recipient = make_username(pargs.r.ret_str);
 	      }
             break;
 	  case oDefRecipientSelf:
             xfree(opt.def_recipient); opt.def_recipient = NULL;
             opt.def_recipient_self = 1;
             break;
 	  case oNoDefRecipient:
             xfree(opt.def_recipient); opt.def_recipient = NULL;
             opt.def_recipient_self = 0;
             break;
 	  case oHomedir: break;
           case oChUid: break;  /* Command line only (see above).  */
 	  case oNoBatch: opt.batch = 0; break;
 
           case oWithTofuInfo: opt.with_tofu_info = 1; break;
 
 	  case oWithKeyData: opt.with_key_data=1; /*FALLTHRU*/
 	  case oWithColons: opt.with_colons=':'; break;
 
           case oWithSigCheck: opt.check_sigs = 1; /*FALLTHRU*/
           case oWithSigList: opt.list_sigs = 1; break;
 
 	  case oSkipVerify: opt.skip_verify=1; break;
 
 	  case oSkipHiddenRecipients: opt.skip_hidden_recipients = 1; break;
 	  case oNoSkipHiddenRecipients: opt.skip_hidden_recipients = 0; break;
 
 	  case aListSecretKeys: set_cmd( &cmd, aListSecretKeys); break;
 
 #ifndef NO_TRUST_MODELS
 	    /* There are many programs (like mutt) that call gpg with
 	       --always-trust so keep this option around for a long
 	       time. */
 	  case oAlwaysTrust: opt.trust_model=TM_ALWAYS; break;
 	  case oTrustModel:
 	    parse_trust_model(pargs.r.ret_str);
 	    break;
 #endif /*!NO_TRUST_MODELS*/
 	  case oTOFUDefaultPolicy:
 	    opt.tofu_default_policy = parse_tofu_policy (pargs.r.ret_str);
 	    break;
 	  case oTOFUDBFormat:
 	    obsolete_option (configname, pargs.lineno, "tofu-db-format");
 	    break;
 
 	  case oForceOwnertrust:
 	    log_info(_("Note: %s is not for normal use!\n"),
 		     "--force-ownertrust");
 	    opt.force_ownertrust=string_to_trust_value(pargs.r.ret_str);
 	    if(opt.force_ownertrust==-1)
 	      {
 		log_error("invalid ownertrust '%s'\n",pargs.r.ret_str);
 		opt.force_ownertrust=0;
 	      }
 	    break;
 
           case oNoAutoTrustNewKey: opt.flags.no_auto_trust_new_key = 1; break;
 
           case oCompliance:
 	    {
 	      int compliance = gnupg_parse_compliance_option
                 (pargs.r.ret_str,
                  compliance_options, DIM (compliance_options),
                  opt.quiet);
 	      if (compliance < 0)
 		g10_exit (1);
 	      set_compliance_option (compliance);
 	    }
             break;
           case oOpenPGP:
           case oRFC2440:
           case oRFC4880:
           case oRFC4880bis:
           case oPGP7:
           case oPGP8:
           case oGnuPG:
             set_compliance_option (pargs.r_opt);
             break;
 
           case oRFC2440Text: opt.rfc2440_text=1; break;
           case oNoRFC2440Text: opt.rfc2440_text=0; break;
 
  	  case oSetFilename:
             if(utf8_strings)
               opt.set_filename = pargs.r.ret_str;
             else
               opt.set_filename = native_to_utf8(pargs.r.ret_str);
  	    break;
 	  case oForYourEyesOnly: eyes_only = 1; break;
 	  case oNoForYourEyesOnly: eyes_only = 0; break;
 	  case oSetPolicyURL:
 	    add_policy_url(pargs.r.ret_str,0);
 	    add_policy_url(pargs.r.ret_str,1);
 	    break;
 	  case oSigPolicyURL: add_policy_url(pargs.r.ret_str,0); break;
 	  case oCertPolicyURL: add_policy_url(pargs.r.ret_str,1); break;
           case oShowPolicyURL:
 	    deprecated_warning(configname,pargs.lineno,"--show-policy-url",
 			       "--list-options ","show-policy-urls");
 	    deprecated_warning(configname,pargs.lineno,"--show-policy-url",
 			       "--verify-options ","show-policy-urls");
 	    opt.list_options|=LIST_SHOW_POLICY_URLS;
 	    opt.verify_options|=VERIFY_SHOW_POLICY_URLS;
 	    break;
 	  case oNoShowPolicyURL:
 	    deprecated_warning(configname,pargs.lineno,"--no-show-policy-url",
 			       "--list-options ","no-show-policy-urls");
 	    deprecated_warning(configname,pargs.lineno,"--no-show-policy-url",
 			       "--verify-options ","no-show-policy-urls");
 	    opt.list_options&=~LIST_SHOW_POLICY_URLS;
 	    opt.verify_options&=~VERIFY_SHOW_POLICY_URLS;
 	    break;
 	  case oSigKeyserverURL: add_keyserver_url(pargs.r.ret_str,0); break;
 	  case oUseEmbeddedFilename:
 	    opt.flags.use_embedded_filename=1;
 	    break;
 	  case oNoUseEmbeddedFilename:
 	    opt.flags.use_embedded_filename=0;
 	    break;
 	  case oComment:
 	    if(pargs.r.ret_str[0])
 	      append_to_strlist(&opt.comments,pargs.r.ret_str);
 	    break;
 	  case oDefaultComment:
 	    deprecated_warning(configname,pargs.lineno,
 			       "--default-comment","--no-comments","");
 	    /* fall through */
 	  case oNoComments:
 	    free_strlist(opt.comments);
 	    opt.comments=NULL;
 	    break;
 	  case oThrowKeyids: opt.throw_keyids = 1; break;
 	  case oNoThrowKeyids: opt.throw_keyids = 0; break;
 	  case oShowPhotos:
 	    deprecated_warning(configname,pargs.lineno,"--show-photos",
 			       "--list-options ","show-photos");
 	    deprecated_warning(configname,pargs.lineno,"--show-photos",
 			       "--verify-options ","show-photos");
 	    opt.list_options|=LIST_SHOW_PHOTOS;
 	    opt.verify_options|=VERIFY_SHOW_PHOTOS;
 	    break;
 	  case oNoShowPhotos:
 	    deprecated_warning(configname,pargs.lineno,"--no-show-photos",
 			       "--list-options ","no-show-photos");
 	    deprecated_warning(configname,pargs.lineno,"--no-show-photos",
 			       "--verify-options ","no-show-photos");
 	    opt.list_options&=~LIST_SHOW_PHOTOS;
 	    opt.verify_options&=~VERIFY_SHOW_PHOTOS;
 	    break;
 	  case oPhotoViewer: opt.photo_viewer = pargs.r.ret_str; break;
 
 	  case oForceAEAD: opt.force_aead = 1; break;
 
           case oDisableSignerUID: opt.flags.disable_signer_uid = 1; break;
           case oIncludeKeyBlock:  opt.flags.include_key_block = 1; break;
           case oNoIncludeKeyBlock: opt.flags.include_key_block = 0; break;
 
 	  case oS2KMode:   opt.s2k_mode = pargs.r.ret_int; break;
 	  case oS2KDigest: s2k_digest_string = xstrdup(pargs.r.ret_str); break;
 	  case oS2KCipher: s2k_cipher_string = xstrdup(pargs.r.ret_str); break;
 	  case oS2KCount:
 	    if (pargs.r.ret_int)
               opt.s2k_count = encode_s2k_iterations (pargs.r.ret_int);
             else
               opt.s2k_count = 0;  /* Auto-calibrate when needed.  */
 	    break;
 
 	  case oRecipient:
 	  case oHiddenRecipient:
 	  case oRecipientFile:
 	  case oHiddenRecipientFile:
             /* Store the recipient.  Note that we also store the
              * option as private data in the flags.  This is achieved
              * by shifting the option value to the left so to keep
              * enough space for the flags.  */
 	    sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
 	    sl->flags = (pargs.r_opt << PK_LIST_SHIFT);
             if (configname)
               sl->flags |= PK_LIST_CONFIG;
             if (pargs.r_opt == oHiddenRecipient
                 || pargs.r_opt == oHiddenRecipientFile)
               sl->flags |= PK_LIST_HIDDEN;
             if (pargs.r_opt == oRecipientFile
                 || pargs.r_opt == oHiddenRecipientFile)
               sl->flags |= PK_LIST_FROM_FILE;
             any_explicit_recipient = 1;
 	    break;
 
 	  case oEncryptTo:
 	  case oHiddenEncryptTo:
             /* Store an additional recipient.  */
 	    sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
 	    sl->flags = ((pargs.r_opt << PK_LIST_SHIFT) | PK_LIST_ENCRYPT_TO);
             if (configname)
               sl->flags |= PK_LIST_CONFIG;
             if (pargs.r_opt == oHiddenEncryptTo)
               sl->flags |= PK_LIST_HIDDEN;
 	    break;
 
 	  case oNoEncryptTo:
             opt.no_encrypt_to = 1;
             break;
           case oEncryptToDefaultKey:
             opt.encrypt_to_default_key = configname ? 2 : 1;
             break;
 
 	  case oTrySecretKey:
 	    add_to_strlist2 (&opt.secret_keys_to_try,
                              pargs.r.ret_str, utf8_strings);
 	    break;
 
           case oMimemode: opt.mimemode = opt.textmode = 1; break;
 	  case oTextmodeShort: opt.textmode = 2; break;
 	  case oTextmode: opt.textmode=1;  break;
 	  case oNoTextmode: opt.textmode=opt.mimemode=0;  break;
 
 	  case oExpert: opt.expert = 1; break;
 	  case oNoExpert: opt.expert = 0; break;
 	  case oDefSigExpire:
 	    if(*pargs.r.ret_str!='\0')
 	      {
 		if(parse_expire_string(pargs.r.ret_str)==(u32)-1)
 		  log_error(_("'%s' is not a valid signature expiration\n"),
 			    pargs.r.ret_str);
 		else
 		  opt.def_sig_expire=pargs.r.ret_str;
 	      }
 	    break;
 	  case oAskSigExpire: opt.ask_sig_expire = 1; break;
 	  case oNoAskSigExpire: opt.ask_sig_expire = 0; break;
 	  case oDefCertExpire:
 	    if(*pargs.r.ret_str!='\0')
 	      {
 		if(parse_expire_string(pargs.r.ret_str)==(u32)-1)
 		  log_error(_("'%s' is not a valid signature expiration\n"),
 			    pargs.r.ret_str);
 		else
 		  opt.def_cert_expire=pargs.r.ret_str;
 	      }
 	    break;
 	  case oAskCertExpire: opt.ask_cert_expire = 1; break;
 	  case oNoAskCertExpire: opt.ask_cert_expire = 0; break;
           case oDefCertLevel: opt.def_cert_level=pargs.r.ret_int; break;
           case oMinCertLevel: opt.min_cert_level=pargs.r.ret_int; break;
 	  case oAskCertLevel: opt.ask_cert_level = 1; break;
 	  case oNoAskCertLevel: opt.ask_cert_level = 0; break;
 	  case oLocalUser: /* store the local users */
 	    sl = add_to_strlist2( &locusr, pargs.r.ret_str, utf8_strings );
             sl->flags = (pargs.r_opt << PK_LIST_SHIFT);
             if (configname)
               sl->flags |= PK_LIST_CONFIG;
 	    break;
 	  case oSender:
             {
               char *mbox = mailbox_from_userid (pargs.r.ret_str, 0);
               if (!mbox)
                 log_error (_("\"%s\" is not a proper mail address\n"),
                            pargs.r.ret_str);
               else
                 {
                   add_to_strlist (&opt.sender_list, mbox);
                   xfree (mbox);
                 }
             }
 	    break;
 	  case oCompress:
 	    /* this is the -z command line option */
 	    opt.compress_level = opt.bz2_compress_level = pargs.r.ret_int;
 	    break;
 	  case oCompressLevel: opt.compress_level = pargs.r.ret_int; break;
 	  case oBZ2CompressLevel: opt.bz2_compress_level = pargs.r.ret_int; break;
 	  case oBZ2DecompressLowmem: opt.bz2_decompress_lowmem=1; break;
 	  case oPassphrase:
             set_passphrase_from_string (pargs.r_type ? pargs.r.ret_str : "");
 	    break;
 	  case oPassphraseFD:
             pwfd = translate_sys2libc_fd_int (pargs.r.ret_int, 0);
             break;
 	  case oPassphraseFile:
             pwfd = open_info_file (pargs.r.ret_str, 0, 1);
             break;
 	  case oPassphraseRepeat:
             opt.passphrase_repeat = pargs.r.ret_int;
             break;
 
           case oPinentryMode:
 	    opt.pinentry_mode = parse_pinentry_mode (pargs.r.ret_str);
 	    if (opt.pinentry_mode == -1)
               log_error (_("invalid pinentry mode '%s'\n"), pargs.r.ret_str);
 	    break;
 
           case oRequestOrigin:
 	    opt.request_origin = parse_request_origin (pargs.r.ret_str);
 	    if (opt.request_origin == -1)
               log_error (_("invalid request origin '%s'\n"), pargs.r.ret_str);
 	    break;
 
 	  case oCommandFD:
             opt.command_fd = translate_sys2libc_fd_int (pargs.r.ret_int, 0);
 	    if (! gnupg_fd_valid (opt.command_fd))
 	      log_error ("command-fd is invalid: %s\n", strerror (errno));
             break;
 	  case oCommandFile:
             opt.command_fd = open_info_file (pargs.r.ret_str, 0, 1);
             break;
 	  case oCipherAlgo:
             def_cipher_string = xstrdup(pargs.r.ret_str);
             break;
 	  case oAEADAlgo:
             def_aead_string = xstrdup (pargs.r.ret_str);
             break;
 	  case oDigestAlgo:
             def_digest_string = xstrdup(pargs.r.ret_str);
             break;
 	  case oCompressAlgo:
 	    /* If it is all digits, stick a Z in front of it for
 	       later.  This is for backwards compatibility with
 	       versions that took the compress algorithm number. */
 	    {
 	      char *pt=pargs.r.ret_str;
 	      while(*pt)
 		{
 		  if (!isascii (*pt) || !isdigit (*pt))
 		    break;
 
 		  pt++;
 		}
 
 	      if(*pt=='\0')
 		{
 		  compress_algo_string=xmalloc(strlen(pargs.r.ret_str)+2);
 		  strcpy(compress_algo_string,"Z");
 		  strcat(compress_algo_string,pargs.r.ret_str);
 		}
 	      else
 		compress_algo_string = xstrdup(pargs.r.ret_str);
 	    }
 	    break;
 	  case oCertDigestAlgo:
             cert_digest_string = xstrdup(pargs.r.ret_str);
             break;
 
 	  case oNoSecmemWarn:
             gcry_control (GCRYCTL_DISABLE_SECMEM_WARN);
             break;
 
 	  case oRequireSecmem: require_secmem=1; break;
 	  case oNoRequireSecmem: require_secmem=0; break;
 	  case oNoPermissionWarn: opt.no_perm_warn=1; break;
           case oDisplayCharset:
 	    if( set_native_charset( pargs.r.ret_str ) )
 		log_error(_("'%s' is not a valid character set\n"),
 			  pargs.r.ret_str);
 	    break;
 	  case oNotDashEscaped: opt.not_dash_escaped = 1; break;
 	  case oEscapeFrom: opt.escape_from = 1; break;
 	  case oNoEscapeFrom: opt.escape_from = 0; break;
 	  case oLockOnce: opt.lock_once = 1; break;
 	  case oLockNever:
             dotlock_disable ();
             break;
 	  case oLockMultiple:
 #ifndef __riscos__
 	    opt.lock_once = 0;
 #else /* __riscos__ */
             riscos_not_implemented("lock-multiple");
 #endif /* __riscos__ */
             break;
 	  case oKeyServer:
 	    {
 	      keyserver_spec_t keyserver;
 	      keyserver = parse_keyserver_uri (pargs.r.ret_str, 0);
 	      if (!keyserver)
 		log_error (_("could not parse keyserver URL\n"));
 	      else
 		{
 		  /* We only support a single keyserver.  Later ones
 		     override earlier ones.  (Since we parse the
 		     config file first and then the command line
 		     arguments, the command line takes
 		     precedence.)  */
 		  if (opt.keyserver)
 		    free_keyserver_spec (opt.keyserver);
 		  opt.keyserver = keyserver;
 		}
 	    }
 	    break;
 	  case oKeyServerOptions:
 	    if(!parse_keyserver_options(pargs.r.ret_str))
 	      {
 		if(configname)
 		  log_error(_("%s:%d: invalid keyserver options\n"),
 			    configname,pargs.lineno);
 		else
 		  log_error(_("invalid keyserver options\n"));
 	      }
 	    break;
 	  case oImportOptions:
 	    if(!parse_import_options(pargs.r.ret_str,&opt.import_options,1))
 	      {
 		if(configname)
 		  log_error(_("%s:%d: invalid import options\n"),
 			    configname,pargs.lineno);
 		else
 		  log_error(_("invalid import options\n"));
 	      }
 	    break;
 	  case oImportFilter:
 	    rc = parse_and_set_import_filter (pargs.r.ret_str);
 	    if (rc)
               log_error (_("invalid filter option: %s\n"), gpg_strerror (rc));
 	    break;
 	  case oExportOptions:
 	    if(!parse_export_options(pargs.r.ret_str,&opt.export_options,1))
 	      {
 		if(configname)
 		  log_error(_("%s:%d: invalid export options\n"),
 			    configname,pargs.lineno);
 		else
 		  log_error(_("invalid export options\n"));
 	      }
 	    break;
 	  case oExportFilter:
 	    rc = parse_and_set_export_filter (pargs.r.ret_str);
 	    if (rc)
               log_error (_("invalid filter option: %s\n"), gpg_strerror (rc));
 	    break;
 	  case oListOptions:
 	    if(!parse_list_options(pargs.r.ret_str))
 	      {
 		if(configname)
 		  log_error(_("%s:%d: invalid list options\n"),
 			    configname,pargs.lineno);
 		else
 		  log_error(_("invalid list options\n"));
 	      }
 	    break;
 	  case oVerifyOptions:
 	    {
 	      struct parse_options vopts[]=
 		{
 		  {"show-photos",VERIFY_SHOW_PHOTOS,NULL,
 		   N_("display photo IDs during signature verification")},
 		  {"show-policy-urls",VERIFY_SHOW_POLICY_URLS,NULL,
 		   N_("show policy URLs during signature verification")},
 		  {"show-notations",VERIFY_SHOW_NOTATIONS,NULL,
 		   N_("show all notations during signature verification")},
 		  {"show-std-notations",VERIFY_SHOW_STD_NOTATIONS,NULL,
 		   N_("show IETF standard notations during signature verification")},
 		  {"show-standard-notations",VERIFY_SHOW_STD_NOTATIONS,NULL,
 		   NULL},
 		  {"show-user-notations",VERIFY_SHOW_USER_NOTATIONS,NULL,
 		   N_("show user-supplied notations during signature verification")},
 		  {"show-keyserver-urls",VERIFY_SHOW_KEYSERVER_URLS,NULL,
 		   N_("show preferred keyserver URLs during signature verification")},
 		  {"show-uid-validity",VERIFY_SHOW_UID_VALIDITY,NULL,
 		   N_("show user ID validity during signature verification")},
 		  {"show-unusable-uids",VERIFY_SHOW_UNUSABLE_UIDS,NULL,
 		   N_("show revoked and expired user IDs in signature verification")},
 		  {"show-primary-uid-only",VERIFY_SHOW_PRIMARY_UID_ONLY,NULL,
 		   N_("show only the primary user ID in signature verification")},
 		  {NULL,0,NULL,NULL}
 		};
 
 	      if(!parse_options(pargs.r.ret_str,&opt.verify_options,vopts,1))
 		{
 		  if(configname)
 		    log_error(_("%s:%d: invalid verify options\n"),
 			      configname,pargs.lineno);
 		  else
 		    log_error(_("invalid verify options\n"));
 		}
 	    }
 	    break;
 	  case oTempDir: opt.temp_dir=pargs.r.ret_str; break;
 	  case oExecPath:
 	    if(set_exec_path(pargs.r.ret_str))
 	      log_error(_("unable to set exec-path to %s\n"),pargs.r.ret_str);
 	    else
 	      opt.exec_path_set=1;
 	    break;
 	  case oSetNotation:
 	    add_notation_data( pargs.r.ret_str, 0 );
 	    add_notation_data( pargs.r.ret_str, 1 );
 	    break;
 	  case oSigNotation: add_notation_data( pargs.r.ret_str, 0 ); break;
 	  case oCertNotation: add_notation_data( pargs.r.ret_str, 1 ); break;
           case oKnownNotation: register_known_notation (pargs.r.ret_str); break;
 	  case oShowNotation:
 	    deprecated_warning(configname,pargs.lineno,"--show-notation",
 			       "--list-options ","show-notations");
 	    deprecated_warning(configname,pargs.lineno,"--show-notation",
 			       "--verify-options ","show-notations");
 	    opt.list_options|=LIST_SHOW_NOTATIONS;
 	    opt.verify_options|=VERIFY_SHOW_NOTATIONS;
 	    break;
 	  case oNoShowNotation:
 	    deprecated_warning(configname,pargs.lineno,"--no-show-notation",
 			       "--list-options ","no-show-notations");
 	    deprecated_warning(configname,pargs.lineno,"--no-show-notation",
 			       "--verify-options ","no-show-notations");
 	    opt.list_options&=~LIST_SHOW_NOTATIONS;
 	    opt.verify_options&=~VERIFY_SHOW_NOTATIONS;
 	    break;
 	  case oUtf8Strings: utf8_strings = 1; break;
 	  case oNoUtf8Strings:
 #ifdef HAVE_W32_SYSTEM
             utf8_strings = 0;
 #endif
             break;
 	  case oDisableCipherAlgo:
             {
               int algo = string_to_cipher_algo (pargs.r.ret_str);
               gcry_cipher_ctl (NULL, GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
             }
             break;
 	  case oDisablePubkeyAlgo:
             {
               int algo = gcry_pk_map_name (pargs.r.ret_str);
               gcry_pk_ctl (GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
             }
             break;
           case oNoSigCache: opt.no_sig_cache = 1; break;
 	  case oAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid = 1; break;
 	  case oNoAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid=0; break;
 	  case oAllowFreeformUID: opt.allow_freeform_uid = 1; break;
 	  case oNoAllowFreeformUID: opt.allow_freeform_uid = 0; break;
 	  case oNoLiteral: opt.no_literal = 1; break;
 	  case oSetFilesize: opt.set_filesize = pargs.r.ret_ulong; break;
 	  case oFastListMode: opt.fast_list_mode = 1; break;
 	  case oFixedListMode: /* Dummy */ break;
           case oLegacyListMode: opt.legacy_list_mode = 1; break;
 	  case oPrintDANERecords: print_dane_records = 1; break;
 	  case oListOnly: opt.list_only=1; break;
 	  case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
 	  case oIgnoreValidFrom: opt.ignore_valid_from = 1; break;
 	  case oIgnoreCrcError: opt.ignore_crc_error = 1; break;
 	  case oIgnoreMDCError: opt.ignore_mdc_error = 1; break;
 	  case oNoRandomSeedFile: use_random_seed = 0; break;
 
           case oAutoKeyImport: opt.flags.auto_key_import = 1; break;
           case oNoAutoKeyImport: opt.flags.auto_key_import = 0; break;
 
 	  case oAutoKeyRetrieve:
             opt.keyserver_options.options |= KEYSERVER_AUTO_KEY_RETRIEVE;
             break;
 	  case oNoAutoKeyRetrieve:
             opt.keyserver_options.options &= ~KEYSERVER_AUTO_KEY_RETRIEVE;
             break;
 
 	  case oShowSessionKey: opt.show_session_key = 1; break;
 	  case oOverrideSessionKey:
 		opt.override_session_key = pargs.r.ret_str;
 		break;
 	  case oOverrideSessionKeyFD:
                 ovrseskeyfd = translate_sys2libc_fd_int (pargs.r.ret_int, 0);
 		break;
 	  case oMergeOnly:
 	        deprecated_warning(configname,pargs.lineno,"--merge-only",
 				   "--import-options ","merge-only");
 		opt.import_options|=IMPORT_MERGE_ONLY;
 	    break;
           case oAllowSecretKeyImport: /* obsolete */ break;
 	  case oTryAllSecrets: opt.try_all_secrets = 1; break;
           case oTrustedKey: register_trusted_key( pargs.r.ret_str ); break;
 
           case oEnableSpecialFilenames:
             enable_special_filenames ();
             break;
 
           case oNoExpensiveTrustChecks: opt.no_expensive_trust_checks=1; break;
           case oAutoCheckTrustDB: opt.no_auto_check_trustdb=0; break;
           case oNoAutoCheckTrustDB: opt.no_auto_check_trustdb=1; break;
           case oPreservePermissions: opt.preserve_permissions=1; break;
           case oDefaultPreferenceList:
 	    opt.def_preference_list = pargs.r.ret_str;
 	    break;
 	  case oDefaultKeyserverURL:
 	    {
 	      keyserver_spec_t keyserver;
 	      keyserver = parse_keyserver_uri (pargs.r.ret_str,1 );
 	      if (!keyserver)
 		log_error (_("could not parse keyserver URL\n"));
 	      else
 		free_keyserver_spec (keyserver);
 
 	      opt.def_keyserver_url = pargs.r.ret_str;
 	    }
 	    break;
           case oPersonalCipherPreferences:
 	    pers_cipher_list=pargs.r.ret_str;
 	    break;
           case oPersonalAEADPreferences:
 	    pers_aead_list = pargs.r.ret_str;
 	    break;
           case oPersonalDigestPreferences:
 	    pers_digest_list=pargs.r.ret_str;
 	    break;
           case oPersonalCompressPreferences:
 	    pers_compress_list=pargs.r.ret_str;
 	    break;
           case oAgentProgram: opt.agent_program = pargs.r.ret_str;  break;
           case oKeyboxdProgram: opt.keyboxd_program = pargs.r.ret_str;  break;
           case oDirmngrProgram: opt.dirmngr_program = pargs.r.ret_str; break;
 	  case oDisableDirmngr: opt.disable_dirmngr = 1;  break;
           case oWeakDigest:
 	    additional_weak_digest(pargs.r.ret_str);
 	    break;
           case oUnwrap:
             opt.unwrap_encryption = 1;
             break;
           case oOnlySignTextIDs:
             opt.only_sign_text_ids = 1;
             break;
 
           case oDisplay:
             set_opt_session_env ("DISPLAY", pargs.r.ret_str);
             break;
           case oTTYname:
             set_opt_session_env ("GPG_TTY", pargs.r.ret_str);
             break;
           case oTTYtype:
             set_opt_session_env ("TERM", pargs.r.ret_str);
             break;
           case oXauthority:
             set_opt_session_env ("XAUTHORITY", pargs.r.ret_str);
             break;
 
           case oLCctype: opt.lc_ctype = pargs.r.ret_str; break;
           case oLCmessages: opt.lc_messages = pargs.r.ret_str; break;
 
 	  case oGroup: add_group(pargs.r.ret_str); break;
 	  case oUnGroup: rm_group(pargs.r.ret_str); break;
 	  case oNoGroups:
 	    while(opt.grouplist)
 	      {
 		struct groupitem *iter=opt.grouplist;
 		free_strlist(iter->values);
 		opt.grouplist=opt.grouplist->next;
 		xfree(iter);
 	      }
 	    break;
 
           case oMangleDosFilenames: opt.mangle_dos_filenames = 1; break;
           case oNoMangleDosFilenames: opt.mangle_dos_filenames = 0; break;
           case oEnableProgressFilter: opt.enable_progress_filter = 1; break;
 	  case oMultifile: multifile=1; break;
 	  case oKeyidFormat:
 	    if(ascii_strcasecmp(pargs.r.ret_str,"short")==0)
 	      opt.keyid_format=KF_SHORT;
 	    else if(ascii_strcasecmp(pargs.r.ret_str,"long")==0)
 	      opt.keyid_format=KF_LONG;
 	    else if(ascii_strcasecmp(pargs.r.ret_str,"0xshort")==0)
 	      opt.keyid_format=KF_0xSHORT;
 	    else if(ascii_strcasecmp(pargs.r.ret_str,"0xlong")==0)
 	      opt.keyid_format=KF_0xLONG;
 	    else if(ascii_strcasecmp(pargs.r.ret_str,"none")==0)
 	      opt.keyid_format = KF_NONE;
 	    else
 	      log_error("unknown keyid-format '%s'\n",pargs.r.ret_str);
 	    break;
 
           case oExitOnStatusWriteError:
             opt.exit_on_status_write_error = 1;
             break;
 
 	  case oLimitCardInsertTries:
             opt.limit_card_insert_tries = pargs.r.ret_int;
             break;
 
 	  case oRequireCrossCert: opt.flags.require_cross_cert=1; break;
 	  case oNoRequireCrossCert: opt.flags.require_cross_cert=0; break;
 
 	  case oAutoKeyLocate:
             if (default_akl)
               {
                 /* This is the first time --auto-key-locate is seen.
                  * We need to reset the default akl.  */
                 default_akl = 0;
                 release_akl();
               }
 	    if(!parse_auto_key_locate(pargs.r.ret_str))
 	      {
 		if(configname)
 		  log_error(_("%s:%d: invalid auto-key-locate list\n"),
 			    configname,pargs.lineno);
 		else
 		  log_error(_("invalid auto-key-locate list\n"));
 	      }
 	    break;
 	  case oNoAutoKeyLocate:
 	    release_akl();
 	    break;
 
 	  case oKeyOrigin:
 	    if(!parse_key_origin (pargs.r.ret_str))
               log_error (_("invalid argument for option \"%.50s\"\n"),
                          "--key-origin");
 	    break;
 
 	  case oEnableLargeRSA:
 #if SECMEM_BUFFER_SIZE >= 65536
             opt.flags.large_rsa=1;
 #else
             if (configname)
               log_info("%s:%d: WARNING: gpg not built with large secure "
                          "memory buffer.  Ignoring enable-large-rsa\n",
                         configname,pargs.lineno);
             else
               log_info("WARNING: gpg not built with large secure "
                          "memory buffer.  Ignoring --enable-large-rsa\n");
 #endif /* SECMEM_BUFFER_SIZE >= 65536 */
             break;
 	  case oDisableLargeRSA: opt.flags.large_rsa=0;
             break;
 
 	  case oEnableDSA2: opt.flags.dsa2=1; break;
 	  case oDisableDSA2: opt.flags.dsa2=0; break;
 
           case oAllowWeakDigestAlgos:
             opt.flags.allow_weak_digest_algos = 1;
             break;
 
           case oAllowWeakKeySignatures:
             opt.flags.allow_weak_key_signatures = 1;
             break;
 
           case oAllowOldCipherAlgos:
             opt.flags.allow_old_cipher_algos = 1;
             break;
 
           case oFakedSystemTime:
             {
               size_t len = strlen (pargs.r.ret_str);
               int freeze = 0;
               time_t faked_time;
 
               if (len > 0 && pargs.r.ret_str[len-1] == '!')
                 {
                   freeze = 1;
                   pargs.r.ret_str[len-1] = '\0';
                 }
 
               faked_time = isotime2epoch (pargs.r.ret_str);
               if (faked_time == (time_t)(-1))
                 faked_time = (time_t)strtoul (pargs.r.ret_str, NULL, 10);
               gnupg_set_time (faked_time, freeze);
             }
             break;
 
           case oNoAutostart: opt.autostart = 0; break;
           case oNoSymkeyCache: opt.no_symkey_cache = 1; break;
 
 	  case oDefaultNewKeyAlgo:
             opt.def_new_key_algo = pargs.r.ret_str;
             break;
 
           case oUseOnlyOpenPGPCard:
             opt.flags.use_only_openpgp_card = 1;
             break;
 
           case oFullTimestrings:
             opt.flags.full_timestrings = 1;
             break;
 
 	  case oNoop: break;
 
 	  default:
             if (configname)
               pargs.err = ARGPARSE_PRINT_WARNING;
             else
               {
                 pargs.err = ARGPARSE_PRINT_ERROR;
                 /* The argparse function calls a plain exit and thus
                  * we need to print a status here.  */
                 write_status_failure ("option-parser",
                                       gpg_error(GPG_ERR_GENERAL));
               }
             break;
 	  }
       }
 
     gpgrt_argparse (NULL, &pargs, NULL);  /* Release internal state.  */
 
     if (log_get_errorcount (0))
       {
         write_status_failure ("option-parser", gpg_error(GPG_ERR_GENERAL));
         g10_exit(2);
       }
 
     /* Process common component options.  */
     if (parse_comopt (GNUPG_MODULE_NAME_GPG, debug_argparser))
       {
         write_status_failure ("option-parser", gpg_error(GPG_ERR_GENERAL));
         g10_exit(2);
       }
 
     if (opt.use_keyboxd)
       log_info ("Note: Please move option \"%s\" to \"common.conf\"\n",
                 "use-keyboxd");
     opt.use_keyboxd = comopt.use_keyboxd;  /* Override.  */
 
     if (opt.keyboxd_program)
       log_info ("Note: Please move option \"%s\" to \"common.conf\"\n",
                 "keyboxd-program");
     if (!opt.keyboxd_program && comopt.keyboxd_program)
       {
         opt.keyboxd_program = comopt.keyboxd_program;
         comopt.keyboxd_program = NULL;
       }
 
 
     /* The command --gpgconf-list is pretty simple and may be called
        directly after the option parsing. */
     if (cmd == aGPGConfList)
       {
         gpgconf_list ();
         g10_exit (0);
       }
     xfree (last_configname);
 
     if (print_dane_records)
       log_error ("invalid option \"%s\"; use \"%s\" instead\n",
                  "--print-dane-records",
                  "--export-options export-dane");
     if (log_get_errorcount (0))
       {
         write_status_failure ("option-checking", gpg_error(GPG_ERR_GENERAL));
         g10_exit(2);
       }
 
 
     if( nogreeting )
 	greeting = 0;
 
     if( greeting )
       {
 	es_fprintf (es_stderr, "%s %s; %s\n",
                     gpgrt_strusage(11), gpgrt_strusage(13), gpgrt_strusage(14));
 	es_fprintf (es_stderr, "%s\n", gpgrt_strusage(15) );
       }
 #ifdef IS_DEVELOPMENT_VERSION
     if (!opt.batch)
       {
 	const char *s;
 
 	if((s=gpgrt_strusage(25)))
 	  log_info("%s\n",s);
 	if((s=gpgrt_strusage(26)))
 	  log_info("%s\n",s);
 	if((s=gpgrt_strusage(27)))
 	  log_info("%s\n",s);
       }
 #endif
 
     /* Init threading which is used by some helper functions.  */
     npth_init ();
     assuan_set_system_hooks (ASSUAN_SYSTEM_NPTH);
     gpgrt_set_syscall_clamp (npth_unprotect, npth_protect);
 
     if (logfile)
       {
         log_set_file (logfile);
         log_set_prefix (NULL, (GPGRT_LOG_WITH_PREFIX
                                | GPGRT_LOG_WITH_TIME
                                | GPGRT_LOG_WITH_PID ));
       }
 
     if (opt.verbose > 2)
         log_info ("using character set '%s'\n", get_native_charset ());
 
     if( may_coredump && !opt.quiet )
 	log_info(_("WARNING: program may create a core file!\n"));
 
     if (opt.flags.rfc4880bis)
       {
         if (opt.verbose)
           log_info ("Note: RFC4880bis features are enabled.\n");
       }
     else
       {
         opt.mimemode = 0; /* This will use text mode instead.  */
       }
 
     if (eyes_only) {
       if (opt.set_filename)
 	  log_info(_("WARNING: %s overrides %s\n"),
 		   "--for-your-eyes-only","--set-filename");
 
       opt.set_filename="_CONSOLE";
     }
 
     if (opt.no_literal) {
 	log_info(_("Note: %s is not for normal use!\n"), "--no-literal");
 	if (opt.textmode)
 	    log_error(_("%s not allowed with %s!\n"),
 		       "--textmode", "--no-literal" );
 	if (opt.set_filename)
 	    log_error(_("%s makes no sense with %s!\n"),
 			eyes_only?"--for-your-eyes-only":"--set-filename",
 		        "--no-literal" );
     }
 
 
     if (opt.set_filesize)
 	log_info(_("Note: %s is not for normal use!\n"), "--set-filesize");
     if( opt.batch )
 	tty_batchmode( 1 );
 
     if (gnupg_faked_time_p ())
       {
         gnupg_isotime_t tbuf;
 
         log_info (_("WARNING: running with faked system time: "));
         gnupg_get_isotime (tbuf);
         dump_isotime (tbuf);
         log_printf ("\n");
       }
 
     /* Print a warning if an argument looks like an option.  */
     if (!opt.quiet && !(pargs.flags & ARGPARSE_FLAG_STOP_SEEN))
       {
         int i;
 
         for (i=0; i < argc; i++)
           if (argv[i][0] == '-' && argv[i][1] == '-')
             log_info (_("Note: '%s' is not considered an option\n"), argv[i]);
       }
 
 
     gcry_control (GCRYCTL_RESUME_SECMEM_WARN);
 
     if(require_secmem && !got_secmem)
       {
 	log_info(_("will not run with insecure memory due to %s\n"),
 		 "--require-secmem");
         write_status_failure ("option-checking", gpg_error(GPG_ERR_GENERAL));
 	g10_exit(2);
       }
 
     set_debug (debug_level);
     if (DBG_CLOCK)
       log_clock ("start");
 
     /* Do these after the switch(), so they can override settings. */
     if (PGP7)
       {
         /* That does not anymore work because we have no more support
            for v3 signatures.  */
 	opt.escape_from=1;
 	opt.ask_sig_expire=0;
       }
     else if(PGP8)
       {
 	opt.escape_from=1;
       }
 
 
     if( def_cipher_string ) {
 	opt.def_cipher_algo = string_to_cipher_algo (def_cipher_string);
 	xfree(def_cipher_string); def_cipher_string = NULL;
 	if ( openpgp_cipher_test_algo (opt.def_cipher_algo) )
 	    log_error(_("selected cipher algorithm is invalid\n"));
     }
     if (def_aead_string)
       {
 	opt.def_aead_algo = string_to_aead_algo (def_aead_string);
 	xfree (def_aead_string); def_aead_string = NULL;
 	if (openpgp_aead_test_algo (opt.def_aead_algo))
           log_error(_("selected AEAD algorithm is invalid\n"));
       }
     if( def_digest_string ) {
 	opt.def_digest_algo = string_to_digest_algo (def_digest_string);
 	xfree(def_digest_string); def_digest_string = NULL;
 	if ( openpgp_md_test_algo (opt.def_digest_algo) )
 	    log_error(_("selected digest algorithm is invalid\n"));
     }
     if( compress_algo_string ) {
 	opt.compress_algo = string_to_compress_algo(compress_algo_string);
 	xfree(compress_algo_string); compress_algo_string = NULL;
 	if( check_compress_algo(opt.compress_algo) )
           log_error(_("selected compression algorithm is invalid\n"));
     }
     if( cert_digest_string ) {
 	opt.cert_digest_algo = string_to_digest_algo (cert_digest_string);
 	xfree(cert_digest_string); cert_digest_string = NULL;
 	if (openpgp_md_test_algo(opt.cert_digest_algo))
           log_error(_("selected certification digest algorithm is invalid\n"));
     }
     if( s2k_cipher_string ) {
 	opt.s2k_cipher_algo = string_to_cipher_algo (s2k_cipher_string);
 	xfree(s2k_cipher_string); s2k_cipher_string = NULL;
 	if (openpgp_cipher_test_algo (opt.s2k_cipher_algo))
           log_error(_("selected cipher algorithm is invalid\n"));
     }
     if( s2k_digest_string ) {
 	opt.s2k_digest_algo = string_to_digest_algo (s2k_digest_string);
 	xfree(s2k_digest_string); s2k_digest_string = NULL;
 	if (openpgp_md_test_algo(opt.s2k_digest_algo))
           log_error(_("selected digest algorithm is invalid\n"));
     }
     if( opt.completes_needed < 1 )
       log_error(_("completes-needed must be greater than 0\n"));
     if( opt.marginals_needed < 2 )
       log_error(_("marginals-needed must be greater than 1\n"));
     if( opt.max_cert_depth < 1 || opt.max_cert_depth > 255 )
       log_error(_("max-cert-depth must be in the range from 1 to 255\n"));
     if(opt.def_cert_level<0 || opt.def_cert_level>3)
       log_error(_("invalid default-cert-level; must be 0, 1, 2, or 3\n"));
     if( opt.min_cert_level < 1 || opt.min_cert_level > 3 )
       log_error(_("invalid min-cert-level; must be 1, 2, or 3\n"));
     switch( opt.s2k_mode ) {
       case 0:
         if (!opt.quiet)
           log_info(_("Note: simple S2K mode (0) is strongly discouraged\n"));
 	break;
       case 1: case 3: break;
       default:
 	log_error(_("invalid S2K mode; must be 0, 1 or 3\n"));
     }
 
     /* This isn't actually needed, but does serve to error out if the
        string is invalid. */
     if(opt.def_preference_list &&
 	keygen_set_std_prefs(opt.def_preference_list,0))
       log_error(_("invalid default preferences\n"));
 
     if(pers_cipher_list &&
        keygen_set_std_prefs(pers_cipher_list,PREFTYPE_SYM))
       log_error(_("invalid personal cipher preferences\n"));
 
     if (pers_aead_list && keygen_set_std_prefs (pers_aead_list, PREFTYPE_AEAD))
       log_error(_("invalid personal AEAD preferences\n"));
 
     if(pers_digest_list &&
        keygen_set_std_prefs(pers_digest_list,PREFTYPE_HASH))
       log_error(_("invalid personal digest preferences\n"));
 
     if(pers_compress_list &&
        keygen_set_std_prefs(pers_compress_list,PREFTYPE_ZIP))
       log_error(_("invalid personal compress preferences\n"));
 
     /* Check chunk size.  Please fix also the man page if you change
      * the default.  The limits are given by the specs.  */
     if (!opt.chunk_size)
       opt.chunk_size = 27; /* Default to the suggested max of 128 MiB.  */
     else if (opt.chunk_size < 6)
       {
         opt.chunk_size = 6;
         log_info (_("chunk size invalid - using %d\n"), opt.chunk_size);
       }
     else if (opt.chunk_size > (allow_large_chunks? 62 : 27))
       {
         opt.chunk_size = (allow_large_chunks? 62 : 27);
         log_info (_("chunk size invalid - using %d\n"), opt.chunk_size);
       }
 
     /* We don't support all possible commands with multifile yet */
     if(multifile)
       {
 	char *cmdname;
 
 	switch(cmd)
 	  {
 	  case aSign:
 	    cmdname="--sign";
 	    break;
 	  case aSignEncr:
 	    cmdname="--sign --encrypt";
 	    break;
 	  case aClearsign:
 	    cmdname="--clear-sign";
 	    break;
 	  case aDetachedSign:
 	    cmdname="--detach-sign";
 	    break;
 	  case aSym:
 	    cmdname="--symmetric";
 	    break;
 	  case aEncrSym:
 	    cmdname="--symmetric --encrypt";
 	    break;
 	  case aStore:
 	    cmdname="--store";
 	    break;
 	  default:
 	    cmdname=NULL;
 	    break;
 	  }
 
 	if(cmdname)
 	  log_error(_("%s does not yet work with %s\n"),cmdname,"--multifile");
       }
 
     if( log_get_errorcount(0) )
       {
         write_status_failure ("option-postprocessing",
                               gpg_error(GPG_ERR_GENERAL));
 	g10_exit (2);
       }
 
     if(opt.compress_level==0)
       opt.compress_algo=COMPRESS_ALGO_NONE;
 
     /* Check our chosen algorithms against the list of legal
        algorithms. */
 
     if(!GNUPG && !opt.flags.rfc4880bis)
       {
 	const char *badalg=NULL;
 	preftype_t badtype=PREFTYPE_NONE;
 
 	if(opt.def_cipher_algo
 	   && !algo_available(PREFTYPE_SYM,opt.def_cipher_algo,NULL))
 	  {
 	    badalg = openpgp_cipher_algo_name (opt.def_cipher_algo);
 	    badtype = PREFTYPE_SYM;
 	  }
 	else if(opt.def_aead_algo
 	   && !algo_available(PREFTYPE_AEAD, opt.def_aead_algo, NULL))
 	  {
 	    badalg = openpgp_aead_algo_name (opt.def_aead_algo);
 	    badtype = PREFTYPE_AEAD;
 	  }
 	else if(opt.def_digest_algo
 		&& !algo_available(PREFTYPE_HASH,opt.def_digest_algo,NULL))
 	  {
 	    badalg = gcry_md_algo_name (opt.def_digest_algo);
 	    badtype = PREFTYPE_HASH;
 	  }
 	else if(opt.cert_digest_algo
 		&& !algo_available(PREFTYPE_HASH,opt.cert_digest_algo,NULL))
 	  {
 	    badalg = gcry_md_algo_name (opt.cert_digest_algo);
 	    badtype = PREFTYPE_HASH;
 	  }
 	else if(opt.compress_algo!=-1
 		&& !algo_available(PREFTYPE_ZIP,opt.compress_algo,NULL))
 	  {
 	    badalg = compress_algo_to_string(opt.compress_algo);
 	    badtype = PREFTYPE_ZIP;
 	  }
 
 	if(badalg)
 	  {
 	    switch(badtype)
 	      {
 	      case PREFTYPE_SYM:
 		log_info (_("cipher algorithm '%s'"
                             " may not be used in %s mode\n"),
 			 badalg,
                           gnupg_compliance_option_string (opt.compliance));
 		break;
 	      case PREFTYPE_AEAD:
 		log_info (_("AEAD algorithm '%s'"
                             " may not be used in %s mode\n"),
                           badalg,
                           gnupg_compliance_option_string (opt.compliance));
 		break;
 	      case PREFTYPE_HASH:
 		log_info (_("digest algorithm '%s'"
                             " may not be used in %s mode\n"),
                           badalg,
                           gnupg_compliance_option_string (opt.compliance));
 		break;
 	      case PREFTYPE_ZIP:
 		log_info (_("compression algorithm '%s'"
                             " may not be used in %s mode\n"),
                           badalg,
                           gnupg_compliance_option_string (opt.compliance));
 		break;
 	      default:
 		BUG();
 	      }
 
 	    compliance_failure();
 	  }
       }
 
     /* Check our chosen algorithms against the list of allowed
      * algorithms in the current compliance mode, and fail hard if it
      * is not.  This is us being nice to the user informing her early
      * that the chosen algorithms are not available.  We also check
      * and enforce this right before the actual operation.  */
     /* FIXME: We also need to check the AEAD algo. */
     if (opt.def_cipher_algo
 	&& ! gnupg_cipher_is_allowed (opt.compliance,
 				      cmd == aEncr
 				      || cmd == aSignEncr
 				      || cmd == aEncrSym
 				      || cmd == aSym
 				      || cmd == aSignSym
 				      || cmd == aSignEncrSym,
 				      opt.def_cipher_algo,
 				      GCRY_CIPHER_MODE_NONE))
       log_error (_("cipher algorithm '%s' may not be used in %s mode\n"),
 		 openpgp_cipher_algo_name (opt.def_cipher_algo),
 		 gnupg_compliance_option_string (opt.compliance));
 
     if (opt.def_digest_algo
 	&& ! gnupg_digest_is_allowed (opt.compliance,
 				      cmd == aSign
 				      || cmd == aSignEncr
 				      || cmd == aSignEncrSym
 				      || cmd == aSignSym
 				      || cmd == aClearsign,
 				      opt.def_digest_algo))
       log_error (_("digest algorithm '%s' may not be used in %s mode\n"),
 		 gcry_md_algo_name (opt.def_digest_algo),
 		 gnupg_compliance_option_string (opt.compliance));
 
     /* Fail hard.  */
     if (log_get_errorcount (0))
       {
         write_status_failure ("option-checking", gpg_error(GPG_ERR_GENERAL));
 	g10_exit (2);
       }
 
     /* Set the random seed file. */
     if (use_random_seed)
       {
         char *p = make_filename (gnupg_homedir (), "random_seed", NULL );
         gcry_control (GCRYCTL_SET_RANDOM_SEED_FILE, p);
         if (!gnupg_access (p, F_OK))
           register_secured_file (p);
 	xfree(p);
       }
 
     /* If there is no command but the --fingerprint is given, default
        to the --list-keys command.  */
     if (!cmd && fpr_maybe_cmd)
       {
 	set_cmd (&cmd, aListKeys);
       }
 
 
     if( opt.verbose > 1 )
 	set_packet_list_mode(1);
 
     /* Add the keyrings, but not for some special commands.  We always
      * need to add the keyrings if we are running under SELinux, this
      * is so that the rings are added to the list of secured files.
      * We do not add any keyring if --no-keyring or --use-keyboxd has
      * been used.  */
     if (!opt.use_keyboxd
         && default_keyring >= 0
         && (ALWAYS_ADD_KEYRINGS
             || (cmd != aDeArmor && cmd != aEnArmor && cmd != aGPGConfTest)))
       {
 	if (!nrings || default_keyring > 0)  /* Add default ring. */
 	    keydb_add_resource ("pubring" EXTSEP_S GPGEXT_GPG,
                                 KEYDB_RESOURCE_FLAG_DEFAULT);
 	for (sl = nrings; sl; sl = sl->next )
           keydb_add_resource (sl->d, sl->flags);
       }
     FREE_STRLIST(nrings);
 
     /* In loopback mode, never ask for the password multiple times.  */
     if (opt.pinentry_mode == PINENTRY_MODE_LOOPBACK)
       {
 	opt.passphrase_repeat = 0;
       }
 
     /* If no pinentry is expected shunt
      * gnupg_allow_set_foregound_window to avoid useless error
      * messages on Windows.  */
     if (opt.pinentry_mode != PINENTRY_MODE_ASK)
       {
         gnupg_inhibit_set_foregound_window (1);
       }
 
 
     if (cmd == aGPGConfTest)
       g10_exit(0);
 
 
     if (pwfd != -1)  /* Read the passphrase now. */
       read_passphrase_from_fd (pwfd);
 
     if (ovrseskeyfd != -1 )  /* Read the sessionkey now. */
       read_sessionkey_from_fd (ovrseskeyfd);
 
     fname = argc? *argv : NULL;
 
     if(fname && utf8_strings)
       opt.flags.utf8_filename=1;
 
     ctrl = xcalloc (1, sizeof *ctrl);
     gpg_init_default_ctrl (ctrl);
 
 #ifndef NO_TRUST_MODELS
     switch (cmd)
       {
       case aPrimegen:
       case aPrintMD:
       case aPrintMDs:
       case aGenRandom:
       case aDeArmor:
       case aEnArmor:
       case aListConfig:
       case aListGcryptConfig:
 	break;
       case aFixTrustDB:
       case aExportOwnerTrust:
         rc = setup_trustdb (0, trustdb_name);
         break;
       case aListTrustDB:
         rc = setup_trustdb (argc? 1:0, trustdb_name);
         break;
       case aKeygen:
       case aFullKeygen:
       case aQuickKeygen:
         rc = setup_trustdb (1, trustdb_name);
         break;
       default:
         /* If we are using TM_ALWAYS, we do not need to create the
            trustdb.  */
         rc = setup_trustdb (opt.trust_model != TM_ALWAYS, trustdb_name);
         break;
       }
     if (rc)
       log_error (_("failed to initialize the TrustDB: %s\n"),
                  gpg_strerror (rc));
 #endif /*!NO_TRUST_MODELS*/
 
     switch (cmd)
       {
       case aStore:
       case aSym:
       case aSign:
       case aSignSym:
       case aClearsign:
         if (!opt.quiet && any_explicit_recipient)
           log_info (_("WARNING: recipients (-r) given "
                       "without using public key encryption\n"));
 	break;
       default:
         break;
       }
 
 
     /* Check for certain command whether we need to migrate a
        secring.gpg to the gpg-agent. */
     switch (cmd)
       {
       case aListSecretKeys:
       case aSign:
       case aSignEncr:
       case aSignEncrSym:
       case aSignSym:
       case aClearsign:
       case aDecrypt:
       case aSignKey:
       case aLSignKey:
       case aEditKey:
       case aPasswd:
       case aDeleteSecretKeys:
       case aDeleteSecretAndPublicKeys:
       case aQuickKeygen:
       case aQuickAddUid:
       case aQuickAddKey:
       case aQuickRevUid:
       case aQuickSetPrimaryUid:
       case aFullKeygen:
       case aKeygen:
       case aImport:
       case aExportSecret:
       case aExportSecretSub:
       case aGenRevoke:
       case aDesigRevoke:
       case aCardEdit:
       case aChangePIN:
         migrate_secring (ctrl);
 	break;
       case aListKeys:
         if (opt.with_secret)
           migrate_secring (ctrl);
         break;
       default:
         break;
       }
 
     /* The command dispatcher.  */
     switch( cmd )
       {
       case aServer:
         gpg_server (ctrl);
         break;
 
       case aStore: /* only store the file */
 	if( argc > 1 )
 	    wrong_args("--store [filename]");
 	if( (rc = encrypt_store(fname)) )
           {
             write_status_failure ("store", rc);
 	    log_error ("storing '%s' failed: %s\n",
                        print_fname_stdin(fname),gpg_strerror (rc) );
           }
 	break;
       case aSym: /* encrypt the given file only with the symmetric cipher */
 	if( argc > 1 )
 	    wrong_args("--symmetric [filename]");
 	if( (rc = encrypt_symmetric(fname)) )
           {
             write_status_failure ("symencrypt", rc);
             log_error (_("symmetric encryption of '%s' failed: %s\n"),
                         print_fname_stdin(fname),gpg_strerror (rc) );
           }
 	break;
 
       case aEncr: /* encrypt the given file */
 	if(multifile)
 	  encrypt_crypt_files (ctrl, argc, argv, remusr);
 	else
 	  {
 	    if( argc > 1 )
 	      wrong_args("--encrypt [filename]");
 	    if( (rc = encrypt_crypt (ctrl, -1, fname, remusr, 0, NULL, -1)) )
               {
                 write_status_failure ("encrypt", rc);
                 log_error("%s: encryption failed: %s\n",
                           print_fname_stdin(fname), gpg_strerror (rc) );
               }
 	  }
 	break;
 
       case aEncrSym:
 	/* This works with PGP 8 in the sense that it acts just like a
 	   symmetric message.  It doesn't work at all with 2 or 6.  It
 	   might work with 7, but alas, I don't have a copy to test
 	   with right now. */
 	if( argc > 1 )
 	  wrong_args("--symmetric --encrypt [filename]");
 	else if(opt.s2k_mode==0)
 	  log_error(_("you cannot use --symmetric --encrypt"
 		      " with --s2k-mode 0\n"));
 	else if (PGP7)
 	  log_error(_("you cannot use --symmetric --encrypt"
 		      " in %s mode\n"),
 		    gnupg_compliance_option_string (opt.compliance));
 	else
 	  {
 	    if( (rc = encrypt_crypt (ctrl, -1, fname, remusr, 1, NULL, -1)) )
               {
                 write_status_failure ("encrypt", rc);
                 log_error ("%s: encryption failed: %s\n",
                            print_fname_stdin(fname), gpg_strerror (rc) );
               }
 	  }
 	break;
 
       case aSign: /* sign the given file */
 	sl = NULL;
 	if( detached_sig ) { /* sign all files */
 	    for( ; argc; argc--, argv++ )
 		add_to_strlist( &sl, *argv );
 	}
 	else {
 	    if( argc > 1 )
 		wrong_args("--sign [filename]");
 	    if( argc ) {
 		sl = xmalloc_clear( sizeof *sl + strlen(fname));
 		strcpy(sl->d, fname);
 	    }
 	}
 	if ((rc = sign_file (ctrl, sl, detached_sig, locusr, 0, NULL, NULL)))
           {
             write_status_failure ("sign", rc);
 	    log_error ("signing failed: %s\n", gpg_strerror (rc) );
           }
 	free_strlist(sl);
 	break;
 
       case aSignEncr: /* sign and encrypt the given file */
 	if( argc > 1 )
 	    wrong_args("--sign --encrypt [filename]");
 	if( argc ) {
 	    sl = xmalloc_clear( sizeof *sl + strlen(fname));
 	    strcpy(sl->d, fname);
 	}
 	else
 	    sl = NULL;
 	if ((rc = sign_file (ctrl, sl, detached_sig, locusr, 1, remusr, NULL)))
           {
             write_status_failure ("sign-encrypt", rc);
 	    log_error("%s: sign+encrypt failed: %s\n",
 		      print_fname_stdin(fname), gpg_strerror (rc) );
           }
 	free_strlist(sl);
 	break;
 
       case aSignEncrSym: /* sign and encrypt the given file */
 	if( argc > 1 )
 	    wrong_args("--symmetric --sign --encrypt [filename]");
 	else if(opt.s2k_mode==0)
 	  log_error(_("you cannot use --symmetric --sign --encrypt"
 		      " with --s2k-mode 0\n"));
 	else if (PGP7)
 	  log_error(_("you cannot use --symmetric --sign --encrypt"
 		      " in %s mode\n"),
 		    gnupg_compliance_option_string (opt.compliance));
 	else
 	  {
 	    if( argc )
 	      {
 		sl = xmalloc_clear( sizeof *sl + strlen(fname));
 		strcpy(sl->d, fname);
 	      }
 	    else
 	      sl = NULL;
 	    if ((rc = sign_file (ctrl, sl, detached_sig, locusr,
                                  2, remusr, NULL)))
               {
                 write_status_failure ("sign-encrypt", rc);
                 log_error("%s: symmetric+sign+encrypt failed: %s\n",
                           print_fname_stdin(fname), gpg_strerror (rc) );
               }
 	    free_strlist(sl);
 	  }
 	break;
 
       case aSignSym: /* sign and conventionally encrypt the given file */
 	if (argc > 1)
 	    wrong_args("--sign --symmetric [filename]");
 	rc = sign_symencrypt_file (ctrl, fname, locusr);
         if (rc)
           {
             write_status_failure ("sign-symencrypt", rc);
 	    log_error("%s: sign+symmetric failed: %s\n",
                       print_fname_stdin(fname), gpg_strerror (rc) );
           }
 	break;
 
       case aClearsign: /* make a clearsig */
 	if( argc > 1 )
 	    wrong_args("--clear-sign [filename]");
 	if( (rc = clearsign_file (ctrl, fname, locusr, NULL)) )
           {
             write_status_failure ("sign", rc);
 	    log_error("%s: clear-sign failed: %s\n",
                       print_fname_stdin(fname), gpg_strerror (rc) );
           }
 	break;
 
       case aVerify:
 	if (multifile)
 	  {
 	    if ((rc = verify_files (ctrl, argc, argv)))
 	      log_error("verify files failed: %s\n", gpg_strerror (rc) );
 	  }
 	else
 	  {
 	    if ((rc = verify_signatures (ctrl, argc, argv)))
 	      log_error("verify signatures failed: %s\n", gpg_strerror (rc) );
 	  }
         if (rc)
           write_status_failure ("verify", rc);
 	break;
 
       case aDecrypt:
         if (multifile)
 	  decrypt_messages (ctrl, argc, argv);
 	else
 	  {
 	    if( argc > 1 )
 	      wrong_args("--decrypt [filename]");
 	    if( (rc = decrypt_message (ctrl, fname) ))
               {
                 write_status_failure ("decrypt", rc);
                 log_error("decrypt_message failed: %s\n", gpg_strerror (rc) );
               }
 	  }
 	break;
 
       case aQuickSignKey:
       case aQuickLSignKey:
         {
           const char *fpr;
 
           if (argc < 1)
             wrong_args ("--quick-[l]sign-key fingerprint [userids]");
           fpr = *argv++; argc--;
           sl = NULL;
           for( ; argc; argc--, argv++)
 	    append_to_strlist2 (&sl, *argv, utf8_strings);
           keyedit_quick_sign (ctrl, fpr, sl, locusr, (cmd == aQuickLSignKey));
           free_strlist (sl);
         }
 	break;
 
       case aQuickRevSig:
         {
           const char *userid, *siguserid;
 
           if (argc < 2)
             wrong_args ("--quick-revoke-sig USER-ID SIG-USER-ID [userids]");
           userid = *argv++; argc--;
           siguserid = *argv++; argc--;
           sl = NULL;
           for( ; argc; argc--, argv++)
 	    append_to_strlist2 (&sl, *argv, utf8_strings);
           keyedit_quick_revsig (ctrl, userid, siguserid, sl);
           free_strlist (sl);
         }
 	break;
 
       case aSignKey:
 	if( argc != 1 )
 	  wrong_args("--sign-key user-id");
 	/* fall through */
       case aLSignKey:
 	if( argc != 1 )
 	  wrong_args("--lsign-key user-id");
 	/* fall through */
 
 	sl=NULL;
 
 	if(cmd==aSignKey)
 	  append_to_strlist(&sl,"sign");
 	else if(cmd==aLSignKey)
 	  append_to_strlist(&sl,"lsign");
 	else
 	  BUG();
 
 	append_to_strlist( &sl, "save" );
 	username = make_username( fname );
 	keyedit_menu (ctrl, username, locusr, sl, 0, 0 );
 	xfree(username);
 	free_strlist(sl);
 	break;
 
       case aEditKey: /* Edit a key signature */
 	if( !argc )
 	    wrong_args("--edit-key user-id [commands]");
 	username = make_username( fname );
 	if( argc > 1 ) {
 	    sl = NULL;
 	    for( argc--, argv++ ; argc; argc--, argv++ )
 		append_to_strlist( &sl, *argv );
 	    keyedit_menu (ctrl, username, locusr, sl, 0, 1 );
 	    free_strlist(sl);
 	}
 	else
             keyedit_menu (ctrl, username, locusr, NULL, 0, 1 );
 	xfree(username);
 	break;
 
       case aPasswd:
         if (argc != 1)
           wrong_args("--change-passphrase <user-id>");
         else
           {
             username = make_username (fname);
             keyedit_passwd (ctrl, username);
             xfree (username);
           }
         break;
 
       case aDeleteKeys:
       case aDeleteSecretKeys:
       case aDeleteSecretAndPublicKeys:
 	sl = NULL;
         /* Print a note if the user did not specify any key.  */
         if (!argc && !opt.quiet)
           log_info (_("Note: %s\n"), gpg_strerror (GPG_ERR_NO_KEY));
         /* I'm adding these in reverse order as add_to_strlist2
            reverses them again, and it's easier to understand in the
            proper order :) */
 	for( ; argc; argc-- )
 	  add_to_strlist2( &sl, argv[argc-1], utf8_strings );
 	delete_keys (ctrl, sl,
                      cmd==aDeleteSecretKeys, cmd==aDeleteSecretAndPublicKeys);
 	free_strlist(sl);
 	break;
 
       case aCheckKeys:
 	opt.check_sigs = 1; /* fall through */
       case aListSigs:
 	opt.list_sigs = 1; /* fall through */
       case aListKeys:
 	sl = NULL;
 	for( ; argc; argc--, argv++ )
 	    add_to_strlist2( &sl, *argv, utf8_strings );
 	public_key_list (ctrl, sl, 0, 0);
 	free_strlist(sl);
 	break;
       case aListSecretKeys:
 	sl = NULL;
 	for( ; argc; argc--, argv++ )
 	    add_to_strlist2( &sl, *argv, utf8_strings );
 	secret_key_list (ctrl, sl);
 	free_strlist(sl);
 	break;
       case aLocateKeys:
       case aLocateExtKeys:
 	sl = NULL;
 	for (; argc; argc--, argv++)
           add_to_strlist2( &sl, *argv, utf8_strings );
         if (cmd == aLocateExtKeys && akl_empty_or_only_local ())
           {
             /* This is a kludge to let --locate-external-keys even
              * work if the config file has --no-auto-key-locate.  This
              * better matches the expectations of the user.  */
             release_akl ();
             parse_auto_key_locate (DEFAULT_AKL_LIST);
           }
 	public_key_list (ctrl, sl, 1, cmd == aLocateExtKeys);
 
 
 	free_strlist (sl);
 	break;
 
       case aQuickKeygen:
         {
           const char *x_algo, *x_usage, *x_expire;
 
           if (argc < 1 || argc > 4)
             wrong_args("--quick-generate-key USER-ID [ALGO [USAGE [EXPIRE]]]");
           username = make_username (fname);
           argv++, argc--;
           x_algo = "";
           x_usage = "";
           x_expire = "";
           if (argc)
             {
               x_algo = *argv++; argc--;
               if (argc)
                 {
                   x_usage = *argv++; argc--;
                   if (argc)
                     {
                       x_expire = *argv++; argc--;
                     }
                 }
             }
           quick_generate_keypair (ctrl, username, x_algo, x_usage, x_expire);
           xfree (username);
         }
         break;
 
       case aKeygen: /* generate a key */
 	if( opt.batch ) {
 	    if( argc > 1 )
 		wrong_args("--generate-key [parameterfile]");
 	    generate_keypair (ctrl, 0, argc? *argv : NULL, NULL, 0);
 	}
 	else {
             if (opt.command_fd != -1 && argc)
               {
                 if( argc > 1 )
                   wrong_args("--generate-key [parameterfile]");
 
                 opt.batch = 1;
                 generate_keypair (ctrl, 0, argc? *argv : NULL, NULL, 0);
               }
             else if (argc)
               wrong_args ("--generate-key");
             else
               generate_keypair (ctrl, 0, NULL, NULL, 0);
 	}
 	break;
 
       case aFullKeygen: /* Generate a key with all options. */
 	if (opt.batch)
           {
 	    if (argc > 1)
               wrong_args ("--full-generate-key [parameterfile]");
 	    generate_keypair (ctrl, 1, argc? *argv : NULL, NULL, 0);
           }
 	else
           {
 	    if (argc)
               wrong_args("--full-generate-key");
 	    generate_keypair (ctrl, 1, NULL, NULL, 0);
 	}
 	break;
 
       case aQuickAddUid:
         {
           const char *uid, *newuid;
 
           if (argc != 2)
             wrong_args ("--quick-add-uid USER-ID NEW-USER-ID");
           uid = *argv++; argc--;
           newuid = *argv++; argc--;
           keyedit_quick_adduid (ctrl, uid, newuid);
         }
 	break;
 
       case aQuickAddKey:
         {
           const char *x_fpr, *x_algo, *x_usage, *x_expire;
 
           if (argc < 1 || argc > 4)
             wrong_args ("--quick-add-key FINGERPRINT [ALGO [USAGE [EXPIRE]]]");
           x_fpr = *argv++; argc--;
           x_algo = "";
           x_usage = "";
           x_expire = "";
           if (argc)
             {
               x_algo = *argv++; argc--;
               if (argc)
                 {
                   x_usage = *argv++; argc--;
                   if (argc)
                    {
                      x_expire = *argv++; argc--;
                    }
                 }
             }
           keyedit_quick_addkey (ctrl, x_fpr, x_algo, x_usage, x_expire);
         }
 	break;
 
       case aQuickRevUid:
         {
           const char *uid, *uidtorev;
 
           if (argc != 2)
             wrong_args ("--quick-revoke-uid USER-ID USER-ID-TO-REVOKE");
           uid = *argv++; argc--;
           uidtorev = *argv++; argc--;
           keyedit_quick_revuid (ctrl, uid, uidtorev);
         }
 	break;
 
       case aQuickSetExpire:
         {
           const char *x_fpr, *x_expire;
 
           if (argc < 2)
             wrong_args ("--quick-set-exipre FINGERPRINT EXPIRE [SUBKEY-FPRS]");
           x_fpr = *argv++; argc--;
           x_expire = *argv++; argc--;
           keyedit_quick_set_expire (ctrl, x_fpr, x_expire, argv);
         }
 	break;
 
       case aQuickSetPrimaryUid:
         {
           const char *uid, *primaryuid;
 
           if (argc != 2)
             wrong_args ("--quick-set-primary-uid USER-ID PRIMARY-USER-ID");
           uid = *argv++; argc--;
           primaryuid = *argv++; argc--;
           keyedit_quick_set_primary (ctrl, uid, primaryuid);
         }
 	break;
 
       case aFastImport:
         opt.import_options |= IMPORT_FAST; /* fall through */
       case aImport:
       case aShowKeys:
 	import_keys (ctrl, argc? argv:NULL, argc, NULL,
                      opt.import_options, opt.key_origin, opt.key_origin_url);
 	break;
 
 	/* TODO: There are a number of command that use this same
 	   "make strlist, call function, report error, free strlist"
 	   pattern.  Join them together here and avoid all that
 	   duplicated code. */
 
       case aExport:
       case aSendKeys:
       case aRecvKeys:
 	sl = NULL;
 	for( ; argc; argc--, argv++ )
 	    append_to_strlist2( &sl, *argv, utf8_strings );
 	if( cmd == aSendKeys )
             rc = keyserver_export (ctrl, sl );
 	else if( cmd == aRecvKeys )
             rc = keyserver_import (ctrl, sl );
 	else
           {
             export_stats_t stats = export_new_stats ();
             rc = export_pubkeys (ctrl, sl, opt.export_options, stats);
             export_print_stats (stats);
             export_release_stats (stats);
           }
 	if(rc)
 	  {
 	    if(cmd==aSendKeys)
               {
                 write_status_failure ("send-keys", rc);
                 log_error(_("keyserver send failed: %s\n"),gpg_strerror (rc));
               }
 	    else if(cmd==aRecvKeys)
               {
                 write_status_failure ("recv-keys", rc);
                 log_error (_("keyserver receive failed: %s\n"),
                            gpg_strerror (rc));
               }
 	    else
               {
                 write_status_failure ("export", rc);
                 log_error (_("key export failed: %s\n"), gpg_strerror (rc));
               }
 	  }
 	free_strlist(sl);
 	break;
 
       case aExportSshKey:
         if (argc != 1)
           wrong_args ("--export-ssh-key <user-id>");
         rc = export_ssh_key (ctrl, argv[0]);
         if (rc)
           {
             write_status_failure ("export-ssh-key", rc);
             log_error (_("export as ssh key failed: %s\n"), gpg_strerror (rc));
           }
 	break;
 
      case aSearchKeys:
 	sl = NULL;
 	for (; argc; argc--, argv++)
 	  append_to_strlist2 (&sl, *argv, utf8_strings);
 	rc = keyserver_search (ctrl, sl);
 	if (rc)
           {
             write_status_failure ("search-keys", rc);
             log_error (_("keyserver search failed: %s\n"), gpg_strerror (rc));
           }
 	free_strlist (sl);
 	break;
 
       case aRefreshKeys:
 	sl = NULL;
 	for( ; argc; argc--, argv++ )
 	    append_to_strlist2( &sl, *argv, utf8_strings );
 	rc = keyserver_refresh (ctrl, sl);
 	if(rc)
           {
             write_status_failure ("refresh-keys", rc);
             log_error (_("keyserver refresh failed: %s\n"),gpg_strerror (rc));
           }
 	free_strlist(sl);
 	break;
 
       case aFetchKeys:
 	sl = NULL;
 	for( ; argc; argc--, argv++ )
 	    append_to_strlist2( &sl, *argv, utf8_strings );
 	rc = keyserver_fetch (ctrl, sl, opt.key_origin);
 	if(rc)
           {
             write_status_failure ("fetch-keys", rc);
             log_error ("key fetch failed: %s\n",gpg_strerror (rc));
           }
 	free_strlist(sl);
 	break;
 
       case aExportSecret:
 	sl = NULL;
 	for( ; argc; argc--, argv++ )
 	    add_to_strlist2( &sl, *argv, utf8_strings );
         {
           export_stats_t stats = export_new_stats ();
           export_seckeys (ctrl, sl, opt.export_options, stats);
           export_print_stats (stats);
           export_release_stats (stats);
         }
 	free_strlist(sl);
 	break;
 
       case aExportSecretSub:
 	sl = NULL;
 	for( ; argc; argc--, argv++ )
 	    add_to_strlist2( &sl, *argv, utf8_strings );
         {
           export_stats_t stats = export_new_stats ();
           export_secsubkeys (ctrl, sl, opt.export_options, stats);
           export_print_stats (stats);
           export_release_stats (stats);
         }
 	free_strlist(sl);
 	break;
 
       case aGenRevoke:
 	if( argc != 1 )
 	    wrong_args("--generate-revocation user-id");
 	username =  make_username(*argv);
 	gen_revoke (ctrl, username );
 	xfree( username );
 	break;
 
       case aDesigRevoke:
 	if (argc != 1)
 	    wrong_args ("--generate-designated-revocation user-id");
 	username = make_username (*argv);
 	gen_desig_revoke (ctrl, username, locusr);
 	xfree (username);
 	break;
 
       case aDeArmor:
 	if( argc > 1 )
 	    wrong_args("--dearmor [file]");
 	rc = dearmor_file( argc? *argv: NULL );
 	if( rc )
           {
             write_status_failure ("dearmor", rc);
             log_error (_("dearmoring failed: %s\n"), gpg_strerror (rc));
           }
 	break;
 
       case aEnArmor:
 	if( argc > 1 )
 	    wrong_args("--enarmor [file]");
 	rc = enarmor_file( argc? *argv: NULL );
 	if( rc )
           {
             write_status_failure ("enarmor", rc);
 	    log_error (_("enarmoring failed: %s\n"), gpg_strerror (rc));
           }
 	break;
 
 
       case aPrimegen:
 #if 0 /*FIXME*/
 	{   int mode = argc < 2 ? 0 : atoi(*argv);
 
 	    if( mode == 1 && argc == 2 ) {
 		mpi_print (es_stdout,
                            generate_public_prime( atoi(argv[1]) ), 1);
 	    }
 	    else if( mode == 2 && argc == 3 ) {
 		mpi_print (es_stdout, generate_elg_prime(
 					     0, atoi(argv[1]),
 					     atoi(argv[2]), NULL,NULL ), 1);
 	    }
 	    else if( mode == 3 && argc == 3 ) {
 		MPI *factors;
 		mpi_print (es_stdout, generate_elg_prime(
 					     1, atoi(argv[1]),
 					     atoi(argv[2]), NULL,&factors ), 1);
 		es_putc ('\n', es_stdout);
 		mpi_print (es_stdout, factors[0], 1 ); /* print q */
 	    }
 	    else if( mode == 4 && argc == 3 ) {
 		MPI g = mpi_alloc(1);
 		mpi_print (es_stdout, generate_elg_prime(
 						 0, atoi(argv[1]),
 						 atoi(argv[2]), g, NULL ), 1);
 		es_putc ('\n', es_stdout);
 		mpi_print (es_stdout, g, 1 );
 		mpi_free (g);
 	    }
 	    else
 		wrong_args("--gen-prime mode bits [qbits] ");
 	    es_putc ('\n', es_stdout);
 	}
 #endif
         wrong_args("--gen-prime not yet supported ");
 	break;
 
       case aGenRandom:
 	{
           int level = argc ? atoi(*argv):0;
           int count = argc > 1 ? atoi(argv[1]): 0;
           int endless = !count;
           int hexhack = (level == 16);
 
           if (hexhack)
             level = 1;
 
           if (argc < 1 || argc > 2 || level < 0 || level > 2 || count < 0)
             wrong_args ("--gen-random 0|1|2 [count]");
 
           while (endless || count)
             {
               byte *p;
               /* We need a multiple of 3, so that in case of armored
                * output we get a correct string.  No linefolding is
                * done, as it is best to leave this to other tools */
               size_t n = !endless && count < 99? count : 99;
               size_t nn;
 
               p = gcry_random_bytes (n, level);
 #ifdef HAVE_DOSISH_SYSTEM
               setmode ( fileno(stdout), O_BINARY );
 #endif
               if (hexhack)
                 {
                   for (nn = 0; nn < n; nn++)
                     es_fprintf (es_stdout, "%02x", p[nn]);
                 }
               else if (opt.armor)
                 {
                   char *tmp = make_radix64_string (p, n);
                   es_fputs (tmp, es_stdout);
                   xfree (tmp);
                   if (n%3 == 1)
                     es_putc ('=', es_stdout);
                   if (n%3)
                     es_putc ('=', es_stdout);
                 }
               else
                 {
                   es_fwrite( p, n, 1, es_stdout );
                 }
               xfree(p);
               if (!endless)
                 count -= n;
 	    }
           if (opt.armor || hexhack)
             es_putc ('\n', es_stdout);
 	}
 	break;
 
       case aPrintMD:
 	if( argc < 1)
 	    wrong_args("--print-md algo [files]");
 	{
 	    int all_algos = (**argv=='*' && !(*argv)[1]);
 	    int algo = all_algos? 0 : gcry_md_map_name (*argv);
 
 	    if( !algo && !all_algos )
 		log_error(_("invalid hash algorithm '%s'\n"), *argv );
 	    else {
 		argc--; argv++;
 		if( !argc )
 		    print_mds(NULL, algo);
 		else {
 		    for(; argc; argc--, argv++ )
 			print_mds(*argv, algo);
 		}
 	    }
 	}
 	break;
 
       case aPrintMDs: /* old option */
 	if( !argc )
 	    print_mds(NULL,0);
 	else {
 	    for(; argc; argc--, argv++ )
 		print_mds(*argv,0);
 	}
 	break;
 
 #ifndef NO_TRUST_MODELS
       case aListTrustDB:
 	if( !argc )
           list_trustdb (ctrl, es_stdout, NULL);
 	else {
 	    for( ; argc; argc--, argv++ )
               list_trustdb (ctrl, es_stdout, *argv );
 	}
 	break;
 
       case aUpdateTrustDB:
 	if( argc )
 	    wrong_args("--update-trustdb");
 	update_trustdb (ctrl);
 	break;
 
       case aCheckTrustDB:
         /* Old versions allowed for arguments - ignore them */
         check_trustdb (ctrl);
 	break;
 
       case aFixTrustDB:
         how_to_fix_the_trustdb ();
 	break;
 
       case aListTrustPath:
 	if( !argc )
 	    wrong_args("--list-trust-path <user-ids>");
 	for( ; argc; argc--, argv++ ) {
 	    username = make_username( *argv );
 	    list_trust_path( username );
 	    xfree(username);
 	}
 	break;
 
       case aExportOwnerTrust:
 	if( argc )
 	    wrong_args("--export-ownertrust");
 	export_ownertrust (ctrl);
 	break;
 
       case aImportOwnerTrust:
 	if( argc > 1 )
 	    wrong_args("--import-ownertrust [file]");
 	import_ownertrust (ctrl, argc? *argv:NULL );
 	break;
 #endif /*!NO_TRUST_MODELS*/
 
       case aRebuildKeydbCaches:
         if (argc)
             wrong_args ("--rebuild-keydb-caches");
         keydb_rebuild_caches (ctrl, 1);
         break;
 
 #ifdef ENABLE_CARD_SUPPORT
       case aCardStatus:
         if (argc == 0)
             card_status (ctrl, es_stdout, NULL);
         else if (argc == 1)
             card_status (ctrl, es_stdout, *argv);
         else
             wrong_args ("--card-status [serialno]");
         break;
 
       case aCardEdit:
         if (argc) {
             sl = NULL;
             for (argc--, argv++ ; argc; argc--, argv++)
                 append_to_strlist (&sl, *argv);
             card_edit (ctrl, sl);
             free_strlist (sl);
 	}
         else
           card_edit (ctrl, NULL);
         break;
 
       case aChangePIN:
         if (!argc)
             change_pin (0,1);
         else if (argc == 1)
             change_pin (atoi (*argv),1);
         else
             wrong_args ("--change-pin [no]");
         break;
 #endif /* ENABLE_CARD_SUPPORT*/
 
       case aListConfig:
 	{
 	  char *str=collapse_args(argc,argv);
 	  list_config(str);
 	  xfree(str);
 	}
 	break;
 
       case aListGcryptConfig:
         /* Fixme: It would be nice to integrate that with
            --list-config but unfortunately there is no way yet to have
            libgcrypt print it to an estream for further parsing.  */
         gcry_control (GCRYCTL_PRINT_CONFIG, stdout);
         break;
 
       case aTOFUPolicy:
 #ifdef USE_TOFU
 	{
 	  int policy;
 	  int i;
 	  KEYDB_HANDLE hd;
 
 	  if (argc < 2)
 	    wrong_args ("--tofu-policy POLICY KEYID [KEYID...]");
 
 	  policy = parse_tofu_policy (argv[0]);
 
 	  hd = keydb_new (ctrl);
 	  if (! hd)
             {
               write_status_failure ("tofu-driver", gpg_error(GPG_ERR_GENERAL));
               g10_exit (1);
             }
 
           tofu_begin_batch_update (ctrl);
 
 	  for (i = 1; i < argc; i ++)
 	    {
 	      KEYDB_SEARCH_DESC desc;
 	      kbnode_t kb;
 
 	      rc = classify_user_id (argv[i], &desc, 0);
 	      if (rc)
 		{
 		  log_error (_("error parsing key specification '%s': %s\n"),
                              argv[i], gpg_strerror (rc));
                   write_status_failure ("tofu-driver", rc);
 		  g10_exit (1);
 		}
 
 	      if (! (desc.mode == KEYDB_SEARCH_MODE_SHORT_KID
 		     || desc.mode == KEYDB_SEARCH_MODE_LONG_KID
 		     || desc.mode == KEYDB_SEARCH_MODE_FPR
 		     || desc.mode == KEYDB_SEARCH_MODE_KEYGRIP))
 		{
 		  log_error (_("'%s' does not appear to be a valid"
 			       " key ID, fingerprint or keygrip\n"),
 			     argv[i]);
                   write_status_failure ("tofu-driver",
                                         gpg_error(GPG_ERR_GENERAL));
 		  g10_exit (1);
 		}
 
 	      rc = keydb_search_reset (hd);
 	      if (rc)
 		{
                   /* This should not happen, thus no need to tranalate
                      the string.  */
                   log_error ("keydb_search_reset failed: %s\n",
                              gpg_strerror (rc));
                   write_status_failure ("tofu-driver", rc);
 		  g10_exit (1);
 		}
 
 	      rc = keydb_search (hd, &desc, 1, NULL);
 	      if (rc)
 		{
 		  log_error (_("key \"%s\" not found: %s\n"), argv[i],
                              gpg_strerror (rc));
                   write_status_failure ("tofu-driver", rc);
 		  g10_exit (1);
 		}
 
 	      rc = keydb_get_keyblock (hd, &kb);
 	      if (rc)
 		{
 		  log_error (_("error reading keyblock: %s\n"),
                              gpg_strerror (rc));
                   write_status_failure ("tofu-driver", rc);
 		  g10_exit (1);
 		}
 
 	      merge_keys_and_selfsig (ctrl, kb);
 	      if (tofu_set_policy (ctrl, kb, policy))
                 {
                   write_status_failure ("tofu-driver", rc);
                   g10_exit (1);
                 }
 
               release_kbnode (kb);
 	    }
 
           tofu_end_batch_update (ctrl);
 
 	  keydb_release (hd);
 	}
 #endif /*USE_TOFU*/
 	break;
 
       default:
         if (!opt.quiet)
           log_info (_("WARNING: no command supplied."
                       "  Trying to guess what you mean ...\n"));
         /*FALLTHRU*/
       case aListPackets:
 	if( argc > 1 )
 	    wrong_args("[filename]");
 	/* Issue some output for the unix newbie */
 	if (!fname && !opt.outfile
             && gnupg_isatty (fileno (stdin))
             && gnupg_isatty (fileno (stdout))
             && gnupg_isatty (fileno (stderr)))
 	    log_info(_("Go ahead and type your message ...\n"));
 
 	a = iobuf_open(fname);
         if (a && is_secured_file (iobuf_get_fd (a)))
           {
             iobuf_close (a);
             a = NULL;
             gpg_err_set_errno (EPERM);
           }
 	if( !a )
 	    log_error(_("can't open '%s'\n"), print_fname_stdin(fname));
 	else {
 
 	    if( !opt.no_armor ) {
 		if( use_armor_filter( a ) ) {
 		    afx = new_armor_context ();
 		    push_armor_filter (afx, a);
 		}
 	    }
 	    if( cmd == aListPackets ) {
 		opt.list_packets=1;
 		set_packet_list_mode(1);
 	    }
 	    rc = proc_packets (ctrl, NULL, a );
 	    if( rc )
               {
                 write_status_failure ("-", rc);
                 log_error ("processing message failed: %s\n",
                            gpg_strerror (rc));
               }
 	    iobuf_close(a);
 	}
 	break;
       }
 
     /* cleanup */
     gpg_deinit_default_ctrl (ctrl);
     xfree (ctrl);
     release_armor_context (afx);
     FREE_STRLIST(remusr);
     FREE_STRLIST(locusr);
     g10_exit(0);
     return 8; /*NEVER REACHED*/
 }
 
 
 /* Note: This function is used by signal handlers!. */
 static void
 emergency_cleanup (void)
 {
   gcry_control (GCRYCTL_TERM_SECMEM );
 }
 
 
 void
 g10_exit( int rc )
 {
   /* If we had an error but not printed an error message, do it now.
    * Note that write_status_failure will never print a second failure
    * status line. */
   if (rc)
     write_status_failure ("gpg-exit", gpg_error (GPG_ERR_GENERAL));
 
   gcry_control (GCRYCTL_UPDATE_RANDOM_SEED_FILE);
   if (DBG_CLOCK)
     log_clock ("stop");
 
   if ( (opt.debug & DBG_MEMSTAT_VALUE) )
     {
       keydb_dump_stats ();
       sig_check_dump_stats ();
       objcache_dump_stats ();
       gcry_control (GCRYCTL_DUMP_MEMORY_STATS);
       gcry_control (GCRYCTL_DUMP_RANDOM_STATS);
     }
   if (opt.debug)
     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
 
   gnupg_block_all_signals ();
   emergency_cleanup ();
 
   rc = rc? rc : log_get_errorcount(0)? 2 : g10_errors_seen? 1 : 0;
   exit (rc);
 }
 
 
 /* Pretty-print hex hashes.  This assumes at least an 80-character
    display, but there are a few other similar assumptions in the
    display code. */
 static void
 print_hex (gcry_md_hd_t md, int algo, const char *fname)
 {
   int i,n,count,indent=0;
   const byte *p;
 
   if (fname)
     indent = es_printf("%s: ",fname);
 
   if (indent>40)
     {
       es_printf ("\n");
       indent=0;
     }
 
   if (algo==DIGEST_ALGO_RMD160)
     indent += es_printf("RMD160 = ");
   else if (algo>0)
     indent += es_printf("%6s = ", gcry_md_algo_name (algo));
   else
     algo = abs(algo);
 
   count = indent;
 
   p = gcry_md_read (md, algo);
   n = gcry_md_get_algo_dlen (algo);
 
   count += es_printf ("%02X",*p++);
 
   for(i=1;i<n;i++,p++)
     {
       if(n==16)
 	{
 	  if(count+2>79)
 	    {
 	      es_printf ("\n%*s",indent," ");
 	      count = indent;
 	    }
 	  else
 	    count += es_printf(" ");
 
 	  if (!(i%8))
 	    count += es_printf(" ");
 	}
       else if (n==20)
 	{
 	  if(!(i%2))
 	    {
 	      if(count+4>79)
 		{
 		  es_printf ("\n%*s",indent," ");
 		  count=indent;
 		}
 	      else
 		count += es_printf(" ");
 	    }
 
 	  if (!(i%10))
 	    count += es_printf(" ");
 	}
       else
 	{
 	  if(!(i%4))
 	    {
 	      if (count+8>79)
 		{
 		  es_printf ("\n%*s",indent," ");
 		  count=indent;
 		}
 	      else
 		count += es_printf(" ");
 	    }
 	}
 
       count += es_printf("%02X",*p);
     }
 
   es_printf ("\n");
 }
 
 static void
 print_hashline( gcry_md_hd_t md, int algo, const char *fname )
 {
   int i, n;
   const byte *p;
 
   if ( fname )
     {
       for (p = fname; *p; p++ )
         {
           if ( *p <= 32 || *p > 127 || *p == ':' || *p == '%' )
             es_printf ("%%%02X", *p );
           else
             es_putc (*p, es_stdout);
         }
     }
   es_putc (':', es_stdout);
   es_printf ("%d:", algo);
   p = gcry_md_read (md, algo);
   n = gcry_md_get_algo_dlen (algo);
   for(i=0; i < n ; i++, p++ )
     es_printf ("%02X", *p);
   es_fputs (":\n", es_stdout);
 }
 
 
 static void
 print_mds( const char *fname, int algo )
 {
   estream_t fp;
   char buf[1024];
   size_t n;
   gcry_md_hd_t md;
 
   if (!fname)
     {
       fp = es_stdin;
       es_set_binary (fp);
     }
   else
     {
       fp = es_fopen (fname, "rb" );
       if (fp && is_secured_file (es_fileno (fp)))
         {
           es_fclose (fp);
           fp = NULL;
           gpg_err_set_errno (EPERM);
         }
     }
   if (!fp)
     {
       log_error("%s: %s\n", fname?fname:"[stdin]", strerror(errno) );
       return;
     }
 
   gcry_md_open (&md, 0, 0);
   if (algo)
     gcry_md_enable (md, algo);
   else
     {
       if (!gcry_md_test_algo (GCRY_MD_MD5))
         gcry_md_enable (md, GCRY_MD_MD5);
       gcry_md_enable (md, GCRY_MD_SHA1);
       if (!gcry_md_test_algo (GCRY_MD_RMD160))
         gcry_md_enable (md, GCRY_MD_RMD160);
       if (!gcry_md_test_algo (GCRY_MD_SHA224))
         gcry_md_enable (md, GCRY_MD_SHA224);
       if (!gcry_md_test_algo (GCRY_MD_SHA256))
         gcry_md_enable (md, GCRY_MD_SHA256);
       if (!gcry_md_test_algo (GCRY_MD_SHA384))
         gcry_md_enable (md, GCRY_MD_SHA384);
       if (!gcry_md_test_algo (GCRY_MD_SHA512))
         gcry_md_enable (md, GCRY_MD_SHA512);
     }
 
   while ((n=es_fread (buf, 1, DIM(buf), fp)))
     gcry_md_write (md, buf, n);
 
   if (es_ferror(fp))
     log_error ("%s: %s\n", fname?fname:"[stdin]", strerror(errno));
   else
     {
       gcry_md_final (md);
       if (opt.with_colons)
         {
           if ( algo )
             print_hashline (md, algo, fname);
           else
             {
               if (!gcry_md_test_algo (GCRY_MD_MD5))
                 print_hashline( md, GCRY_MD_MD5, fname );
               print_hashline( md, GCRY_MD_SHA1, fname );
               if (!gcry_md_test_algo (GCRY_MD_RMD160))
                 print_hashline( md, GCRY_MD_RMD160, fname );
               if (!gcry_md_test_algo (GCRY_MD_SHA224))
                 print_hashline (md, GCRY_MD_SHA224, fname);
               if (!gcry_md_test_algo (GCRY_MD_SHA256))
                 print_hashline( md, GCRY_MD_SHA256, fname );
               if (!gcry_md_test_algo (GCRY_MD_SHA384))
                 print_hashline ( md, GCRY_MD_SHA384, fname );
               if (!gcry_md_test_algo (GCRY_MD_SHA512))
                 print_hashline ( md, GCRY_MD_SHA512, fname );
             }
         }
       else
         {
           if (algo)
             print_hex (md, -algo, fname);
           else
             {
               if (!gcry_md_test_algo (GCRY_MD_MD5))
                 print_hex (md, GCRY_MD_MD5, fname);
               print_hex (md, GCRY_MD_SHA1, fname );
               if (!gcry_md_test_algo (GCRY_MD_RMD160))
                 print_hex (md, GCRY_MD_RMD160, fname );
               if (!gcry_md_test_algo (GCRY_MD_SHA224))
                 print_hex (md, GCRY_MD_SHA224, fname);
               if (!gcry_md_test_algo (GCRY_MD_SHA256))
                 print_hex (md, GCRY_MD_SHA256, fname );
               if (!gcry_md_test_algo (GCRY_MD_SHA384))
                 print_hex (md, GCRY_MD_SHA384, fname );
               if (!gcry_md_test_algo (GCRY_MD_SHA512))
                 print_hex (md, GCRY_MD_SHA512, fname );
             }
         }
     }
   gcry_md_close (md);
 
   if (fp != es_stdin)
     es_fclose (fp);
 }
 
 
 /****************
  * Check the supplied name,value string and add it to the notation
  * data to be used for signatures.  which==0 for sig notations, and 1
  * for cert notations.
 */
 static void
 add_notation_data( const char *string, int which )
 {
   struct notation *notation;
 
   notation=string_to_notation(string,utf8_strings);
   if(notation)
     {
       if(which)
 	{
 	  notation->next=opt.cert_notations;
 	  opt.cert_notations=notation;
 	}
       else
 	{
 	  notation->next=opt.sig_notations;
 	  opt.sig_notations=notation;
 	}
     }
 }
 
 static void
 add_policy_url( const char *string, int which )
 {
   unsigned int i,critical=0;
   strlist_t sl;
 
   if(*string=='!')
     {
       string++;
       critical=1;
     }
 
   for(i=0;i<strlen(string);i++)
     if( !isascii (string[i]) || iscntrl(string[i]))
       break;
 
   if(i==0 || i<strlen(string))
     {
       if(which)
 	log_error(_("the given certification policy URL is invalid\n"));
       else
 	log_error(_("the given signature policy URL is invalid\n"));
     }
 
   if(which)
     sl=add_to_strlist( &opt.cert_policy_url, string );
   else
     sl=add_to_strlist( &opt.sig_policy_url, string );
 
   if(critical)
     sl->flags |= 1;
 }
 
 static void
 add_keyserver_url( const char *string, int which )
 {
   unsigned int i,critical=0;
   strlist_t sl;
 
   if(*string=='!')
     {
       string++;
       critical=1;
     }
 
   for(i=0;i<strlen(string);i++)
     if( !isascii (string[i]) || iscntrl(string[i]))
       break;
 
   if(i==0 || i<strlen(string))
     {
       if(which)
 	BUG();
       else
 	log_error(_("the given preferred keyserver URL is invalid\n"));
     }
 
   if(which)
     BUG();
   else
     sl=add_to_strlist( &opt.sig_keyserver_url, string );
 
   if(critical)
     sl->flags |= 1;
 }
 
 
 static void
 read_sessionkey_from_fd (int fd)
 {
   int i, len;
   char *line;
 
   if (! gnupg_fd_valid (fd))
     log_fatal ("override-session-key-fd is invalid: %s\n", strerror (errno));
 
   for (line = NULL, i = len = 100; ; i++ )
     {
       if (i >= len-1 )
         {
           char *tmp = line;
           len += 100;
           line = xmalloc_secure (len);
           if (tmp)
             {
               memcpy (line, tmp, i);
               xfree (tmp);
             }
           else
             i=0;
 	}
       if (read (fd, line + i, 1) != 1 || line[i] == '\n')
         break;
     }
   line[i] = 0;
   log_debug ("seskey: %s\n", line);
   gpgrt_annotate_leaked_object (line);
   opt.override_session_key = line;
 }
diff --git a/g10/import.c b/g10/import.c
index 821ddf0d4..951c33d81 100644
--- a/g10/import.c
+++ b/g10/import.c
@@ -1,4682 +1,4685 @@
 /* import.c - import a key into our key storage.
  * Copyright (C) 1998-2007, 2010-2011 Free Software Foundation, Inc.
  * Copyright (C) 2014, 2016, 2017, 2019  Werner Koch
  *
  * 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 "gpg.h"
 #include "options.h"
 #include "packet.h"
 #include "../common/status.h"
 #include "keydb.h"
 #include "../common/util.h"
 #include "trustdb.h"
 #include "main.h"
 #include "../common/i18n.h"
 #include "../common/ttyio.h"
 #include "../common/recsel.h"
 #include "keyserver-internal.h"
 #include "call-agent.h"
 #include "../common/membuf.h"
 #include "../common/init.h"
 #include "../common/mbox-util.h"
 #include "key-check.h"
 #include "key-clean.h"
 
 
 struct import_stats_s
 {
   ulong count;
   ulong no_user_id;
   ulong imported;
   ulong n_uids;
   ulong n_sigs;
   ulong n_subk;
   ulong unchanged;
   ulong n_revoc;
   ulong secret_read;
   ulong secret_imported;
   ulong secret_dups;
   ulong skipped_new_keys;
   ulong not_imported;
   ulong n_sigs_cleaned;
   ulong n_uids_cleaned;
   ulong v3keys;   /* Number of V3 keys seen.  */
 };
 
 
 /* Node flag to indicate that a user ID or a subkey has a
  * valid self-signature.  */
 #define NODE_GOOD_SELFSIG  1
 /* Node flag to indicate that a user ID or subkey has
  * an invalid self-signature.  */
 #define NODE_BAD_SELFSIG   2
 /* Node flag to indicate that the node shall be deleted.  */
 #define NODE_DELETION_MARK 4
 /* A node flag used to temporary mark a node. */
 #define NODE_FLAG_A  8
 /* A flag used by transfer_secret_keys. */
 #define NODE_TRANSFER_SECKEY 16
 
 
 /* An object and a global instance to store selectors created from
  * --import-filter keep-uid=EXPR.
  * --import-filter drop-sig=EXPR.
  *
  * FIXME: We should put this into the CTRL object but that requires a
  * lot more changes right now.  For now we use save and restore
  * function to temporary change them.
  */
 /* Definition of the import filters.  */
 struct import_filter_s
 {
   recsel_expr_t keep_uid;
   recsel_expr_t drop_sig;
 };
 /* The current instance.  */
 struct import_filter_s import_filter;
 
 
 static int import (ctrl_t ctrl,
                    IOBUF inp, const char* fname, struct import_stats_s *stats,
 		   unsigned char **fpr, size_t *fpr_len, unsigned int options,
 		   import_screener_t screener, void *screener_arg,
                    int origin, const char *url);
 static int read_block (IOBUF a, unsigned int options,
                        PACKET **pending_pkt, kbnode_t *ret_root, int *r_v3keys);
 static void revocation_present (ctrl_t ctrl, kbnode_t keyblock);
 static gpg_error_t import_one (ctrl_t ctrl,
                        kbnode_t keyblock,
                        struct import_stats_s *stats,
                        unsigned char **fpr, size_t *fpr_len,
                        unsigned int options, int from_sk, int silent,
                        import_screener_t screener, void *screener_arg,
                        int origin, const char *url, int *r_valid);
 static gpg_error_t import_matching_seckeys (
                        ctrl_t ctrl, kbnode_t seckeys,
                        const byte *mainfpr, size_t mainfprlen,
                        struct import_stats_s *stats, int batch);
 static gpg_error_t import_secret_one (ctrl_t ctrl, kbnode_t keyblock,
                               struct import_stats_s *stats, int batch,
                               unsigned int options, int for_migration,
                               import_screener_t screener, void *screener_arg,
                               kbnode_t *r_secattic);
 static int import_revoke_cert (ctrl_t ctrl, kbnode_t node, unsigned int options,
                                struct import_stats_s *stats);
 static int chk_self_sigs (ctrl_t ctrl, kbnode_t keyblock, u32 *keyid,
                           int *non_self);
 static int delete_inv_parts (ctrl_t ctrl, kbnode_t keyblock,
                              u32 *keyid, unsigned int options);
 static int any_uid_left (kbnode_t keyblock);
 static void remove_all_non_self_sigs (kbnode_t *keyblock, u32 *keyid);
 static int merge_blocks (ctrl_t ctrl, unsigned int options,
                          kbnode_t keyblock_orig,
 			 kbnode_t keyblock, u32 *keyid,
                          u32 curtime, int origin, const char *url,
 			 int *n_uids, int *n_sigs, int *n_subk );
 static gpg_error_t append_new_uid (unsigned int options,
                                    kbnode_t keyblock, kbnode_t node,
                                    u32 curtime, int origin, const char *url,
                                    int *n_sigs);
 static int append_key (kbnode_t keyblock, kbnode_t node, int *n_sigs);
 static int merge_sigs (kbnode_t dst, kbnode_t src, int *n_sigs);
 static int merge_keysigs (kbnode_t dst, kbnode_t src, int *n_sigs);
 
 
 
 static void
 release_import_filter (import_filter_t filt)
 {
   recsel_release (filt->keep_uid);
   filt->keep_uid = NULL;
   recsel_release (filt->drop_sig);
   filt->drop_sig = NULL;
 }
 
 static void
 cleanup_import_globals (void)
 {
   release_import_filter (&import_filter);
 }
 
 
 int
 parse_import_options(char *str,unsigned int *options,int noisy)
 {
   struct parse_options import_opts[]=
     {
       {"import-local-sigs",IMPORT_LOCAL_SIGS,NULL,
        N_("import signatures that are marked as local-only")},
 
       {"repair-pks-subkey-bug",IMPORT_REPAIR_PKS_SUBKEY_BUG,NULL,
        N_("repair damage from the pks keyserver during import")},
 
       {"keep-ownertrust", IMPORT_KEEP_OWNERTTRUST, NULL,
        N_("do not clear the ownertrust values during import")},
 
       {"fast-import",IMPORT_FAST,NULL,
        N_("do not update the trustdb after import")},
 
       {"bulk-import",IMPORT_BULK, NULL,
        N_("enable bulk import mode")},
 
       {"import-show",IMPORT_SHOW,NULL,
        N_("show key during import")},
 
       {"show-only", (IMPORT_SHOW | IMPORT_DRY_RUN), NULL,
        N_("show key but do not actually import") },
 
       {"merge-only",IMPORT_MERGE_ONLY,NULL,
        N_("only accept updates to existing keys")},
 
       {"import-clean",IMPORT_CLEAN,NULL,
        N_("remove unusable parts from key after import")},
 
       {"import-minimal",IMPORT_MINIMAL|IMPORT_CLEAN,NULL,
        N_("remove as much as possible from key after import")},
 
       {"self-sigs-only", IMPORT_SELF_SIGS_ONLY, NULL,
        N_("ignore key-signatures which are not self-signatures")},
 
       {"import-export", IMPORT_EXPORT, NULL,
        N_("run import filters and export key immediately")},
 
       {"restore", IMPORT_RESTORE, NULL,
        N_("assume the GnuPG key backup format")},
       {"import-restore", IMPORT_RESTORE, NULL, NULL},
 
       {"repair-keys", IMPORT_REPAIR_KEYS, NULL,
        N_("repair keys on import")},
 
       /* Hidden options which are enabled by default and are provided
        * in case of problems with the respective implementation.  */
       {"collapse-uids", IMPORT_COLLAPSE_UIDS, NULL, NULL},
       {"collapse-subkeys", IMPORT_COLLAPSE_SUBKEYS, NULL, NULL},
 
       /* Aliases for backward compatibility */
       {"allow-local-sigs",IMPORT_LOCAL_SIGS,NULL,NULL},
       {"repair-hkp-subkey-bug",IMPORT_REPAIR_PKS_SUBKEY_BUG,NULL,NULL},
       /* dummy */
       {"import-unusable-sigs",0,NULL,NULL},
       {"import-clean-sigs",0,NULL,NULL},
       {"import-clean-uids",0,NULL,NULL},
       {"convert-sk-to-pk",0, NULL,NULL}, /* Not anymore needed due to
                                             the new design.  */
       {NULL,0,NULL,NULL}
     };
   int rc;
   int saved_self_sigs_only, saved_import_clean;
 
   /* We need to set flags indicating wether the user has set certain
    * options or if they came from the default.  */
   saved_self_sigs_only = (*options & IMPORT_SELF_SIGS_ONLY);
   saved_self_sigs_only &= ~IMPORT_SELF_SIGS_ONLY;
   saved_import_clean   = (*options & IMPORT_CLEAN);
   saved_import_clean   &= ~IMPORT_CLEAN;
 
   rc = parse_options (str, options, import_opts, noisy);
 
   if (rc && (*options & IMPORT_SELF_SIGS_ONLY))
     opt.flags.expl_import_self_sigs_only = 1;
   else
     *options |= saved_self_sigs_only;
 
   if (rc && (*options & IMPORT_CLEAN))
     opt.flags.expl_import_clean = 1;
   else
     *options |= saved_import_clean;
 
 
   if (rc && (*options & IMPORT_RESTORE))
     {
       /* Alter other options we want or don't want for restore.  */
       *options |= (IMPORT_LOCAL_SIGS | IMPORT_KEEP_OWNERTTRUST);
       *options &= ~(IMPORT_MINIMAL | IMPORT_CLEAN
                     | IMPORT_REPAIR_PKS_SUBKEY_BUG
                     | IMPORT_MERGE_ONLY);
     }
   return rc;
 }
 
 
 /* Parse and set an import filter from string.  STRING has the format
  * "NAME=EXPR" with NAME being the name of the filter.  Spaces before
  * and after NAME are not allowed.  If this function is all called
  * several times all expressions for the same NAME are concatenated.
  * Supported filter names are:
  *
  *  - keep-uid :: If the expression evaluates to true for a certain
  *                user ID packet, that packet and all it dependencies
  *                will be imported.  The expression may use these
  *                variables:
  *
  *                - uid  :: The entire user ID.
  *                - mbox :: The mail box part of the user ID.
  *                - primary :: Evaluate to true for the primary user ID.
  */
 gpg_error_t
 parse_and_set_import_filter (const char *string)
 {
   gpg_error_t err;
 
   /* Auto register the cleanup function.  */
   register_mem_cleanup_func (cleanup_import_globals);
 
   if (!strncmp (string, "keep-uid=", 9))
     err = recsel_parse_expr (&import_filter.keep_uid, string+9);
   else if (!strncmp (string, "drop-sig=", 9))
     err = recsel_parse_expr (&import_filter.drop_sig, string+9);
   else
     err = gpg_error (GPG_ERR_INV_NAME);
 
   return err;
 }
 
 
 /* Save the current import filters, return them, and clear the current
  * filters.  Returns NULL on error and sets ERRNO.  */
 import_filter_t
 save_and_clear_import_filter (void)
 {
   import_filter_t filt;
 
   filt = xtrycalloc (1, sizeof *filt);
   if (!filt)
     return NULL;
   *filt = import_filter;
   memset (&import_filter, 0, sizeof import_filter);
 
   return filt;
 }
 
 
 /* Release the current import filters and restore them from NEWFILT.
  * Ownership of NEWFILT is moved to this function.  */
 void
 restore_import_filter (import_filter_t filt)
 {
   if (filt)
     {
       release_import_filter (&import_filter);
       import_filter = *filt;
       xfree (filt);
     }
 }
 
 
 import_stats_t
 import_new_stats_handle (void)
 {
   return xmalloc_clear ( sizeof (struct import_stats_s) );
 }
 
 
 void
 import_release_stats_handle (import_stats_t p)
 {
   xfree (p);
 }
 
 
 /* Read a key from a file.  Only the first key in the file is
  * considered and stored at R_KEYBLOCK.  FNAME is the name of the
  * file.
  */
 gpg_error_t
 read_key_from_file_or_buffer (ctrl_t ctrl, const char *fname,
                               const void *buffer, size_t buflen,
                               kbnode_t *r_keyblock)
 {
   gpg_error_t err;
   iobuf_t inp;
   PACKET *pending_pkt = NULL;
   kbnode_t keyblock = NULL;
   u32 keyid[2];
   int v3keys;   /* Dummy */
   int non_self; /* Dummy */
 
   (void)ctrl;
 
   *r_keyblock = NULL;
 
   log_assert (!!fname ^ !!buffer);
 
   if (fname)
     {
       inp = iobuf_open (fname);
       if (!inp)
         err = gpg_error_from_syserror ();
       else if (is_secured_file (iobuf_get_fd (inp)))
         {
           iobuf_close (inp);
           inp = NULL;
           err = gpg_error (GPG_ERR_EPERM);
         }
       else
         err = 0;
       if (err)
         {
           log_error (_("can't open '%s': %s\n"),
                      iobuf_is_pipe_filename (fname)? "[stdin]": fname,
                      gpg_strerror (err));
           if (gpg_err_code (err) == GPG_ERR_ENOENT)
             err = gpg_error (GPG_ERR_NO_PUBKEY);
           goto leave;
         }
 
       /* Push the armor filter.  */
       {
         armor_filter_context_t *afx;
         afx = new_armor_context ();
         afx->only_keyblocks = 1;
         push_armor_filter (afx, inp);
         release_armor_context (afx);
       }
 
     }
   else  /* Read from buffer (No armor expected).  */
     {
       inp = iobuf_temp_with_content (buffer, buflen);
     }
 
   /* Read the first non-v3 keyblock.  */
   while (!(err = read_block (inp, 0, &pending_pkt, &keyblock, &v3keys)))
     {
       if (keyblock->pkt->pkttype == PKT_PUBLIC_KEY)
         break;
       log_info (_("skipping block of type %d\n"), keyblock->pkt->pkttype);
       release_kbnode (keyblock);
       keyblock = NULL;
     }
   if (err)
     {
       if (gpg_err_code (err) != GPG_ERR_INV_KEYRING)
         log_error (_("error reading '%s': %s\n"),
                    fname? (iobuf_is_pipe_filename (fname)? "[stdin]": fname)
                    /* */ : "[buffer]",
                    gpg_strerror (err));
       goto leave;
     }
 
   keyid_from_pk (keyblock->pkt->pkt.public_key, keyid);
 
   if (!find_next_kbnode (keyblock, PKT_USER_ID))
     {
       err = gpg_error (GPG_ERR_NO_USER_ID);
       goto leave;
     }
 
   /* We do the collapsing unconditionally although it is expected that
    * clean keys are provided here.  */
   collapse_uids (&keyblock);
   collapse_subkeys (&keyblock);
 
   clear_kbnode_flags (keyblock);
   if (chk_self_sigs (ctrl, keyblock, keyid, &non_self))
     {
       err = gpg_error (GPG_ERR_INV_KEYRING);
       goto leave;
     }
 
   if (!delete_inv_parts (ctrl, keyblock, keyid, 0) )
     {
       err = gpg_error (GPG_ERR_NO_USER_ID);
       goto leave;
     }
 
   *r_keyblock = keyblock;
   keyblock = NULL;
 
  leave:
   if (inp)
     {
       iobuf_close (inp);
       /* Must invalidate that ugly cache to actually close the file. */
       if (fname)
         iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char*)fname);
     }
   release_kbnode (keyblock);
   /* FIXME: Do we need to free PENDING_PKT ? */
   return err;
 }
 
 
 /* Import an already checked public key which was included in a
  * signature and the signature verified out using this key.  */
 gpg_error_t
 import_included_key_block (ctrl_t ctrl, kbnode_t keyblock)
 {
   gpg_error_t err;
   struct import_stats_s *stats;
   import_filter_t save_filt;
   int save_armor = opt.armor;
 
   opt.armor = 0;
   stats = import_new_stats_handle ();
   save_filt = save_and_clear_import_filter ();
   if (!save_filt)
     {
       err = gpg_error_from_syserror ();
       goto leave;
     }
 
   /* FIXME: Should we introduce a dedicated KEYORG ? */
   err = import_one (ctrl, keyblock,
                     stats, NULL, 0, 0, 0, 0,
                     NULL, NULL, KEYORG_UNKNOWN, NULL, NULL);
 
  leave:
   restore_import_filter (save_filt);
   import_release_stats_handle (stats);
   opt.armor = save_armor;
   return err;
 }
 
 
 
 /*
  * Import the public keys from the given filename. Input may be armored.
  * This function rejects all keys which are not validly self signed on at
  * least one userid. Only user ids which are self signed will be imported.
  * Other signatures are not checked.
  *
  * Actually this function does a merge. It works like this:
  *
  *  - get the keyblock
  *  - check self-signatures and remove all userids and their signatures
  *    without/invalid self-signatures.
  *  - reject the keyblock, if we have no valid userid.
  *  - See whether we have this key already in one of our pubrings.
  *    If not, simply add it to the default keyring.
  *  - Compare the key and the self-signatures of the new and the one in
  *    our keyring.  If they are different something weird is going on;
  *    ask what to do.
  *  - See whether we have only non-self-signature on one user id; if not
  *    ask the user what to do.
  *  - compare the signatures: If we already have this signature, check
  *    that they compare okay; if not, issue a warning and ask the user.
  *    (consider looking at the timestamp and use the newest?)
  *  - Simply add the signature.  Can't verify here because we may not have
  *    the signature's public key yet; verification is done when putting it
  *    into the trustdb, which is done automagically as soon as this pubkey
  *    is used.
  *  - Proceed with next signature.
  *
  *  Key revocation certificates have special handling.
  */
 static gpg_error_t
 import_keys_internal (ctrl_t ctrl, iobuf_t inp, char **fnames, int nnames,
 		      import_stats_t stats_handle,
                       unsigned char **fpr, size_t *fpr_len,
 		      unsigned int options,
                       import_screener_t screener, void *screener_arg,
                       int origin, const char *url)
 {
   int i;
   gpg_error_t err = 0;
   struct import_stats_s *stats = stats_handle;
 
   if (!stats)
     stats = import_new_stats_handle ();
 
   if (inp)
     {
       err = import (ctrl, inp, "[stream]", stats, fpr, fpr_len, options,
                     screener, screener_arg, origin, url);
     }
   else
     {
       if (!fnames && !nnames)
         nnames = 1;  /* Ohh what a ugly hack to jump into the loop */
 
       for (i=0; i < nnames; i++)
         {
           const char *fname = fnames? fnames[i] : NULL;
           IOBUF inp2 = iobuf_open(fname);
 
           if (!fname)
             fname = "[stdin]";
           if (inp2 && is_secured_file (iobuf_get_fd (inp2)))
             {
               iobuf_close (inp2);
               inp2 = NULL;
               gpg_err_set_errno (EPERM);
             }
           if (!inp2)
             log_error (_("can't open '%s': %s\n"), fname, strerror (errno));
           else
             {
               err = import (ctrl, inp2, fname, stats, fpr, fpr_len, options,
                            screener, screener_arg, origin, url);
               iobuf_close (inp2);
               /* Must invalidate that ugly cache to actually close it. */
               iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char*)fname);
               if (err)
                 log_error ("import from '%s' failed: %s\n",
                            fname, gpg_strerror (err) );
             }
           if (!fname)
             break;
 	}
     }
 
   if (!stats_handle)
     {
       if ((options & (IMPORT_SHOW | IMPORT_DRY_RUN))
           != (IMPORT_SHOW | IMPORT_DRY_RUN))
         import_print_stats (stats);
       import_release_stats_handle (stats);
     }
 
   /* If no fast import and the trustdb is dirty (i.e. we added a key
      or userID that had something other than a selfsig, a signature
      that was other than a selfsig, or any revocation), then
      update/check the trustdb if the user specified by setting
      interactive or by not setting no-auto-check-trustdb */
 
   if (!(options & IMPORT_FAST))
     check_or_update_trustdb (ctrl);
 
   return err;
 }
 
 
 void
 import_keys (ctrl_t ctrl, char **fnames, int nnames,
 	     import_stats_t stats_handle, unsigned int options,
              int origin, const char *url)
 {
   import_keys_internal (ctrl, NULL, fnames, nnames, stats_handle,
                         NULL, NULL, options, NULL, NULL, origin, url);
 }
 
 
 gpg_error_t
 import_keys_es_stream (ctrl_t ctrl, estream_t fp,
                        import_stats_t stats_handle,
                        unsigned char **fpr, size_t *fpr_len,
                        unsigned int options,
                        import_screener_t screener, void *screener_arg,
                        int origin, const char *url)
 {
   gpg_error_t err;
   iobuf_t inp;
 
   inp = iobuf_esopen (fp, "rb", 1, 0);
   if (!inp)
     {
       err = gpg_error_from_syserror ();
       log_error ("iobuf_esopen failed: %s\n", gpg_strerror (err));
       return err;
     }
 
   err = import_keys_internal (ctrl, inp, NULL, 0, stats_handle,
                              fpr, fpr_len, options,
                              screener, screener_arg, origin, url);
 
   iobuf_close (inp);
   return err;
 }
 
 
 static int
 import (ctrl_t ctrl, IOBUF inp, const char* fname,struct import_stats_s *stats,
 	unsigned char **fpr,size_t *fpr_len, unsigned int options,
 	import_screener_t screener, void *screener_arg,
         int origin, const char *url)
 {
   PACKET *pending_pkt = NULL;
   kbnode_t keyblock = NULL;  /* Need to initialize because gcc can't
                                 grasp the return semantics of
                                 read_block. */
   kbnode_t secattic = NULL;  /* Kludge for PGP desktop percularity */
   int rc = 0;
   int v3keys;
 
   getkey_disable_caches ();
 
   if (!opt.no_armor) /* Armored reading is not disabled.  */
     {
       armor_filter_context_t *afx;
 
       afx = new_armor_context ();
       afx->only_keyblocks = 1;
       push_armor_filter (afx, inp);
       release_armor_context (afx);
     }
 
   while (!(rc = read_block (inp, options, &pending_pkt, &keyblock, &v3keys)))
     {
       stats->v3keys += v3keys;
       if (keyblock->pkt->pkttype == PKT_PUBLIC_KEY)
         {
           rc = import_one (ctrl, keyblock,
                            stats, fpr, fpr_len, options, 0, 0,
                            screener, screener_arg, origin, url, NULL);
           if (secattic)
             {
               byte tmpfpr[MAX_FINGERPRINT_LEN];
               size_t tmpfprlen;
 
               if (!rc && !(opt.dry_run || (options & IMPORT_DRY_RUN)))
                 {
                   /* Kudge for PGP desktop - see below.  */
                   fingerprint_from_pk (keyblock->pkt->pkt.public_key,
                                        tmpfpr, &tmpfprlen);
                   rc = import_matching_seckeys (ctrl, secattic,
                                                 tmpfpr, tmpfprlen,
                                                 stats, opt.batch);
                 }
               release_kbnode (secattic);
               secattic = NULL;
             }
         }
       else if (keyblock->pkt->pkttype == PKT_SECRET_KEY)
         {
           release_kbnode (secattic);
           secattic = NULL;
           rc = import_secret_one (ctrl, keyblock, stats,
                                   opt.batch, options, 0,
                                   screener, screener_arg, &secattic);
           keyblock = NULL;  /* Ownership was transferred.  */
           if (secattic)
             {
               if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY)
                 rc = 0; /* Try import after the next pubkey.  */
 
               /* The attic is a workaround for the peculiar PGP
                * Desktop method of exporting a secret key: The
                * exported file is the concatenation of two armored
                * keyblocks; first the private one and then the public
                * one.  The strange thing is that the secret one has no
                * binding signatures at all and thus we have not
                * imported it.  The attic stores that secret keys and
                * we try to import it once after the very next public
                * keyblock.  */
             }
         }
       else if (keyblock->pkt->pkttype == PKT_SIGNATURE
                && IS_KEY_REV (keyblock->pkt->pkt.signature) )
         {
           release_kbnode (secattic);
           secattic = NULL;
           rc = import_revoke_cert (ctrl, keyblock, options, stats);
         }
       else
         {
           release_kbnode (secattic);
           secattic = NULL;
           log_info (_("skipping block of type %d\n"), keyblock->pkt->pkttype);
 	}
       release_kbnode (keyblock);
 
       /* fixme: we should increment the not imported counter but
          this does only make sense if we keep on going despite of
          errors.  For now we do this only if the imported key is too
          large. */
       if (gpg_err_code (rc) == GPG_ERR_TOO_LARGE
             && gpg_err_source (rc) == GPG_ERR_SOURCE_KEYBOX)
         {
           stats->not_imported++;
         }
       else if (rc)
         break;
 
       if (!(++stats->count % 100) && !opt.quiet)
         log_info (_("%lu keys processed so far\n"), stats->count );
 
       if (origin == KEYORG_WKD && stats->count >= 5)
         {
           /* We limit the number of keys _received_ from the WKD to 5.
            * In fact there should be only one key but some sites want
            * to store a few expired keys there also.  gpg's key
            * selection will later figure out which key to use.  Note
            * that for WKD we always return the fingerprint of the
            * first imported key.  */
           log_info ("import from WKD stopped after %d keys\n", 5);
           break;
         }
     }
   stats->v3keys += v3keys;
   if (rc == -1)
     rc = 0;
   else if (rc && gpg_err_code (rc) != GPG_ERR_INV_KEYRING)
     log_error (_("error reading '%s': %s\n"), fname, gpg_strerror (rc));
 
   release_kbnode (secattic);
 
   /* When read_block loop was stopped by error, we have PENDING_PKT left.  */
   if (pending_pkt)
     {
       free_packet (pending_pkt, NULL);
       xfree (pending_pkt);
     }
   return rc;
 }
 
 
 /* Helper to migrate secring.gpg to GnuPG 2.1.  */
 gpg_error_t
 import_old_secring (ctrl_t ctrl, const char *fname)
 {
   gpg_error_t err;
   iobuf_t inp;
   PACKET *pending_pkt = NULL;
   kbnode_t keyblock = NULL;  /* Need to initialize because gcc can't
                                 grasp the return semantics of
                                 read_block. */
   struct import_stats_s *stats;
   int v3keys;
 
   inp = iobuf_open (fname);
   if (inp && is_secured_file (iobuf_get_fd (inp)))
     {
       iobuf_close (inp);
       inp = NULL;
       gpg_err_set_errno (EPERM);
     }
   if (!inp)
     {
       err = gpg_error_from_syserror ();
       log_error (_("can't open '%s': %s\n"), fname, gpg_strerror (err));
       return err;
     }
 
   getkey_disable_caches();
   stats = import_new_stats_handle ();
   while (!(err = read_block (inp, 0, &pending_pkt, &keyblock, &v3keys)))
     {
       if (keyblock->pkt->pkttype == PKT_SECRET_KEY)
         {
           err = import_secret_one (ctrl, keyblock, stats, 1, 0, 1,
                                    NULL, NULL, NULL);
           keyblock = NULL; /* Ownership was transferred.  */
         }
       release_kbnode (keyblock);
       if (err)
         break;
     }
   import_release_stats_handle (stats);
   if (err == -1)
     err = 0;
   else if (err && gpg_err_code (err) != GPG_ERR_INV_KEYRING)
     log_error (_("error reading '%s': %s\n"), fname, gpg_strerror (err));
   else if (err)
     log_error ("import from '%s' failed: %s\n", fname, gpg_strerror (err));
 
   iobuf_close (inp);
   iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char*)fname);
 
   return err;
 }
 
 
 void
 import_print_stats (import_stats_t stats)
 {
   if (!opt.quiet)
     {
       log_info(_("Total number processed: %lu\n"),
                stats->count + stats->v3keys);
       if (stats->v3keys)
         log_info(_("    skipped PGP-2 keys: %lu\n"), stats->v3keys);
       if (stats->skipped_new_keys )
         log_info(_("      skipped new keys: %lu\n"),
                  stats->skipped_new_keys );
       if (stats->no_user_id )
         log_info(_("          w/o user IDs: %lu\n"), stats->no_user_id );
       if (stats->imported)
         {
           log_info(_("              imported: %lu"), stats->imported );
           log_printf ("\n");
         }
       if (stats->unchanged )
         log_info(_("             unchanged: %lu\n"), stats->unchanged );
       if (stats->n_uids )
         log_info(_("          new user IDs: %lu\n"), stats->n_uids );
       if (stats->n_subk )
         log_info(_("           new subkeys: %lu\n"), stats->n_subk );
       if (stats->n_sigs )
         log_info(_("        new signatures: %lu\n"), stats->n_sigs );
       if (stats->n_revoc )
         log_info(_("   new key revocations: %lu\n"), stats->n_revoc );
       if (stats->secret_read )
         log_info(_("      secret keys read: %lu\n"), stats->secret_read );
       if (stats->secret_imported )
         log_info(_("  secret keys imported: %lu\n"), stats->secret_imported );
       if (stats->secret_dups )
         log_info(_(" secret keys unchanged: %lu\n"), stats->secret_dups );
       if (stats->not_imported )
         log_info(_("          not imported: %lu\n"), stats->not_imported );
       if (stats->n_sigs_cleaned)
         log_info(_("    signatures cleaned: %lu\n"),stats->n_sigs_cleaned);
       if (stats->n_uids_cleaned)
         log_info(_("      user IDs cleaned: %lu\n"),stats->n_uids_cleaned);
     }
 
   if (is_status_enabled ())
     {
       char buf[15*20];
 
       snprintf (buf, sizeof buf,
                 "%lu %lu %lu 0 %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu",
 		stats->count + stats->v3keys,
 		stats->no_user_id,
 		stats->imported,
 		stats->unchanged,
 		stats->n_uids,
 		stats->n_subk,
 		stats->n_sigs,
 		stats->n_revoc,
 		stats->secret_read,
 		stats->secret_imported,
 		stats->secret_dups,
 		stats->skipped_new_keys,
                 stats->not_imported,
                 stats->v3keys );
       write_status_text (STATUS_IMPORT_RES, buf);
     }
 }
 
 
 /* Return true if PKTTYPE is valid in a keyblock.  */
 static int
 valid_keyblock_packet (int pkttype)
 {
   switch (pkttype)
     {
     case PKT_PUBLIC_KEY:
     case PKT_PUBLIC_SUBKEY:
     case PKT_SECRET_KEY:
     case PKT_SECRET_SUBKEY:
     case PKT_SIGNATURE:
     case PKT_USER_ID:
     case PKT_ATTRIBUTE:
     case PKT_RING_TRUST:
       return 1;
     default:
       return 0;
     }
 }
 
 
 /* Read the next keyblock from stream A.  Meta data (ring trust
  * packets) are only considered if OPTIONS has the IMPORT_RESTORE flag
  * set.  PENDING_PKT should be initialized to NULL and not changed by
  * the caller.
  *
  * Returns 0 for okay, -1 no more blocks, or any other errorcode.  The
  * integer at R_V3KEY counts the number of unsupported v3 keyblocks.
  */
 static int
 read_block( IOBUF a, unsigned int options,
             PACKET **pending_pkt, kbnode_t *ret_root, int *r_v3keys)
 {
   int rc;
   struct parse_packet_ctx_s parsectx;
   PACKET *pkt;
   kbnode_t root = NULL;
   kbnode_t lastnode = NULL;
   int in_cert, in_v3key, skip_sigs;
   u32 keyid[2];
   int got_keyid = 0;
   unsigned int dropped_nonselfsigs = 0;
 
   *r_v3keys = 0;
 
   if (*pending_pkt)
     {
       root = lastnode = new_kbnode( *pending_pkt );
       *pending_pkt = NULL;
       log_assert (root->pkt->pkttype == PKT_PUBLIC_KEY
                   || root->pkt->pkttype == PKT_SECRET_KEY);
       in_cert = 1;
       keyid_from_pk (root->pkt->pkt.public_key, keyid);
       got_keyid = 1;
     }
   else
     in_cert = 0;
 
   pkt = xmalloc (sizeof *pkt);
   init_packet (pkt);
   init_parse_packet (&parsectx, a);
   if (!(options & IMPORT_RESTORE))
     parsectx.skip_meta = 1;
   in_v3key = 0;
   skip_sigs = 0;
   while ((rc=parse_packet (&parsectx, pkt)) != -1)
     {
       if (rc && (gpg_err_code (rc) == GPG_ERR_LEGACY_KEY
                  && (pkt->pkttype == PKT_PUBLIC_KEY
                      || pkt->pkttype == PKT_SECRET_KEY)))
         {
           in_v3key = 1;
           ++*r_v3keys;
           free_packet (pkt, &parsectx);
           init_packet (pkt);
           continue;
         }
       else if (rc ) /* (ignore errors) */
         {
           skip_sigs = 0;
           if (gpg_err_code (rc) == GPG_ERR_UNKNOWN_PACKET)
             ; /* Do not show a diagnostic.  */
           else if (gpg_err_code (rc) == GPG_ERR_INV_PACKET
                    && (pkt->pkttype == PKT_USER_ID
                        || pkt->pkttype == PKT_ATTRIBUTE))
             {
               /* This indicates a too large user id or attribute
                * packet.  We skip this packet and all following
                * signatures.  Sure, this won't allow to repair a
                * garbled keyring in case one of the signatures belong
                * to another user id.  However, this better mitigates
                * DoS using inserted user ids.  */
               skip_sigs = 1;
             }
           else if (gpg_err_code (rc) == GPG_ERR_INV_PACKET
                    && (pkt->pkttype == PKT_OLD_COMMENT
                        || pkt->pkttype == PKT_COMMENT))
             ; /* Ignore too large comment packets.  */
           else
             {
               log_error("read_block: read error: %s\n", gpg_strerror (rc) );
               rc = GPG_ERR_INV_KEYRING;
               goto ready;
             }
           free_packet (pkt, &parsectx);
           init_packet(pkt);
           continue;
 	}
 
       if (skip_sigs)
         {
           if (pkt->pkttype == PKT_SIGNATURE)
             {
               free_packet (pkt, &parsectx);
               init_packet (pkt);
               continue;
             }
           skip_sigs = 0;
         }
 
       if (in_v3key && !(pkt->pkttype == PKT_PUBLIC_KEY
                         || pkt->pkttype == PKT_SECRET_KEY))
         {
           free_packet (pkt, &parsectx);
           init_packet(pkt);
           continue;
         }
       in_v3key = 0;
 
       if (!root && pkt->pkttype == PKT_SIGNATURE
           && IS_KEY_REV (pkt->pkt.signature) )
         {
           /* This is a revocation certificate which is handled in a
            * special way.  */
           root = new_kbnode( pkt );
           pkt = NULL;
           goto ready;
         }
 
       /* Make a linked list of all packets.  */
       switch (pkt->pkttype)
         {
         case PKT_COMPRESSED:
           if (check_compress_algo (pkt->pkt.compressed->algorithm))
             {
               rc = GPG_ERR_COMPR_ALGO;
               goto ready;
             }
           else
             {
               compress_filter_context_t *cfx = xmalloc_clear( sizeof *cfx );
               pkt->pkt.compressed->buf = NULL;
               if (push_compress_filter2 (a, cfx,
                                          pkt->pkt.compressed->algorithm, 1))
                 xfree (cfx); /* e.g. in case of compression_algo NONE.  */
             }
           free_packet (pkt, &parsectx);
           init_packet(pkt);
           break;
 
         case PKT_RING_TRUST:
           /* Skip those packets unless we are in restore mode.  */
           if ((opt.import_options & IMPORT_RESTORE))
             goto x_default;
           free_packet (pkt, &parsectx);
           init_packet(pkt);
           break;
 
         case PKT_SIGNATURE:
           if (!in_cert)
             goto x_default;
           if (!(options & IMPORT_SELF_SIGS_ONLY))
             goto x_default;
           log_assert (got_keyid);
 	  if (pkt->pkt.signature->keyid[0] == keyid[0]
               && pkt->pkt.signature->keyid[1] == keyid[1])
 	    { /* This is likely a self-signature.  We import this one.
                * Eventually we should use the ISSUER_FPR to compare
                * self-signatures, but that will work only for v5 keys
                * which are currently not even deployed.
                * Note that we do not do any crypto verify here because
                * that would defeat this very mitigation of DoS by
                * importing a key with a huge amount of faked
                * key-signatures.  A verification will be done later in
                * the processing anyway.  Here we want a cheap an early
                * way to drop non-self-signatures.  */
               goto x_default;
             }
           /* Skip this signature.  */
           dropped_nonselfsigs++;
           free_packet (pkt, &parsectx);
           init_packet(pkt);
           break;
 
         case PKT_PUBLIC_KEY:
         case PKT_SECRET_KEY:
           if (!got_keyid)
             {
               keyid_from_pk (pkt->pkt.public_key, keyid);
               got_keyid = 1;
             }
           if (in_cert) /* Store this packet.  */
             {
               *pending_pkt = pkt;
               pkt = NULL;
               goto ready;
             }
           in_cert = 1;
           goto x_default;
 
         default:
         x_default:
           if (in_cert && valid_keyblock_packet (pkt->pkttype))
             {
               if (!root )
                 root = lastnode = new_kbnode (pkt);
               else
                 {
                   lastnode->next = new_kbnode (pkt);
                   lastnode = lastnode->next;
                 }
               pkt = xmalloc (sizeof *pkt);
             }
           else
             free_packet (pkt, &parsectx);
           init_packet(pkt);
           break;
         }
     }
 
  ready:
   if (rc == -1 && root )
     rc = 0;
 
   if (rc )
     release_kbnode( root );
   else
     *ret_root = root;
   free_packet (pkt, &parsectx);
   deinit_parse_packet (&parsectx);
   xfree( pkt );
   if (!rc && dropped_nonselfsigs && opt.verbose)
     log_info ("key %s: number of dropped non-self-signatures: %u\n",
               keystr (keyid), dropped_nonselfsigs);
 
   return rc;
 }
 
 
 /* Walk through the subkeys on a pk to find if we have the PKS
    disease: multiple subkeys with their binding sigs stripped, and the
    sig for the first subkey placed after the last subkey.  That is,
    instead of "pk uid sig sub1 bind1 sub2 bind2 sub3 bind3" we have
    "pk uid sig sub1 sub2 sub3 bind1".  We can't do anything about sub2
    and sub3, as they are already lost, but we can try and rescue sub1
    by reordering the keyblock so that it reads "pk uid sig sub1 bind1
    sub2 sub3".  Returns TRUE if the keyblock was modified. */
 static int
 fix_pks_corruption (ctrl_t ctrl, kbnode_t keyblock)
 {
   int changed = 0;
   int keycount = 0;
   kbnode_t node;
   kbnode_t last = NULL;
   kbnode_t sknode=NULL;
 
   /* First determine if we have the problem at all.  Look for 2 or
      more subkeys in a row, followed by a single binding sig. */
   for (node=keyblock; node; last=node, node=node->next)
     {
       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
 	{
 	  keycount++;
 	  if(!sknode)
 	    sknode=node;
 	}
       else if (node->pkt->pkttype == PKT_SIGNATURE
                && IS_SUBKEY_SIG (node->pkt->pkt.signature)
                && keycount >= 2
                && !node->next)
 	{
 	  /* We might have the problem, as this key has two subkeys in
 	     a row without any intervening packets. */
 
 	  /* Sanity check */
 	  if (!last)
 	    break;
 
 	  /* Temporarily attach node to sknode. */
 	  node->next = sknode->next;
 	  sknode->next = node;
 	  last->next = NULL;
 
 	  /* Note we aren't checking whether this binding sig is a
 	     selfsig.  This is not necessary here as the subkey and
 	     binding sig will be rejected later if that is the
 	     case. */
 	  if (check_key_signature (ctrl, keyblock,node,NULL))
 	    {
 	      /* Not a match, so undo the changes. */
 	      sknode->next = node->next;
 	      last->next = node;
 	      node->next = NULL;
 	      break;
 	    }
 	  else
 	    {
               /* Mark it good so we don't need to check it again */
 	      sknode->flag |= NODE_GOOD_SELFSIG;
 	      changed = 1;
 	      break;
 	    }
 	}
       else
 	keycount = 0;
     }
 
   return changed;
 }
 
 
 /* Versions of GnuPG before 1.4.11 and 2.0.16 allowed to import bogus
    direct key signatures.  A side effect of this was that a later
    import of the same good direct key signatures was not possible
    because the cmp_signature check in merge_blocks considered them
    equal.  Although direct key signatures are now checked during
    import, there might still be bogus signatures sitting in a keyring.
    We need to detect and delete them before doing a merge.  This
    function returns the number of removed sigs.  */
 static int
 fix_bad_direct_key_sigs (ctrl_t ctrl, kbnode_t keyblock, u32 *keyid)
 {
   gpg_error_t err;
   kbnode_t node;
   int count = 0;
 
   for (node = keyblock->next; node; node=node->next)
     {
       if (node->pkt->pkttype == PKT_USER_ID)
         break;
       if (node->pkt->pkttype == PKT_SIGNATURE
           && IS_KEY_SIG (node->pkt->pkt.signature))
         {
           err = check_key_signature (ctrl, keyblock, node, NULL);
           if (err && gpg_err_code (err) != GPG_ERR_PUBKEY_ALGO )
             {
               /* If we don't know the error, we can't decide; this is
                  not a problem because cmp_signature can't compare the
                  signature either.  */
               log_info ("key %s: invalid direct key signature removed\n",
                         keystr (keyid));
               delete_kbnode (node);
               count++;
             }
         }
     }
 
   return count;
 }
 
 
 static void
 print_import_ok (PKT_public_key *pk, unsigned int reason)
 {
   byte array[MAX_FINGERPRINT_LEN], *s;
   char buf[MAX_FINGERPRINT_LEN*2+30], *p;
   size_t i, n;
 
   snprintf (buf, sizeof buf, "%u ", reason);
   p = buf + strlen (buf);
 
   fingerprint_from_pk (pk, array, &n);
   s = array;
   for (i=0; i < n ; i++, s++, p += 2)
     sprintf (p, "%02X", *s);
 
   write_status_text (STATUS_IMPORT_OK, buf);
 }
 
 
 static void
 print_import_check (PKT_public_key * pk, PKT_user_id * id)
 {
   byte hexfpr[2*MAX_FINGERPRINT_LEN+1];
   u32 keyid[2];
 
   keyid_from_pk (pk, keyid);
   hexfingerprint (pk, hexfpr, sizeof hexfpr);
   write_status_printf (STATUS_IMPORT_CHECK, "%08X%08X %s %s",
                        keyid[0], keyid[1], hexfpr, id->name);
 
 }
 
 
 static void
 check_prefs_warning(PKT_public_key *pk)
 {
   log_info(_("WARNING: key %s contains preferences for unavailable\n"
              "algorithms on these user IDs:\n"), keystr_from_pk(pk));
 }
 
 
 static void
 check_prefs (ctrl_t ctrl, kbnode_t keyblock)
 {
   kbnode_t node;
   PKT_public_key *pk;
   int problem=0;
 
   merge_keys_and_selfsig (ctrl, keyblock);
   pk=keyblock->pkt->pkt.public_key;
 
   for(node=keyblock;node;node=node->next)
     {
       if(node->pkt->pkttype==PKT_USER_ID
 	 && node->pkt->pkt.user_id->created
 	 && node->pkt->pkt.user_id->prefs)
 	{
 	  PKT_user_id *uid = node->pkt->pkt.user_id;
 	  prefitem_t *prefs = uid->prefs;
 	  char *user = utf8_to_native(uid->name,strlen(uid->name),0);
 
 	  for(;prefs->type;prefs++)
 	    {
 	      char num[10]; /* prefs->value is a byte, so we're over
 			       safe here */
 
 	      sprintf(num,"%u",prefs->value);
 
 	      if(prefs->type==PREFTYPE_SYM)
 		{
 		  if (openpgp_cipher_test_algo (prefs->value))
 		    {
 		      const char *algo =
                         (openpgp_cipher_test_algo (prefs->value)
                          ? num
                          : openpgp_cipher_algo_name (prefs->value));
 		      if(!problem)
 			check_prefs_warning(pk);
 		      log_info(_("         \"%s\": preference for cipher"
 				 " algorithm %s\n"), user, algo);
 		      problem=1;
 		    }
 		}
 	      else if(prefs->type==PREFTYPE_AEAD)
 		{
 		  if (openpgp_aead_test_algo (prefs->value))
 		    {
                       /* FIXME: The test below is wrong.  We should
                        * check if ...algo_name yields a "?" and
                        * only in that case use NUM.  */
 		      const char *algo =
                         (openpgp_aead_test_algo (prefs->value)
                          ? num
                          : openpgp_aead_algo_name (prefs->value));
 		      if(!problem)
 			check_prefs_warning(pk);
 		      log_info(_("         \"%s\": preference for AEAD"
 				 " algorithm %s\n"), user, algo);
 		      problem=1;
 		    }
 		}
 	      else if(prefs->type==PREFTYPE_HASH)
 		{
 		  if(openpgp_md_test_algo(prefs->value))
 		    {
 		      const char *algo =
                         (gcry_md_test_algo (prefs->value)
                          ? num
                          : gcry_md_algo_name (prefs->value));
 		      if(!problem)
 			check_prefs_warning(pk);
 		      log_info(_("         \"%s\": preference for digest"
 				 " algorithm %s\n"), user, algo);
 		      problem=1;
 		    }
 		}
 	      else if(prefs->type==PREFTYPE_ZIP)
 		{
 		  if(check_compress_algo (prefs->value))
 		    {
 		      const char *algo=compress_algo_to_string(prefs->value);
 		      if(!problem)
 			check_prefs_warning(pk);
 		      log_info(_("         \"%s\": preference for compression"
 				 " algorithm %s\n"),user,algo?algo:num);
 		      problem=1;
 		    }
 		}
 	    }
 
 	  xfree(user);
 	}
     }
 
   if(problem)
     {
       log_info(_("it is strongly suggested that you update"
 		 " your preferences and\n"));
       log_info(_("re-distribute this key to avoid potential algorithm"
 		 " mismatch problems\n"));
 
       if(!opt.batch)
 	{
 	  strlist_t sl = NULL;
           strlist_t locusr = NULL;
 	  size_t fprlen=0;
 	  byte fpr[MAX_FINGERPRINT_LEN], *p;
 	  char username[(MAX_FINGERPRINT_LEN*2)+1];
 	  unsigned int i;
 
 	  p = fingerprint_from_pk (pk,fpr,&fprlen);
 	  for(i=0;i<fprlen;i++,p++)
 	    sprintf(username+2*i,"%02X",*p);
 	  add_to_strlist(&locusr,username);
 
 	  append_to_strlist(&sl,"updpref");
 	  append_to_strlist(&sl,"save");
 
 	  keyedit_menu (ctrl, username, locusr, sl, 1, 1 );
 	  free_strlist(sl);
 	  free_strlist(locusr);
 	}
       else if(!opt.quiet)
 	log_info(_("you can update your preferences with:"
 		   " gpg --edit-key %s updpref save\n"),keystr_from_pk(pk));
     }
 }
 
 
 /* Helper for apply_*_filter in import.c and export.c.  */
 const char *
 impex_filter_getval (void *cookie, const char *propname)
 {
   /* FIXME: Malloc our static buffers and access them via PARM.  */
   struct impex_filter_parm_s *parm = cookie;
   ctrl_t ctrl = parm->ctrl;
   kbnode_t node = parm->node;
   static char numbuf[20];
   const char *result;
 
   log_assert (ctrl && ctrl->magic == SERVER_CONTROL_MAGIC);
 
   if (node->pkt->pkttype == PKT_USER_ID
       || node->pkt->pkttype == PKT_ATTRIBUTE)
     {
       PKT_user_id *uid = node->pkt->pkt.user_id;
 
       if (!strcmp (propname, "uid"))
         result = uid->name;
       else if (!strcmp (propname, "mbox"))
         {
           if (!uid->mbox)
             {
               uid->mbox = mailbox_from_userid (uid->name, 0);
             }
           result = uid->mbox;
         }
       else if (!strcmp (propname, "primary"))
         {
           result = uid->flags.primary? "1":"0";
         }
       else if (!strcmp (propname, "expired"))
         {
           result = uid->flags.expired? "1":"0";
         }
       else if (!strcmp (propname, "revoked"))
         {
           result = uid->flags.revoked? "1":"0";
         }
       else
         result = NULL;
     }
   else if (node->pkt->pkttype == PKT_SIGNATURE)
     {
       PKT_signature *sig = node->pkt->pkt.signature;
 
       if (!strcmp (propname, "sig_created"))
         {
           snprintf (numbuf, sizeof numbuf, "%lu", (ulong)sig->timestamp);
           result = numbuf;
         }
       else if (!strcmp (propname, "sig_created_d"))
         {
           result = dateonlystr_from_sig (sig);
         }
       else if (!strcmp (propname, "sig_algo"))
         {
           snprintf (numbuf, sizeof numbuf, "%d", sig->pubkey_algo);
           result = numbuf;
         }
       else if (!strcmp (propname, "sig_digest_algo"))
         {
           snprintf (numbuf, sizeof numbuf, "%d", sig->digest_algo);
           result = numbuf;
         }
       else if (!strcmp (propname, "expired"))
         {
           result = sig->flags.expired? "1":"0";
         }
       else
         result = NULL;
     }
   else if (node->pkt->pkttype == PKT_PUBLIC_KEY
            || node->pkt->pkttype == PKT_SECRET_KEY
            || node->pkt->pkttype == PKT_PUBLIC_SUBKEY
            || node->pkt->pkttype == PKT_SECRET_SUBKEY)
     {
       PKT_public_key *pk = node->pkt->pkt.public_key;
 
       if (!strcmp (propname, "secret"))
         {
           result = (node->pkt->pkttype == PKT_SECRET_KEY
                     || node->pkt->pkttype == PKT_SECRET_SUBKEY)? "1":"0";
         }
       else if (!strcmp (propname, "key_algo"))
         {
           snprintf (numbuf, sizeof numbuf, "%d", pk->pubkey_algo);
           result = numbuf;
         }
       else if (!strcmp (propname, "key_created"))
         {
           snprintf (numbuf, sizeof numbuf, "%lu", (ulong)pk->timestamp);
           result = numbuf;
         }
       else if (!strcmp (propname, "key_created_d"))
         {
           result = dateonlystr_from_pk (pk);
         }
       else if (!strcmp (propname, "expired"))
         {
           result = pk->has_expired? "1":"0";
         }
       else if (!strcmp (propname, "revoked"))
         {
           result = pk->flags.revoked? "1":"0";
         }
       else if (!strcmp (propname, "disabled"))
         {
           result = pk_is_disabled (pk)? "1":"0";
         }
       else if (!strcmp (propname, "usage"))
         {
           snprintf (numbuf, sizeof numbuf, "%s%s%s%s%s",
                     (pk->pubkey_usage & PUBKEY_USAGE_ENC)?"e":"",
                     (pk->pubkey_usage & PUBKEY_USAGE_SIG)?"s":"",
                     (pk->pubkey_usage & PUBKEY_USAGE_CERT)?"c":"",
                     (pk->pubkey_usage & PUBKEY_USAGE_AUTH)?"a":"",
                     (pk->pubkey_usage & PUBKEY_USAGE_UNKNOWN)?"?":"");
           result = numbuf;
         }
       else if (!strcmp (propname, "fpr"))
         {
           hexfingerprint (pk, parm->hexfpr, sizeof parm->hexfpr);
           result = parm->hexfpr;
         }
       else
         result = NULL;
     }
   else
     result = NULL;
 
   return result;
 }
 
 
 /*
  * Apply the keep-uid filter to the keyblock.  The deleted nodes are
  * marked and thus the caller should call commit_kbnode afterwards.
  * KEYBLOCK must not have any blocks marked as deleted.
  */
 static void
 apply_keep_uid_filter (ctrl_t ctrl, kbnode_t keyblock, recsel_expr_t selector)
 {
   kbnode_t node;
   struct impex_filter_parm_s parm;
 
   parm.ctrl = ctrl;
 
   for (node = keyblock->next; node; node = node->next )
     {
       if (node->pkt->pkttype == PKT_USER_ID)
         {
           parm.node = node;
           if (!recsel_select (selector, impex_filter_getval, &parm))
             {
 
               /* log_debug ("keep-uid: deleting '%s'\n", */
               /*            node->pkt->pkt.user_id->name); */
               /* The UID packet and all following packets up to the
                * next UID or a subkey.  */
               delete_kbnode (node);
               for (; node->next
                      && node->next->pkt->pkttype != PKT_USER_ID
                      && node->next->pkt->pkttype != PKT_PUBLIC_SUBKEY
                      && node->next->pkt->pkttype != PKT_SECRET_SUBKEY ;
                    node = node->next)
                 delete_kbnode (node->next);
 	    }
           /* else */
           /*   log_debug ("keep-uid: keeping '%s'\n", */
           /*              node->pkt->pkt.user_id->name); */
         }
     }
 }
 
 
 /*
  * Apply the drop-sig filter to the keyblock.  The deleted nodes are
  * marked and thus the caller should call commit_kbnode afterwards.
  * KEYBLOCK must not have any blocks marked as deleted.
  */
 static void
 apply_drop_sig_filter (ctrl_t ctrl, kbnode_t keyblock, recsel_expr_t selector)
 {
   kbnode_t node;
   int active = 0;
   u32 main_keyid[2];
   PKT_signature *sig;
   struct impex_filter_parm_s parm;
 
   parm.ctrl = ctrl;
 
   keyid_from_pk (keyblock->pkt->pkt.public_key, main_keyid);
 
   /* Loop over all signatures for user id and attribute packets which
    * are not self signatures.  */
   for (node = keyblock->next; node; node = node->next )
     {
       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
           || node->pkt->pkttype == PKT_SECRET_SUBKEY)
         break; /* ready.  */
       if (node->pkt->pkttype == PKT_USER_ID
           || node->pkt->pkttype == PKT_ATTRIBUTE)
         active = 1;
       if (!active)
         continue;
       if (node->pkt->pkttype != PKT_SIGNATURE)
         continue;
 
       sig = node->pkt->pkt.signature;
       if (main_keyid[0] == sig->keyid[0] || main_keyid[1] == sig->keyid[1])
         continue;  /* Skip self-signatures.  */
 
       if (IS_UID_SIG(sig) || IS_UID_REV(sig))
         {
           parm.node = node;
           if (recsel_select (selector, impex_filter_getval, &parm))
             delete_kbnode (node);
         }
     }
 }
 
 
 /* Insert a key origin into a public key packet.  */
 static gpg_error_t
 insert_key_origin_pk (PKT_public_key *pk, u32 curtime,
                       int origin, const char *url)
 {
   if (origin == KEYORG_WKD || origin == KEYORG_DANE)
     {
       /* For WKD and DANE we insert origin information also for the
        * key but we don't record the URL because we have have no use
        * for that: An update using a keyserver has higher precedence
        * and will thus update this origin info.  For refresh using WKD
        * or DANE we need to go via the User ID anyway.  Recall that we
        * are only inserting a new key. */
       pk->keyorg = origin;
       pk->keyupdate = curtime;
     }
   else if (origin == KEYORG_KS && url)
     {
       /* If the key was retrieved from a keyserver using a fingerprint
        * request we add the meta information.  Note that the use of a
        * fingerprint needs to be enforced by the caller of the import
        * function.  This is commonly triggered by verifying a modern
        * signature which has an Issuer Fingerprint signature
        * subpacket.  */
       pk->keyorg = origin;
       pk->keyupdate = curtime;
       xfree (pk->updateurl);
       pk->updateurl = xtrystrdup (url);
       if (!pk->updateurl)
         return gpg_error_from_syserror ();
     }
   else if (origin == KEYORG_FILE)
     {
       pk->keyorg = origin;
       pk->keyupdate = curtime;
     }
   else if (origin == KEYORG_URL)
     {
       pk->keyorg = origin;
       pk->keyupdate = curtime;
       if (url)
         {
           xfree (pk->updateurl);
           pk->updateurl = xtrystrdup (url);
           if (!pk->updateurl)
             return gpg_error_from_syserror ();
         }
     }
 
   return 0;
 }
 
 
 /* Insert a key origin into a user id packet.  */
 static gpg_error_t
 insert_key_origin_uid (PKT_user_id *uid, u32 curtime,
                        int origin, const char *url)
 
 {
   if (origin == KEYORG_WKD || origin == KEYORG_DANE)
     {
       /* We insert origin information on a UID only when we received
        * them via the Web Key Directory or a DANE record.  The key we
        * receive here from the WKD has been filtered to contain only
        * the user ID as looked up in the WKD.  For a DANE origin we
        * this should also be the case.  Thus we will see here only one
        * user id.  */
       uid->keyorg = origin;
       uid->keyupdate = curtime;
       if (url)
         {
           xfree (uid->updateurl);
           uid->updateurl = xtrystrdup (url);
           if (!uid->updateurl)
             return gpg_error_from_syserror ();
         }
     }
   else if (origin == KEYORG_KS && url)
     {
       /* If the key was retrieved from a keyserver using a fingerprint
        * request we mark that also in the user ID.  However we do not
        * store the keyserver URL in the UID.  A later update (merge)
        * from a more trusted source will replace this info.  */
       uid->keyorg = origin;
       uid->keyupdate = curtime;
     }
   else if (origin == KEYORG_FILE)
     {
       uid->keyorg = origin;
       uid->keyupdate = curtime;
     }
   else if (origin == KEYORG_URL)
     {
       uid->keyorg = origin;
       uid->keyupdate = curtime;
     }
 
   return 0;
 }
 
 
 /* Apply meta data to KEYBLOCK.  This sets the origin of the key to
  * ORIGIN and the updateurl to URL.  Note that this function is only
  * used for a new key, that is not when we are merging keys.  */
 static gpg_error_t
 insert_key_origin (kbnode_t keyblock, int origin, const char *url)
 {
   gpg_error_t err;
   kbnode_t node;
   u32 curtime = make_timestamp ();
 
   for (node = keyblock; node; node = node->next)
     {
       if (is_deleted_kbnode (node))
         ;
       else if (node->pkt->pkttype == PKT_PUBLIC_KEY)
         {
           err = insert_key_origin_pk (node->pkt->pkt.public_key, curtime,
                                       origin, url);
           if (err)
             return err;
         }
       else if (node->pkt->pkttype == PKT_USER_ID)
         {
           err = insert_key_origin_uid (node->pkt->pkt.user_id, curtime,
                                        origin, url);
           if (err)
             return err;
         }
     }
 
   return 0;
 }
 
 
 /* Update meta data on KEYBLOCK.  This updates the key origin on the
  * public key according to ORIGIN and URL.  The UIDs are already
  * updated when this function is called.  */
 static gpg_error_t
 update_key_origin (kbnode_t keyblock, u32 curtime, int origin, const char *url)
 {
   PKT_public_key *pk;
 
   log_assert (keyblock->pkt->pkttype == PKT_PUBLIC_KEY);
   pk = keyblock->pkt->pkt.public_key;
 
   if (pk->keyupdate > curtime)
     ; /* Don't do it for a time warp.  */
   else if (origin == KEYORG_WKD || origin == KEYORG_DANE)
     {
       /* We only update the origin info if they either have never been
        * set or are the origin was the same as the new one.  If this
        * is WKD we also update the UID to show from which user id this
        * was updated.  */
       if (!pk->keyorg || pk->keyorg == KEYORG_WKD || pk->keyorg == KEYORG_DANE)
         {
           pk->keyorg = origin;
           pk->keyupdate = curtime;
           xfree (pk->updateurl);
           pk->updateurl = NULL;
           if (origin == KEYORG_WKD && url)
             {
               pk->updateurl = xtrystrdup (url);
               if (!pk->updateurl)
                 return gpg_error_from_syserror ();
             }
         }
     }
   else if (origin == KEYORG_KS)
     {
       /* All updates from a keyserver are considered to have the
        * freshed key.  Thus we always set the new key origin.  */
       pk->keyorg = origin;
       pk->keyupdate = curtime;
       xfree (pk->updateurl);
       pk->updateurl = NULL;
       if (url)
         {
           pk->updateurl = xtrystrdup (url);
           if (!pk->updateurl)
             return gpg_error_from_syserror ();
         }
     }
   else if (origin == KEYORG_FILE)
     {
       /* Updates from a file are considered to be fresh.  */
       pk->keyorg = origin;
       pk->keyupdate = curtime;
       xfree (pk->updateurl);
       pk->updateurl = NULL;
     }
   else if (origin == KEYORG_URL)
     {
       /* Updates from a URL are considered to be fresh.  */
       pk->keyorg = origin;
       pk->keyupdate = curtime;
       xfree (pk->updateurl);
       pk->updateurl = NULL;
       if (url)
         {
           pk->updateurl = xtrystrdup (url);
           if (!pk->updateurl)
             return gpg_error_from_syserror ();
         }
     }
 
   return 0;
 }
 
 
 /*
  * Try to import one keyblock. Return an error only in serious cases,
  * but never for an invalid keyblock.  It uses log_error to increase
  * the internal errorcount, so that invalid input can be detected by
  * programs which called gpg.  If SILENT is no messages are printed -
  * even most error messages are suppressed.  ORIGIN is the origin of
  * the key (0 for unknown) and URL the corresponding URL.  FROM_SK
  * indicates that the key has been made from a secret key.  If R_SAVED
  * is not NULL a boolean will be stored indicating whether the keyblock
  * has valid parts.
  */
 static gpg_error_t
 import_one_real (ctrl_t ctrl,
                  kbnode_t keyblock, struct import_stats_s *stats,
                  unsigned char **fpr, size_t *fpr_len, unsigned int options,
                  int from_sk, int silent,
                  import_screener_t screener, void *screener_arg,
                  int origin, const char *url, int *r_valid)
 {
   gpg_error_t err = 0;
   PKT_public_key *pk;
   kbnode_t node, uidnode;
   kbnode_t keyblock_orig = NULL;
   byte fpr2[MAX_FINGERPRINT_LEN];
   size_t fpr2len;
   u32 keyid[2];
   int new_key = 0;
   int mod_key = 0;
   int same_key = 0;
   int non_self = 0;
   size_t an;
   char pkstrbuf[PUBKEY_STRING_SIZE];
   int merge_keys_done = 0;
   int any_filter = 0;
   KEYDB_HANDLE hd = NULL;
 
   if (r_valid)
     *r_valid = 0;
 
   /* If show-only is active we don't won't any extra output.  */
   if ((options & (IMPORT_SHOW | IMPORT_DRY_RUN)))
     silent = 1;
 
   /* Get the key and print some info about it. */
   node = find_kbnode( keyblock, PKT_PUBLIC_KEY );
   if (!node )
     BUG();
 
   pk = node->pkt->pkt.public_key;
 
   fingerprint_from_pk (pk, fpr2, &fpr2len);
   for (an = fpr2len; an < MAX_FINGERPRINT_LEN; an++)
     fpr2[an] = 0;
   keyid_from_pk( pk, keyid );
   uidnode = find_next_kbnode( keyblock, PKT_USER_ID );
 
   if (opt.verbose && !opt.interactive && !silent && !from_sk)
     {
       /* Note that we do not print this info in FROM_SK mode
        * because import_secret_one already printed that.  */
       log_info ("pub  %s/%s %s  ",
                 pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
                 keystr_from_pk(pk), datestr_from_pk(pk) );
       if (uidnode)
         print_utf8_buffer (log_get_stream (),
                            uidnode->pkt->pkt.user_id->name,
                            uidnode->pkt->pkt.user_id->len );
       log_printf ("\n");
     }
 
 
   if (!uidnode)
     {
       if (!silent)
         log_error( _("key %s: no user ID\n"), keystr_from_pk(pk));
       return 0;
     }
 
   if (screener && screener (keyblock, screener_arg))
     {
       log_error (_("key %s: %s\n"), keystr_from_pk (pk),
                  _("rejected by import screener"));
       return 0;
     }
 
   if (opt.interactive && !silent)
     {
       if (is_status_enabled())
         print_import_check (pk, uidnode->pkt->pkt.user_id);
       merge_keys_and_selfsig (ctrl, keyblock);
       tty_printf ("\n");
       show_basic_key_info (ctrl, keyblock, from_sk);
       tty_printf ("\n");
       if (!cpr_get_answer_is_yes ("import.okay",
                                   "Do you want to import this key? (y/N) "))
         return 0;
     }
 
   /* Remove all non-self-sigs if requested.  Note that this is a NOP if
    * that option has been globally set but we may also be called
    * latter with the already parsed keyblock and a locally changed
    * option.  This is why we need to remove them here as well.  */
   if ((options & IMPORT_SELF_SIGS_ONLY))
     remove_all_non_self_sigs (&keyblock, keyid);
 
   /* Remove or collapse the user ids.  */
   if ((options & IMPORT_COLLAPSE_UIDS))
     collapse_uids (&keyblock);
 
   if ((options & IMPORT_COLLAPSE_SUBKEYS))
     collapse_subkeys (&keyblock);
 
   /* Clean the key that we're about to import, to cut down on things
      that we have to clean later.  This has no practical impact on the
      end result, but does result in less logging which might confuse
      the user. */
   if ((options & IMPORT_CLEAN))
     {
       merge_keys_and_selfsig (ctrl, keyblock);
       clean_all_uids (ctrl, keyblock,
                       opt.verbose, (options&IMPORT_MINIMAL), NULL, NULL);
       clean_all_subkeys (ctrl, keyblock, opt.verbose, KEY_CLEAN_NONE,
                          NULL, NULL);
     }
 
   clear_kbnode_flags( keyblock );
 
   if ((options&IMPORT_REPAIR_PKS_SUBKEY_BUG)
       && fix_pks_corruption (ctrl, keyblock)
       && opt.verbose)
     log_info (_("key %s: PKS subkey corruption repaired\n"),
               keystr_from_pk(pk));
 
   if ((options & IMPORT_REPAIR_KEYS))
     key_check_all_keysigs (ctrl, 1, keyblock, 0, 0);
 
   if (chk_self_sigs (ctrl, keyblock, keyid, &non_self))
     return 0;  /* Invalid keyblock - error already printed.  */
 
   /* If we allow such a thing, mark unsigned uids as valid */
   if (opt.allow_non_selfsigned_uid)
     {
       for (node=keyblock; node; node = node->next )
         if (node->pkt->pkttype == PKT_USER_ID
             && !(node->flag & NODE_GOOD_SELFSIG)
             && !(node->flag & NODE_BAD_SELFSIG) )
           {
             char *user=utf8_to_native(node->pkt->pkt.user_id->name,
                                       node->pkt->pkt.user_id->len,0);
             /* Fake a good signature status for the user id.  */
             node->flag |= NODE_GOOD_SELFSIG;
             log_info( _("key %s: accepted non self-signed user ID \"%s\"\n"),
                       keystr_from_pk(pk),user);
             xfree(user);
 	  }
     }
 
   /* Delete invalid parts and bail out if there are no user ids left.  */
   if (!delete_inv_parts (ctrl, keyblock, keyid, options))
     {
       if (!silent)
         {
           log_error ( _("key %s: no valid user IDs\n"), keystr_from_pk(pk));
           if (!opt.quiet)
             log_info(_("this may be caused by a missing self-signature\n"));
         }
       stats->no_user_id++;
       return 0;
     }
 
   /* Get rid of deleted nodes.  */
   commit_kbnode (&keyblock);
 
   /* Apply import filter.  */
   if (import_filter.keep_uid)
     {
       apply_keep_uid_filter (ctrl, keyblock, import_filter.keep_uid);
       commit_kbnode (&keyblock);
       any_filter = 1;
     }
   if (import_filter.drop_sig)
     {
       apply_drop_sig_filter (ctrl, keyblock, import_filter.drop_sig);
       commit_kbnode (&keyblock);
       any_filter = 1;
     }
 
   /* If we ran any filter we need to check that at least one user id
    * is left in the keyring.  Note that we do not use log_error in
    * this case. */
   if (any_filter && !any_uid_left (keyblock))
     {
       if (!opt.quiet )
         log_info ( _("key %s: no valid user IDs\n"), keystr_from_pk (pk));
       stats->no_user_id++;
       return 0;
     }
 
   /* The keyblock is valid and ready for real import.  */
   if (r_valid)
     *r_valid = 1;
 
   /* Show the key in the form it is merged or inserted.  We skip this
    * if "import-export" is also active without --armor or the output
    * file has explicily been given. */
   if ((options & IMPORT_SHOW)
       && !((options & IMPORT_EXPORT) && !opt.armor && !opt.outfile))
     {
       merge_keys_and_selfsig (ctrl, keyblock);
       merge_keys_done = 1;
       /* Note that we do not want to show the validity because the key
        * has not yet imported.  */
       list_keyblock_direct (ctrl, keyblock, from_sk, 0,
                             opt.fingerprint || opt.with_fingerprint, 1);
       es_fflush (es_stdout);
     }
 
   /* Write the keyblock to the output and do not actually import.  */
   if ((options & IMPORT_EXPORT))
     {
       if (!merge_keys_done)
         {
           merge_keys_and_selfsig (ctrl, keyblock);
           merge_keys_done = 1;
         }
       err = write_keyblock_to_output (keyblock, opt.armor, opt.export_options);
       goto leave;
     }
 
   if (opt.dry_run || (options & IMPORT_DRY_RUN))
     goto leave;
 
   /* Do we have this key already in one of our pubrings ? */
   err = get_keyblock_byfprint_fast (ctrl, &keyblock_orig, &hd,
                                     fpr2, fpr2len, 1/*locked*/);
   if ((err
        && gpg_err_code (err) != GPG_ERR_NO_PUBKEY
        && gpg_err_code (err) != GPG_ERR_UNUSABLE_PUBKEY)
       || !hd)
     {
       /* The !hd above is to catch a misbehaving function which
        * returns NO_PUBKEY for failing to allocate a handle.  */
       if (!silent)
         log_error (_("key %s: public key not found: %s\n"),
                    keystr(keyid), gpg_strerror (err));
     }
   else if (err && (opt.import_options&IMPORT_MERGE_ONLY) )
     {
       if (opt.verbose && !silent )
         log_info( _("key %s: new key - skipped\n"), keystr(keyid));
       err = 0;
       stats->skipped_new_keys++;
     }
   else if (err)  /* Insert this key. */
     {
       /* Note: ERR can only be NO_PUBKEY or UNUSABLE_PUBKEY.  */
       int n_sigs_cleaned, n_uids_cleaned;
 
       err = keydb_locate_writable (hd);
       if (err)
         {
           log_error (_("no writable keyring found: %s\n"), gpg_strerror (err));
           err = gpg_error (GPG_ERR_GENERAL);
           goto leave;
 	}
       if (opt.verbose > 1 )
         log_info (_("writing to '%s'\n"), keydb_get_resource_name (hd) );
 
       if ((options & IMPORT_CLEAN))
         {
           merge_keys_and_selfsig (ctrl, keyblock);
           clean_all_uids (ctrl, keyblock, opt.verbose, (options&IMPORT_MINIMAL),
                           &n_uids_cleaned,&n_sigs_cleaned);
           clean_all_subkeys (ctrl, keyblock, opt.verbose, KEY_CLEAN_NONE,
                              NULL, NULL);
         }
 
       /* Unless we are in restore mode apply meta data to the
        * keyblock.  Note that this will never change the first packet
        * and thus the address of KEYBLOCK won't change.  */
       if ( !(options & IMPORT_RESTORE) )
         {
           err = insert_key_origin (keyblock, origin, url);
           if (err)
             {
               log_error ("insert_key_origin failed: %s\n", gpg_strerror (err));
               err = gpg_error (GPG_ERR_GENERAL);
               goto leave;
             }
         }
 
       err = keydb_insert_keyblock (hd, keyblock );
       if (err)
         log_error (_("error writing keyring '%s': %s\n"),
                    keydb_get_resource_name (hd), gpg_strerror (err));
       else if (!(opt.import_options & IMPORT_KEEP_OWNERTTRUST))
         {
           /* This should not be possible since we delete the
              ownertrust when a key is deleted, but it can happen if
              the keyring and trustdb are out of sync.  It can also
              be made to happen with the trusted-key command and by
              importing and locally exported key. */
 
           clear_ownertrusts (ctrl, pk);
           if (non_self)
             revalidation_mark (ctrl);
         }
 
       /* Release the handle and thus unlock the keyring asap.  */
       keydb_release (hd);
       hd = NULL;
 
       /* We are ready.  */
       if (!err && !opt.quiet && !silent)
         {
           char *p = get_user_id_byfpr_native (ctrl, fpr2, fpr2len);
           log_info (_("key %s: public key \"%s\" imported\n"),
                     keystr(keyid), p);
           xfree(p);
         }
       if (!err && is_status_enabled())
         {
           char *us = get_long_user_id_string (ctrl, keyid);
           write_status_text( STATUS_IMPORTED, us );
           xfree(us);
           print_import_ok (pk, 1);
         }
       if (!err)
         {
           stats->imported++;
           new_key = 1;
         }
     }
   else /* Key already exists - merge.  */
     {
       int n_uids, n_sigs, n_subk, n_sigs_cleaned, n_uids_cleaned;
       u32 curtime = make_timestamp ();
 
       /* Compare the original against the new key; just to be sure nothing
        * weird is going on */
       if (cmp_public_keys (keyblock_orig->pkt->pkt.public_key, pk))
         {
           if (!silent)
             log_error( _("key %s: doesn't match our copy\n"),keystr(keyid));
           goto leave;
         }
 
       /* Make sure the original direct key sigs are all sane.  */
       n_sigs_cleaned = fix_bad_direct_key_sigs (ctrl, keyblock_orig, keyid);
       if (n_sigs_cleaned)
         commit_kbnode (&keyblock_orig);
 
       /* Try to merge KEYBLOCK into KEYBLOCK_ORIG.  */
       clear_kbnode_flags( keyblock_orig );
       clear_kbnode_flags( keyblock );
       n_uids = n_sigs = n_subk = n_uids_cleaned = 0;
       err = merge_blocks (ctrl, options, keyblock_orig, keyblock, keyid,
                           curtime, origin, url,
                           &n_uids, &n_sigs, &n_subk );
       if (err)
         goto leave;
 
       /* Clean the final keyblock again if requested.  we can't do
        * this if only self-signatures are imported; see bug #4628.  */
       if ((options & IMPORT_CLEAN)
           && !(options & IMPORT_SELF_SIGS_ONLY))
         {
           merge_keys_and_selfsig (ctrl, keyblock_orig);
           clean_all_uids (ctrl, keyblock_orig, opt.verbose,
                           (options&IMPORT_MINIMAL),
                           &n_uids_cleaned,&n_sigs_cleaned);
           clean_all_subkeys (ctrl, keyblock_orig, opt.verbose, KEY_CLEAN_NONE,
                              NULL, NULL);
         }
 
       if (n_uids || n_sigs || n_subk || n_sigs_cleaned || n_uids_cleaned)
         {
           /* Unless we are in restore mode apply meta data to the
            * keyblock.  Note that this will never change the first packet
            * and thus the address of KEYBLOCK won't change.  */
           if ( !(options & IMPORT_RESTORE) )
             {
               err = update_key_origin (keyblock_orig, curtime, origin, url);
               if (err)
                 {
                   log_error ("update_key_origin failed: %s\n",
                              gpg_strerror (err));
                   goto leave;
                 }
             }
 
           mod_key = 1;
           /* KEYBLOCK_ORIG has been updated; write */
           err = keydb_update_keyblock (ctrl, hd, keyblock_orig);
           if (err)
             log_error (_("error writing keyring '%s': %s\n"),
                        keydb_get_resource_name (hd), gpg_strerror (err));
           else if (non_self)
             revalidation_mark (ctrl);
 
           /* Release the handle and thus unlock the keyring asap.  */
           keydb_release (hd);
           hd = NULL;
 
           /* We are ready.  Print and update stats if we got no error.
            * An error here comes from writing the keyblock and thus
            * very likely means that no update happened.  */
           if (!err && !opt.quiet && !silent)
             {
               char *p = get_user_id_byfpr_native (ctrl, fpr2, fpr2len);
               if (n_uids == 1 )
                 log_info( _("key %s: \"%s\" 1 new user ID\n"),
                           keystr(keyid),p);
               else if (n_uids )
                 log_info( _("key %s: \"%s\" %d new user IDs\n"),
                           keystr(keyid),p,n_uids);
               if (n_sigs == 1 )
                 log_info( _("key %s: \"%s\" 1 new signature\n"),
                           keystr(keyid), p);
               else if (n_sigs )
                 log_info( _("key %s: \"%s\" %d new signatures\n"),
                           keystr(keyid), p, n_sigs );
               if (n_subk == 1 )
                 log_info( _("key %s: \"%s\" 1 new subkey\n"),
                           keystr(keyid), p);
               else if (n_subk )
                 log_info( _("key %s: \"%s\" %d new subkeys\n"),
                           keystr(keyid), p, n_subk );
               if (n_sigs_cleaned==1)
                 log_info(_("key %s: \"%s\" %d signature cleaned\n"),
                          keystr(keyid),p,n_sigs_cleaned);
               else if (n_sigs_cleaned)
                 log_info(_("key %s: \"%s\" %d signatures cleaned\n"),
                          keystr(keyid),p,n_sigs_cleaned);
               if (n_uids_cleaned==1)
                 log_info(_("key %s: \"%s\" %d user ID cleaned\n"),
                          keystr(keyid),p,n_uids_cleaned);
               else if (n_uids_cleaned)
                 log_info(_("key %s: \"%s\" %d user IDs cleaned\n"),
                          keystr(keyid),p,n_uids_cleaned);
               xfree(p);
             }
 
           if (!err)
             {
               stats->n_uids +=n_uids;
               stats->n_sigs +=n_sigs;
               stats->n_subk +=n_subk;
               stats->n_sigs_cleaned +=n_sigs_cleaned;
               stats->n_uids_cleaned +=n_uids_cleaned;
 
               if (is_status_enabled () && !silent)
                 print_import_ok (pk, ((n_uids?2:0)|(n_sigs?4:0)|(n_subk?8:0)));
             }
 	}
       else
         {
           /* Release the handle and thus unlock the keyring asap.  */
           keydb_release (hd);
           hd = NULL;
 
           /* FIXME: We do not track the time we last checked a key for
            * updates.  To do this we would need to rewrite even the
            * keys which have no changes.  Adding this would be useful
            * for the automatic update of expired keys via the WKD in
            * case the WKD still carries the expired key.  See
            * get_best_pubkey_byname.  */
           same_key = 1;
           if (is_status_enabled ())
             print_import_ok (pk, 0);
 
           if (!opt.quiet && !silent)
             {
               char *p = get_user_id_byfpr_native (ctrl, fpr2, fpr2len);
               log_info( _("key %s: \"%s\" not changed\n"),keystr(keyid),p);
               xfree(p);
             }
 
           stats->unchanged++;
         }
     }
 
  leave:
   keydb_release (hd);
   if (mod_key || new_key || same_key)
     {
       /* A little explanation for this: we fill in the fingerprint
          when importing keys as it can be useful to know the
          fingerprint in certain keyserver-related cases (a keyserver
          asked for a particular name, but the key doesn't have that
          name).  However, in cases where we're importing more than
          one key at a time, we cannot know which key to fingerprint.
          In these cases, rather than guessing, we do not
          fingerprinting at all, and we must hope the user ID on the
          keys are useful.  Note that we need to do this for new
          keys, merged keys and even for unchanged keys.  This is
          required because for example the --auto-key-locate feature
          may import an already imported key and needs to know the
          fingerprint of the key in all cases.  */
       if (fpr)
         {
           /* Note that we need to compare against 0 here because
              COUNT gets only incremented after returning from this
              function.  */
           if (!stats->count)
             {
               xfree (*fpr);
               *fpr = fingerprint_from_pk (pk, NULL, fpr_len);
             }
           else if (origin != KEYORG_WKD)
             {
               xfree (*fpr);
               *fpr = NULL;
             }
         }
     }
 
   /* Now that the key is definitely incorporated into the keydb, we
      need to check if a designated revocation is present or if the
      prefs are not rational so we can warn the user. */
 
   if (mod_key)
     {
       revocation_present (ctrl, keyblock_orig);
       if (!from_sk && have_secret_key_with_kid (ctrl, keyid))
         check_prefs (ctrl, keyblock_orig);
     }
   else if (new_key)
     {
       revocation_present (ctrl, keyblock);
       if (!from_sk && have_secret_key_with_kid (ctrl, keyid))
         check_prefs (ctrl, keyblock);
     }
 
   release_kbnode( keyblock_orig );
 
   return err;
 }
 
 
 /* Wrapper around import_one_real to retry the import in some cases.  */
 static gpg_error_t
 import_one (ctrl_t ctrl,
             kbnode_t keyblock, struct import_stats_s *stats,
 	    unsigned char **fpr, size_t *fpr_len, unsigned int options,
 	    int from_sk, int silent,
             import_screener_t screener, void *screener_arg,
             int origin, const char *url, int *r_valid)
 {
   gpg_error_t err;
 
   err = import_one_real (ctrl, keyblock, stats, fpr, fpr_len, options,
                          from_sk, silent, screener, screener_arg,
                          origin, url, r_valid);
   if (gpg_err_code (err) == GPG_ERR_TOO_LARGE
       && gpg_err_source (err) == GPG_ERR_SOURCE_KEYBOX
       && ((options & (IMPORT_SELF_SIGS_ONLY | IMPORT_CLEAN))
           != (IMPORT_SELF_SIGS_ONLY | IMPORT_CLEAN)))
     {
       /* We hit the maximum image length.  Ask the wrapper to do
        * everything again but this time with some extra options.  */
       u32 keyid[2];
 
       keyid_from_pk (keyblock->pkt->pkt.public_key, keyid);
       log_info ("key %s: keyblock too large, retrying with self-sigs-only\n",
                 keystr (keyid));
       options |= IMPORT_SELF_SIGS_ONLY | IMPORT_CLEAN;
       err = import_one_real (ctrl, keyblock, stats, fpr, fpr_len, options,
                              from_sk, silent, screener, screener_arg,
                              origin, url, r_valid);
     }
   return err;
 }
 
 
 /* Transfer all the secret keys in SEC_KEYBLOCK to the gpg-agent.  The
  * function prints diagnostics and returns an error code.  If BATCH is
  * true the secret keys are stored by gpg-agent in the transfer format
  * (i.e. no re-protection and aksing for passphrases). If ONLY_MARKED
  * is set, only those nodes with flag NODE_TRANSFER_SECKEY are
  * processed.  */
 gpg_error_t
 transfer_secret_keys (ctrl_t ctrl, struct import_stats_s *stats,
                       kbnode_t sec_keyblock, int batch, int force,
                       int only_marked)
 {
   gpg_error_t err = 0;
   void *kek = NULL;
   size_t keklen;
   kbnode_t ctx = NULL;
   kbnode_t node;
   PKT_public_key *main_pk, *pk;
   struct seckey_info *ski;
   int nskey;
   membuf_t mbuf;
   int i, j;
   void *format_args[2*PUBKEY_MAX_NSKEY];
   gcry_sexp_t skey, prot, tmpsexp;
   gcry_sexp_t curve = NULL;
   unsigned char *transferkey = NULL;
   size_t transferkeylen;
   gcry_cipher_hd_t cipherhd = NULL;
   unsigned char *wrappedkey = NULL;
   size_t wrappedkeylen;
   char *cache_nonce = NULL;
   int stub_key_skipped = 0;
 
   /* Get the current KEK.  */
   err = agent_keywrap_key (ctrl, 0, &kek, &keklen);
   if (err)
     {
       log_error ("error getting the KEK: %s\n", gpg_strerror (err));
       goto leave;
     }
 
   /* Prepare a cipher context.  */
   err = gcry_cipher_open (&cipherhd, GCRY_CIPHER_AES128,
                           GCRY_CIPHER_MODE_AESWRAP, 0);
   if (!err)
     err = gcry_cipher_setkey (cipherhd, kek, keklen);
   if (err)
     goto leave;
   xfree (kek);
   kek = NULL;
 
   /* Note: We need to use walk_kbnode so that we skip nodes which are
    * marked as deleted.  */
   main_pk = NULL;
   while ((node = walk_kbnode (sec_keyblock, &ctx, 0)))
     {
       if (node->pkt->pkttype != PKT_SECRET_KEY
           && node->pkt->pkttype != PKT_SECRET_SUBKEY)
         continue;
       if (only_marked && !(node->flag & NODE_TRANSFER_SECKEY))
         continue;
       pk = node->pkt->pkt.public_key;
       if (!main_pk)
         main_pk = pk;
 
       /* Make sure the keyids are available.  */
       keyid_from_pk (pk, NULL);
       if (node->pkt->pkttype == PKT_SECRET_KEY)
         {
           pk->main_keyid[0] = pk->keyid[0];
           pk->main_keyid[1] = pk->keyid[1];
         }
       else
         {
           pk->main_keyid[0] = main_pk->keyid[0];
           pk->main_keyid[1] = main_pk->keyid[1];
         }
 
 
       ski = pk->seckey_info;
       if (!ski)
         BUG ();
 
       if (stats)
         {
           stats->count++;
           stats->secret_read++;
         }
 
       /* We ignore stub keys.  The way we handle them in other parts
          of the code is by asking the agent whether any secret key is
          available for a given keyblock and then concluding that we
          have a secret key; all secret (sub)keys of the keyblock the
          agent does not know of are then stub keys.  This works also
          for card stub keys.  The learn command or the card-status
          command may be used to check with the agent whether a card
          has been inserted and a stub key is in turn generated by the
          agent.  */
       if (ski->s2k.mode == 1001 || ski->s2k.mode == 1002)
         {
           stub_key_skipped = 1;
           continue;
         }
 
       /* Convert our internal secret key object into an S-expression.  */
       nskey = pubkey_get_nskey (pk->pubkey_algo);
       if (!nskey || nskey > PUBKEY_MAX_NSKEY)
         {
           err = gpg_error (GPG_ERR_BAD_SECKEY);
           log_error ("internal error: %s\n", gpg_strerror (err));
           goto leave;
         }
 
       init_membuf (&mbuf, 50);
       put_membuf_str (&mbuf, "(skey");
       if (pk->pubkey_algo == PUBKEY_ALGO_ECDSA
           || pk->pubkey_algo == PUBKEY_ALGO_EDDSA
           || pk->pubkey_algo == PUBKEY_ALGO_ECDH)
         {
           /* The ECC case.  */
           char *curvestr = openpgp_oid_to_str (pk->pkey[0]);
           if (!curvestr)
             err = gpg_error_from_syserror ();
           else
             {
               const char *curvename = openpgp_oid_to_curve (curvestr, 1);
               gcry_sexp_release (curve);
               err = gcry_sexp_build (&curve, NULL, "(curve %s)",
                                      curvename?curvename:curvestr);
               xfree (curvestr);
               if (!err)
                 {
                   j = 0;
                   /* Append the public key element Q.  */
                   put_membuf_str (&mbuf, " _ %m");
                   format_args[j++] = pk->pkey + 1;
 
                   /* Append the secret key element D.  For ECDH we
                      skip PKEY[2] because this holds the KEK which is
                      not needed by gpg-agent.  */
                   i = pk->pubkey_algo == PUBKEY_ALGO_ECDH? 3 : 2;
                   if (gcry_mpi_get_flag (pk->pkey[i], GCRYMPI_FLAG_USER1))
                     put_membuf_str (&mbuf, " e %m");
                   else
                     put_membuf_str (&mbuf, " _ %m");
                   format_args[j++] = pk->pkey + i;
                 }
             }
         }
       else
         {
           /* Standard case for the old (non-ECC) algorithms.  */
           for (i=j=0; i < nskey; i++)
             {
               if (!pk->pkey[i])
                 continue; /* Protected keys only have NPKEY+1 elements.  */
 
               if (gcry_mpi_get_flag (pk->pkey[i], GCRYMPI_FLAG_USER1))
                 put_membuf_str (&mbuf, " e %m");
               else
                 put_membuf_str (&mbuf, " _ %m");
               format_args[j++] = pk->pkey + i;
             }
         }
       put_membuf_str (&mbuf, ")");
       put_membuf (&mbuf, "", 1);
       if (err)
         xfree (get_membuf (&mbuf, NULL));
       else
         {
           char *format = get_membuf (&mbuf, NULL);
           if (!format)
             err = gpg_error_from_syserror ();
           else
             err = gcry_sexp_build_array (&skey, NULL, format, format_args);
           xfree (format);
         }
       if (err)
         {
           log_error ("error building skey array: %s\n", gpg_strerror (err));
           goto leave;
         }
 
       if (ski->is_protected)
         {
           char countbuf[35];
 
           /* FIXME: Support AEAD */
           /* Note that the IVLEN may be zero if we are working on a
              dummy key.  We can't express that in an S-expression and
              thus we send dummy data for the IV.  */
           snprintf (countbuf, sizeof countbuf, "%lu",
                     (unsigned long)ski->s2k.count);
           err = gcry_sexp_build
             (&prot, NULL,
              " (protection %s %s %b %d %s %b %s)\n",
              ski->sha1chk? "sha1":"sum",
              openpgp_cipher_algo_name (ski->algo),
              ski->ivlen? (int)ski->ivlen:1,
              ski->ivlen? ski->iv: (const unsigned char*)"X",
              ski->s2k.mode,
              openpgp_md_algo_name (ski->s2k.hash_algo),
              (int)sizeof (ski->s2k.salt), ski->s2k.salt,
              countbuf);
         }
       else
         err = gcry_sexp_build (&prot, NULL, " (protection none)\n");
 
       tmpsexp = NULL;
       xfree (transferkey);
       transferkey = NULL;
       if (!err)
         err = gcry_sexp_build (&tmpsexp, NULL,
                                "(openpgp-private-key\n"
                                " (version %d)\n"
                                " (algo %s)\n"
                                " %S%S\n"
                                " (csum %d)\n"
                                " %S)\n",
                                pk->version,
                                openpgp_pk_algo_name (pk->pubkey_algo),
                                curve, skey,
                                (int)(unsigned long)ski->csum, prot);
       gcry_sexp_release (skey);
       gcry_sexp_release (prot);
       if (!err)
         err = make_canon_sexp_pad (tmpsexp, 1, &transferkey, &transferkeylen);
       gcry_sexp_release (tmpsexp);
       if (err)
         {
           log_error ("error building transfer key: %s\n", gpg_strerror (err));
           goto leave;
         }
 
       /* Wrap the key.  */
       wrappedkeylen = transferkeylen + 8;
       xfree (wrappedkey);
       wrappedkey = xtrymalloc (wrappedkeylen);
       if (!wrappedkey)
         err = gpg_error_from_syserror ();
       else
         err = gcry_cipher_encrypt (cipherhd, wrappedkey, wrappedkeylen,
                                    transferkey, transferkeylen);
       if (err)
         goto leave;
       xfree (transferkey);
       transferkey = NULL;
 
       /* Send the wrapped key to the agent.  */
       {
         char *desc = gpg_format_keydesc (ctrl, pk, FORMAT_KEYDESC_IMPORT, 1);
         err = agent_import_key (ctrl, desc, &cache_nonce,
                                 wrappedkey, wrappedkeylen, batch, force,
 				pk->keyid, pk->main_keyid, pk->pubkey_algo,
                                 pk->timestamp);
         xfree (desc);
       }
       if (!err)
         {
           if (opt.verbose)
             log_info (_("key %s: secret key imported\n"),
                       keystr_from_pk_with_sub (main_pk, pk));
           if (stats)
             stats->secret_imported++;
         }
       else if ( gpg_err_code (err) == GPG_ERR_EEXIST )
         {
           if (opt.verbose)
             log_info (_("key %s: secret key already exists\n"),
                       keystr_from_pk_with_sub (main_pk, pk));
           err = 0;
           if (stats)
             stats->secret_dups++;
         }
       else
         {
           log_error (_("key %s: error sending to agent: %s\n"),
                      keystr_from_pk_with_sub (main_pk, pk),
                      gpg_strerror (err));
           if (gpg_err_code (err) == GPG_ERR_CANCELED
               || gpg_err_code (err) == GPG_ERR_FULLY_CANCELED)
             break; /* Don't try the other subkeys.  */
         }
     }
 
   if (!err && stub_key_skipped)
     /* We need to notify user how to migrate stub keys.  */
     err = gpg_error (GPG_ERR_NOT_PROCESSED);
 
  leave:
   gcry_sexp_release (curve);
   xfree (cache_nonce);
   xfree (wrappedkey);
   xfree (transferkey);
   gcry_cipher_close (cipherhd);
   xfree (kek);
   return err;
 }
 
 
 /* Walk a secret keyblock and produce a public keyblock out of it.
  * Returns a new node or NULL on error.  Modifies the tag field of the
  * nodes.  */
 static kbnode_t
 sec_to_pub_keyblock (kbnode_t sec_keyblock)
 {
   kbnode_t pub_keyblock = NULL;
   kbnode_t ctx = NULL;
   kbnode_t secnode, pubnode;
   kbnode_t lastnode = NULL;
   unsigned int tag = 0;
 
   /* Set a tag to all nodes.  */
   for (secnode = sec_keyblock; secnode; secnode = secnode->next)
     secnode->tag = ++tag;
 
   /* Copy.  */
   while ((secnode = walk_kbnode (sec_keyblock, &ctx, 0)))
     {
       if (secnode->pkt->pkttype == PKT_SECRET_KEY
           || secnode->pkt->pkttype == PKT_SECRET_SUBKEY)
 	{
 	  /* Make a public key.  */
 	  PACKET *pkt;
           PKT_public_key *pk;
 
 	  pkt = xtrycalloc (1, sizeof *pkt);
           pk = pkt? copy_public_key (NULL, secnode->pkt->pkt.public_key): NULL;
           if (!pk)
             {
               xfree (pkt);
 	      release_kbnode (pub_keyblock);
               return NULL;
             }
 	  if (secnode->pkt->pkttype == PKT_SECRET_KEY)
 	    pkt->pkttype = PKT_PUBLIC_KEY;
 	  else
 	    pkt->pkttype = PKT_PUBLIC_SUBKEY;
 	  pkt->pkt.public_key = pk;
 
 	  pubnode = new_kbnode (pkt);
 	}
       else
 	{
 	  pubnode = clone_kbnode (secnode);
 	}
       pubnode->tag = secnode->tag;
 
       if (!pub_keyblock)
         pub_keyblock = lastnode = pubnode;
       else
         {
           lastnode->next = pubnode;
           lastnode = pubnode;
         }
     }
 
   return pub_keyblock;
 }
 
 
 /* Delete all notes in the keyblock at R_KEYBLOCK which are not in
  * PUB_KEYBLOCK.  Modifies the tags of both keyblock's nodes.  */
 static gpg_error_t
 resync_sec_with_pub_keyblock (kbnode_t *r_keyblock, kbnode_t pub_keyblock,
                               kbnode_t *r_removedsecs)
 {
   kbnode_t sec_keyblock = *r_keyblock;
   kbnode_t node, prevnode;
   unsigned int *taglist;
   unsigned int ntaglist, n;
   kbnode_t attic = NULL;
   kbnode_t *attic_head = &attic;
 
   /* Collect all tags in an array for faster searching.  */
   for (ntaglist = 0, node = pub_keyblock; node; node = node->next)
     ntaglist++;
   taglist = xtrycalloc (ntaglist, sizeof *taglist);
   if (!taglist)
     return gpg_error_from_syserror ();
   for (ntaglist = 0, node = pub_keyblock; node; node = node->next)
     taglist[ntaglist++] = node->tag;
 
   /* Walks over the secret keyblock and delete all nodes which are not
    * in the tag list.  Those nodes have been deleted in the
    * pub_keyblock.  Sequential search is a bit lazy and could be
    * optimized by sorting and bsearch; however secret keyrings are
    * short and there are easier ways to DoS the import.  */
  again:
   for (prevnode=NULL, node=sec_keyblock; node; prevnode=node, node=node->next)
     {
       for (n=0; n < ntaglist; n++)
         if (taglist[n] == node->tag)
           break;
       if (n == ntaglist)  /* Not in public keyblock.  */
         {
           if (node->pkt->pkttype == PKT_SECRET_KEY
               || node->pkt->pkttype == PKT_SECRET_SUBKEY)
             {
               if (!prevnode)
                 sec_keyblock = node->next;
               else
                 prevnode->next = node->next;
               node->next = NULL;
               *attic_head = node;
               attic_head = &node->next;
               goto again;  /* That's lame; I know.  */
             }
           else
             delete_kbnode (node);
         }
     }
 
   xfree (taglist);
 
   /* Commit the as deleted marked nodes and return the possibly
    * modified keyblock and a list of removed secret key nodes.  */
   commit_kbnode (&sec_keyblock);
   *r_keyblock = sec_keyblock;
   *r_removedsecs = attic;
   return 0;
 }
 
 
 /* Helper for import_secret_one.  */
 static gpg_error_t
 do_transfer (ctrl_t ctrl, kbnode_t keyblock, PKT_public_key *pk,
              struct import_stats_s *stats, int batch, int only_marked)
 
 {
   gpg_error_t err;
   struct import_stats_s subkey_stats = {0};
 
   err = transfer_secret_keys (ctrl, &subkey_stats, keyblock,
                               batch, 0, only_marked);
   if (gpg_err_code (err) == GPG_ERR_NOT_PROCESSED)
     {
       /* TRANSLATORS: For a smartcard, each private key on host has a
        * reference (stub) to a smartcard and actual private key data
        * is stored on the card.  A single smartcard can have up to
        * three private key data.  Importing private key stub is always
        * skipped in 2.1, and it returns GPG_ERR_NOT_PROCESSED.
        * Instead, user should be suggested to run 'gpg --card-status',
        * then, references to a card will be automatically created
        * again.  */
       log_info (_("To migrate '%s', with each smartcard, "
                   "run: %s\n"), "secring.gpg", "gpg --card-status");
       err = 0;
     }
 
   if (!err)
     {
       int status = 16;
 
       if (!opt.quiet)
         log_info (_("key %s: secret key imported\n"), keystr_from_pk (pk));
       if (subkey_stats.secret_imported)
         {
           status |= 1;
           stats->secret_imported += 1;
         }
       if (subkey_stats.secret_dups)
         stats->secret_dups += 1;
 
       if (is_status_enabled ())
         print_import_ok (pk, status);
     }
 
   return err;
 }
 
 
 /* If the secret keys (main or subkey) in SECKEYS have a corresponding
  * public key in the public key described by (FPR,FPRLEN) import these
  * parts.
  */
 static gpg_error_t
 import_matching_seckeys (ctrl_t ctrl, kbnode_t seckeys,
                          const byte *mainfpr, size_t mainfprlen,
                          struct import_stats_s *stats, int batch)
 {
   gpg_error_t err;
   kbnode_t pub_keyblock = NULL;
   kbnode_t node;
   struct { byte fpr[MAX_FINGERPRINT_LEN]; size_t fprlen; } *fprlist = NULL;
   size_t n, nfprlist;
   byte fpr[MAX_FINGERPRINT_LEN];
   size_t fprlen;
   PKT_public_key *pk;
 
   /* Get the entire public key block from our keystore and put all its
    * fingerprints into an array.  */
   err = get_pubkey_byfprint (ctrl, NULL, &pub_keyblock, mainfpr, mainfprlen);
   if (err)
     goto leave;
   log_assert (pub_keyblock && pub_keyblock->pkt->pkttype == PKT_PUBLIC_KEY);
   pk = pub_keyblock->pkt->pkt.public_key;
 
   for (nfprlist = 0, node = pub_keyblock; node; node = node->next)
     if (node->pkt->pkttype == PKT_PUBLIC_KEY
         || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
       nfprlist++;
   log_assert (nfprlist);
   fprlist = xtrycalloc (nfprlist, sizeof *fprlist);
   if (!fprlist)
     {
       err = gpg_error_from_syserror ();
       goto leave;
     }
   for (n = 0, node = pub_keyblock; node; node = node->next)
     if (node->pkt->pkttype == PKT_PUBLIC_KEY
         || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
       {
         fingerprint_from_pk (node->pkt->pkt.public_key,
                              fprlist[n].fpr, &fprlist[n].fprlen);
         n++;
       }
   log_assert (n == nfprlist);
 
   /* for (n=0; n < nfprlist; n++) */
   /*   log_printhex (fprlist[n].fpr, fprlist[n].fprlen, "pubkey %zu:", n); */
 
   /* Mark all secret keys which have a matching public key part in
    * PUB_KEYBLOCK.  */
   for (node = seckeys; node; node = node->next)
     {
       if (node->pkt->pkttype != PKT_SECRET_KEY
           && node->pkt->pkttype != PKT_SECRET_SUBKEY)
         continue; /* Should not happen.  */
       fingerprint_from_pk (node->pkt->pkt.public_key, fpr, &fprlen);
       node->flag &= ~NODE_TRANSFER_SECKEY;
       for (n=0; n < nfprlist; n++)
         if (fprlist[n].fprlen == fprlen && !memcmp (fprlist[n].fpr,fpr,fprlen))
           {
             node->flag |= NODE_TRANSFER_SECKEY;
             /* log_debug ("found matching seckey\n"); */
             break;
           }
     }
 
   /* Transfer all marked keys.  */
   err = do_transfer (ctrl, seckeys, pk, stats, batch, 1);
 
  leave:
   xfree (fprlist);
   release_kbnode (pub_keyblock);
   return err;
 }
 
 
 /* Import function for a single secret keyblock.  Handling is simpler
  * than for public keys.  We allow secret key importing only when
  * allow is true, this is so that a secret key can not be imported
  * accidentally and thereby tampering with the trust calculation.
  *
  * Ownership of KEYBLOCK is transferred to this function!
  *
  * If R_SECATTIC is not null the last special sec_keyblock is stored
  * there.
  */
 static gpg_error_t
 import_secret_one (ctrl_t ctrl, kbnode_t keyblock,
                    struct import_stats_s *stats, int batch,
                    unsigned int options, int for_migration,
                    import_screener_t screener, void *screener_arg,
                    kbnode_t *r_secattic)
 {
   PKT_public_key *pk;
   struct seckey_info *ski;
   kbnode_t node, uidnode;
   u32 keyid[2];
   gpg_error_t err = 0;
   int nr_prev;
   kbnode_t pub_keyblock;
   kbnode_t attic = NULL;
   byte fpr[MAX_FINGERPRINT_LEN];
   size_t fprlen;
   char pkstrbuf[PUBKEY_STRING_SIZE];
 
   /* Get the key and print some info about it */
   node = find_kbnode (keyblock, PKT_SECRET_KEY);
   if (!node)
     BUG ();
 
   pk = node->pkt->pkt.public_key;
 
   fingerprint_from_pk (pk, fpr, &fprlen);
   keyid_from_pk (pk, keyid);
   uidnode = find_next_kbnode (keyblock, PKT_USER_ID);
 
   if (screener && screener (keyblock, screener_arg))
     {
       log_error (_("secret key %s: %s\n"), keystr_from_pk (pk),
                  _("rejected by import screener"));
       release_kbnode (keyblock);
       return 0;
     }
 
   if (opt.verbose && !for_migration)
     {
       log_info ("sec  %s/%s %s  ",
                 pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
                 keystr_from_pk (pk), datestr_from_pk (pk));
       if (uidnode)
         print_utf8_buffer (log_get_stream (), uidnode->pkt->pkt.user_id->name,
                            uidnode->pkt->pkt.user_id->len);
       log_printf ("\n");
     }
   stats->secret_read++;
 
   if ((options & IMPORT_NO_SECKEY))
     {
       if (!for_migration)
         log_error (_("importing secret keys not allowed\n"));
       release_kbnode (keyblock);
       return 0;
     }
 
   if (!uidnode)
     {
       if (!for_migration)
         log_error( _("key %s: no user ID\n"), keystr_from_pk (pk));
       release_kbnode (keyblock);
       return 0;
     }
 
   ski = pk->seckey_info;
   if (!ski)
     {
       /* Actually an internal error.  */
       log_error ("key %s: secret key info missing\n", keystr_from_pk (pk));
       release_kbnode (keyblock);
       return 0;
     }
 
   /* A quick check to not import keys with an invalid protection
      cipher algorithm (only checks the primary key, though).  */
   if (ski->algo > 110)
     {
       if (!for_migration)
         log_error (_("key %s: secret key with invalid cipher %d"
                      " - skipped\n"), keystr_from_pk (pk), ski->algo);
       release_kbnode (keyblock);
       return 0;
     }
 
 #ifdef ENABLE_SELINUX_HACKS
   if (1)
     {
       /* We don't allow importing secret keys because that may be used
          to put a secret key into the keyring and the user might later
          be tricked into signing stuff with that key.  */
       log_error (_("importing secret keys not allowed\n"));
       release_kbnode (keyblock);
       return 0;
     }
 #endif
 
   clear_kbnode_flags (keyblock);
 
   nr_prev = stats->skipped_new_keys;
 
   /* Make a public key out of the key. */
   pub_keyblock = sec_to_pub_keyblock (keyblock);
   if (!pub_keyblock)
     {
       err = gpg_error_from_syserror ();
       log_error ("key %s: failed to create public key from secret key\n",
                  keystr_from_pk (pk));
     }
   else
     {
       int valid;
 
       /* Note that this outputs an IMPORT_OK status message for the
 	 public key block, and below we will output another one for
 	 the secret keys.  FIXME?  */
       import_one (ctrl, pub_keyblock, stats,
 		  NULL, NULL, options, 1, for_migration,
                   screener, screener_arg, 0, NULL, &valid);
 
       /* The secret keyblock may not have nodes which are deleted in
        * the public keyblock.  Otherwise we would import just the
        * secret key without having the public key.  That would be
        * surprising and clutters our private-keys-v1.d.  */
       err = resync_sec_with_pub_keyblock (&keyblock, pub_keyblock, &attic);
       if (err)
         goto leave;
 
       if (!valid)
         {
           /* If the block was not valid the primary key is left in the
            * original keyblock because we require that for the first
            * node.   Move it to ATTIC.  */
           if (keyblock && keyblock->pkt->pkttype == PKT_SECRET_KEY)
             {
               node = keyblock;
               keyblock = node->next;
               node->next = NULL;
               if (attic)
                 {
                   node->next = attic;
                   attic = node;
                 }
               else
                 attic = node;
             }
 
           /* Try to import the secret key iff we have a public key.  */
           if (attic && !(opt.dry_run || (options & IMPORT_DRY_RUN)))
             err = import_matching_seckeys (ctrl, attic, fpr, fprlen,
                                            stats, batch);
           else
             err = gpg_error (GPG_ERR_NO_SECKEY);
           goto leave;
         }
 
       /* log_debug ("attic is:\n"); */
       /* dump_kbnode (attic); */
 
       /* Proceed with the valid parts of PUBKEYBLOCK. */
 
       /* At least we cancel the secret key import when the public key
 	 import was skipped due to MERGE_ONLY option and a new
 	 key.  */
       if (!(opt.dry_run || (options & IMPORT_DRY_RUN))
           && stats->skipped_new_keys <= nr_prev)
 	{
           /* Read the keyblock again to get the effects of a merge for
            * the public key.  */
           err = get_pubkey_byfprint (ctrl, NULL, &node, fpr, fprlen);
           if (err || !node)
             log_error ("key %s: failed to re-lookup public key: %s\n",
                        keystr_from_pk (pk), gpg_strerror (err));
           else
             {
               err = do_transfer (ctrl, keyblock, pk, stats, batch, 0);
               if (!err)
                 check_prefs (ctrl, node);
               release_kbnode (node);
 
               if (!err && attic)
                 {
                   /* Try to import invalid subkeys.  This can be the
                    * case if the primary secret key was imported due
                    * to --allow-non-selfsigned-uid.  */
                   err = import_matching_seckeys (ctrl, attic, fpr, fprlen,
                                                  stats, batch);
                 }
 
             }
         }
     }
 
  leave:
   release_kbnode (keyblock);
   release_kbnode (pub_keyblock);
   if (r_secattic)
     *r_secattic = attic;
   else
     release_kbnode (attic);
   return err;
 }
 
 
 
 /* Return the recocation reason from signature SIG.  If no revocation
  * reason is available 0 is returned, in other cases the reason
  * (0..255).  If R_REASON is not NULL a malloced textual
  * representation of the code is stored there.  If R_COMMENT is not
  * NULL the comment from the reason is stored there and its length at
  * R_COMMENTLEN.  Note that the value at R_COMMENT is not filtered but
  * user supplied data in UTF8; thus it needs to be escaped for display
  * purposes.  Both return values are either NULL or a malloced
  * string/buffer.  */
 int
 get_revocation_reason (PKT_signature *sig, char **r_reason,
                        char **r_comment, size_t *r_commentlen)
 {
   int reason_seq = 0;
   size_t reason_n;
   const byte *reason_p;
   char reason_code_buf[20];
   const char *reason_text = NULL;
   int reason_code = 0;
 
   if (r_reason)
     *r_reason = NULL;
   if (r_comment)
     *r_comment = NULL;
 
   /* Skip over empty reason packets.  */
   while ((reason_p = enum_sig_subpkt (sig, 1, SIGSUBPKT_REVOC_REASON,
                                       &reason_n, &reason_seq, NULL))
          && !reason_n)
     ;
   if (reason_p)
     {
       reason_code = *reason_p;
       reason_n--; reason_p++;
       switch (reason_code)
         {
         case 0x00: reason_text = _("No reason specified"); break;
         case 0x01: reason_text = _("Key is superseded");   break;
         case 0x02: reason_text = _("Key has been compromised"); break;
         case 0x03: reason_text = _("Key is no longer used"); break;
         case 0x20: reason_text = _("User ID is no longer valid"); break;
         default:
           snprintf (reason_code_buf, sizeof reason_code_buf,
                     "code=%02x", reason_code);
           reason_text = reason_code_buf;
           break;
         }
 
       if (r_reason)
         *r_reason = xstrdup (reason_text);
 
       if (r_comment && reason_n)
         {
           *r_comment = xmalloc (reason_n);
           memcpy (*r_comment, reason_p, reason_n);
           *r_commentlen = reason_n;
         }
     }
 
   return reason_code;
 }
 
 
 /* List the recocation signature as a "rvs" record.  SIGRC shows the
  * character from the signature verification or 0 if no public key was
  * found.  */
 static void
 list_standalone_revocation (ctrl_t ctrl, PKT_signature *sig, int sigrc)
 {
   char *siguid = NULL;
   size_t siguidlen = 0;
   char *issuer_fpr = NULL;
   int reason_code = 0;
   char *reason_text = NULL;
   char *reason_comment = NULL;
   size_t reason_commentlen;
 
   if (sigrc != '%' && sigrc != '?' && !opt.fast_list_mode)
     {
       int nouid;
       siguid = get_user_id (ctrl, sig->keyid, &siguidlen, &nouid);
       if (nouid)
         sigrc = '?';
     }
 
   reason_code = get_revocation_reason (sig, &reason_text,
                                        &reason_comment, &reason_commentlen);
 
   if (opt.with_colons)
     {
       es_fputs ("rvs:", es_stdout);
       if (sigrc)
         es_putc (sigrc, es_stdout);
       es_fprintf (es_stdout, "::%d:%08lX%08lX:%s:%s:::",
                   sig->pubkey_algo,
                   (ulong) sig->keyid[0], (ulong) sig->keyid[1],
                   colon_datestr_from_sig (sig),
                   colon_expirestr_from_sig (sig));
 
       if (siguid)
         es_write_sanitized (es_stdout, siguid, siguidlen, ":", NULL);
 
       es_fprintf (es_stdout, ":%02x%c", sig->sig_class,
                   sig->flags.exportable ? 'x' : 'l');
       if (reason_text)
         es_fprintf (es_stdout, ",%02x", reason_code);
       es_fputs ("::", es_stdout);
 
       if ((issuer_fpr = issuer_fpr_string (sig)))
         es_fputs (issuer_fpr, es_stdout);
 
       es_fprintf (es_stdout, ":::%d:", sig->digest_algo);
 
       if (reason_comment)
         {
           es_fputs ("::::", es_stdout);
           es_write_sanitized (es_stdout, reason_comment, reason_commentlen,
                               ":", NULL);
           es_putc (':', es_stdout);
         }
       es_putc ('\n', es_stdout);
 
       if (opt.show_subpackets)
         print_subpackets_colon (sig);
     }
   else /* Human readable. */
     {
       es_fputs ("rvs", es_stdout);
       es_fprintf (es_stdout, "%c%c %c%c%c%c%c%c %s %s",
 		  sigrc, (sig->sig_class - 0x10 > 0 &&
 			  sig->sig_class - 0x10 <
 			  4) ? '0' + sig->sig_class - 0x10 : ' ',
 		  sig->flags.exportable ? ' ' : 'L',
 		  sig->flags.revocable ? ' ' : 'R',
 		  sig->flags.policy_url ? 'P' : ' ',
 		  sig->flags.notation ? 'N' : ' ',
 		  sig->flags.expired ? 'X' : ' ',
 		  (sig->trust_depth > 9) ? 'T' : (sig->trust_depth >
 						  0) ? '0' +
 		  sig->trust_depth : ' ', keystr (sig->keyid),
 		  datestr_from_sig (sig));
       if (siguid)
         {
           es_fprintf (es_stdout, "  ");
           print_utf8_buffer (es_stdout, siguid, siguidlen);
         }
       es_putc ('\n', es_stdout);
 
       if (sig->flags.policy_url
           && (opt.list_options & LIST_SHOW_POLICY_URLS))
         show_policy_url (sig, 3, 0);
 
       if (sig->flags.notation && (opt.list_options & LIST_SHOW_NOTATIONS))
         show_notation (sig, 3, 0,
                        ((opt.list_options & LIST_SHOW_STD_NOTATIONS) ? 1 : 0)
                        +
                        ((opt.list_options & LIST_SHOW_USER_NOTATIONS) ? 2 : 0));
 
       if (sig->flags.pref_ks
           && (opt.list_options & LIST_SHOW_KEYSERVER_URLS))
         show_keyserver_url (sig, 3, 0);
 
       if (reason_text)
         {
           es_fprintf (es_stdout, "      %s%s\n",
                       _("reason for revocation: "), reason_text);
           if (reason_comment)
             {
               const byte *s, *s_lf;
               size_t n, n_lf;
 
               s = reason_comment;
               n = reason_commentlen;
               s_lf = NULL;
               do
                 {
                   /* We don't want any empty lines, so we skip them.  */
                   for (;n && *s == '\n'; s++, n--)
                     ;
                   if (n)
                     {
                       s_lf = memchr (s, '\n', n);
                       n_lf = s_lf? s_lf - s : n;
                       es_fprintf (es_stdout, "         %s",
                                   _("revocation comment: "));
                       es_write_sanitized (es_stdout, s, n_lf, NULL, NULL);
                       es_putc ('\n', es_stdout);
                       s += n_lf; n -= n_lf;
                     }
                 } while (s_lf);
             }
         }
     }
 
   es_fflush (es_stdout);
 
   xfree (reason_text);
   xfree (reason_comment);
   xfree (siguid);
   xfree (issuer_fpr);
 }
 
 
 /****************
  * Import a revocation certificate; this is a single signature packet.
  */
 static int
 import_revoke_cert (ctrl_t ctrl, kbnode_t node, unsigned int options,
                     struct import_stats_s *stats)
 {
   PKT_public_key *pk = NULL;
   kbnode_t onode;
   kbnode_t keyblock = NULL;
   KEYDB_HANDLE hd = NULL;
   u32 keyid[2];
   int rc = 0;
   int sigrc = 0;
   int silent;
 
   /* No error output for --show-keys.  */
   silent = (options & (IMPORT_SHOW | IMPORT_DRY_RUN));
 
   log_assert (!node->next );
   log_assert (node->pkt->pkttype == PKT_SIGNATURE );
   log_assert (IS_KEY_REV (node->pkt->pkt.signature));
 
   keyid[0] = node->pkt->pkt.signature->keyid[0];
   keyid[1] = node->pkt->pkt.signature->keyid[1];
 
   pk = xmalloc_clear( sizeof *pk );
   rc = get_pubkey (ctrl, pk, keyid );
   if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY )
     {
       if (!silent)
         log_error (_("key %s: no public key -"
                      " can't apply revocation certificate\n"), keystr(keyid));
       rc = 0;
       goto leave;
     }
   else if (rc )
     {
       log_error (_("key %s: public key not found: %s\n"),
                  keystr(keyid), gpg_strerror (rc));
       goto leave;
     }
 
   /* Read the original keyblock. */
   hd = keydb_new (ctrl);
   if (!hd)
     {
       rc = gpg_error_from_syserror ();
       goto leave;
     }
 
   {
     byte afp[MAX_FINGERPRINT_LEN];
     size_t an;
 
     fingerprint_from_pk (pk, afp, &an);
     rc = keydb_search_fpr (hd, afp, an);
   }
   if (rc)
     {
       log_error (_("key %s: can't locate original keyblock: %s\n"),
                  keystr(keyid), gpg_strerror (rc));
       goto leave;
     }
   rc = keydb_get_keyblock (hd, &keyblock );
   if (rc)
     {
       log_error (_("key %s: can't read original keyblock: %s\n"),
                  keystr(keyid), gpg_strerror (rc));
       goto leave;
     }
 
   /* it is okay, that node is not in keyblock because
    * check_key_signature works fine for sig_class 0x20 (KEY_REV) in
    * this special case.  SIGRC is only used for IMPORT_SHOW.  */
   rc = check_key_signature (ctrl, keyblock, node, NULL);
   switch (gpg_err_code (rc))
     {
     case 0:                       sigrc = '!'; break;
     case GPG_ERR_BAD_SIGNATURE:   sigrc = '-'; break;
     case GPG_ERR_NO_PUBKEY:       sigrc = '?'; break;
     case GPG_ERR_UNUSABLE_PUBKEY: sigrc = '?'; break;
     default:                      sigrc = '%'; break;
     }
   if (rc )
     {
       if (!silent)
         log_error (_("key %s: invalid revocation certificate"
                      ": %s - rejected\n"), keystr(keyid), gpg_strerror (rc));
       goto leave;
     }
 
   /* check whether we already have this */
   for(onode=keyblock->next; onode; onode=onode->next ) {
     if (onode->pkt->pkttype == PKT_USER_ID )
       break;
     else if (onode->pkt->pkttype == PKT_SIGNATURE
              && !cmp_signatures(node->pkt->pkt.signature,
                                 onode->pkt->pkt.signature))
       {
         rc = 0;
         goto leave; /* yes, we already know about it */
       }
   }
 
   /* insert it */
   insert_kbnode( keyblock, clone_kbnode(node), 0 );
 
   /* and write the keyblock back unless in dry run mode.  */
   if (!(opt.dry_run || (options & IMPORT_DRY_RUN)))
     {
       rc = keydb_update_keyblock (ctrl, hd, keyblock );
       if (rc)
         log_error (_("error writing keyring '%s': %s\n"),
                    keydb_get_resource_name (hd), gpg_strerror (rc) );
       keydb_release (hd);
       hd = NULL;
 
       /* we are ready */
       if (!opt.quiet )
         {
           char *p=get_user_id_native (ctrl, keyid);
           log_info( _("key %s: \"%s\" revocation certificate imported\n"),
                     keystr(keyid),p);
           xfree(p);
         }
 
       /* If the key we just revoked was ultimately trusted, remove its
        * ultimate trust.  This doesn't stop the user from putting the
        * ultimate trust back, but is a reasonable solution for now. */
       if (get_ownertrust (ctrl, pk) == TRUST_ULTIMATE)
         clear_ownertrusts (ctrl, pk);
 
       revalidation_mark (ctrl);
     }
   stats->n_revoc++;
 
  leave:
   if ((options & IMPORT_SHOW))
     list_standalone_revocation (ctrl, node->pkt->pkt.signature, sigrc);
 
   keydb_release (hd);
   release_kbnode( keyblock );
   free_public_key( pk );
   return rc;
 }
 
 
 /* Loop over the KEYBLOCK and check all self signatures.  KEYID is the
  * keyid of the primary key for reporting purposes. On return the
  * following bits in the node flags are set:
  *
  * - NODE_GOOD_SELFSIG  :: User ID or subkey has a self-signature
  * - NODE_BAD_SELFSIG   :: Used ID or subkey has an invalid self-signature
  * - NODE_DELETION_MARK :: This node shall be deleted
  *
  * NON_SELF is set to true if there are any sigs other than self-sigs
  * in this keyblock.
  *
  * Returns 0 on success or -1 (but not an error code) if the keyblock
  * is invalid.
  */
 static int
 chk_self_sigs (ctrl_t ctrl, kbnode_t keyblock, u32 *keyid, int *non_self)
 {
   kbnode_t knode = NULL;   /* The node of the current subkey.  */
   PKT_public_key *subpk = NULL; /* and its packet. */
   kbnode_t bsnode = NULL;  /* Subkey binding signature node.  */
   u32 bsdate = 0;          /* Timestamp of that node.   */
   kbnode_t rsnode = NULL;  /* Subkey recocation signature node.  */
   u32 rsdate = 0;          /* Timestamp of that node.  */
   PKT_signature *sig;
   int rc;
   kbnode_t n;
 
   for (n=keyblock; (n = find_next_kbnode (n, 0)); )
     {
       if (n->pkt->pkttype == PKT_PUBLIC_SUBKEY)
 	{
 	  knode = n;
           subpk = knode->pkt->pkt.public_key;
 	  bsdate = 0;
 	  rsdate = 0;
 	  bsnode = NULL;
 	  rsnode = NULL;
 	  continue;
 	}
 
       if ( n->pkt->pkttype != PKT_SIGNATURE )
         continue;
 
       sig = n->pkt->pkt.signature;
       if ( keyid[0] != sig->keyid[0] || keyid[1] != sig->keyid[1] )
         {
           *non_self = 1;
           continue;
         }
 
       /* This just caches the sigs for later use.  That way we
          import a fully-cached key which speeds things up. */
       if (!opt.no_sig_cache)
         check_key_signature (ctrl, keyblock, n, NULL);
 
       if ( IS_UID_SIG(sig) || IS_UID_REV(sig) )
         {
           kbnode_t unode = find_prev_kbnode( keyblock, n, PKT_USER_ID );
           if ( !unode )
             {
               log_error( _("key %s: no user ID for signature\n"),
                          keystr(keyid));
               return -1;  /* The complete keyblock is invalid.  */
             }
 
           /* If it hasn't been marked valid yet, keep trying.  */
           if (!(unode->flag & NODE_GOOD_SELFSIG))
             {
               rc = check_key_signature (ctrl, keyblock, n, NULL);
               if ( rc )
                 {
                   if ( opt.verbose )
                     {
                       char *p = utf8_to_native
                         (unode->pkt->pkt.user_id->name,
                          strlen (unode->pkt->pkt.user_id->name),0);
                       log_info (gpg_err_code(rc) == GPG_ERR_PUBKEY_ALGO ?
                                 _("key %s: unsupported public key "
                                   "algorithm on user ID \"%s\"\n"):
                                 _("key %s: invalid self-signature "
                                   "on user ID \"%s\"\n"),
                                 keystr (keyid),p);
                       xfree (p);
                     }
                 }
               else
                 unode->flag |= NODE_GOOD_SELFSIG;
             }
         }
       else if (IS_KEY_SIG (sig))
         {
           rc = check_key_signature (ctrl, keyblock, n, NULL);
           if ( rc )
             {
               if (opt.verbose)
                 log_info (gpg_err_code (rc) == GPG_ERR_PUBKEY_ALGO ?
                           _("key %s: unsupported public key algorithm\n"):
                           _("key %s: invalid direct key signature\n"),
                           keystr (keyid));
               n->flag |= NODE_DELETION_MARK;
             }
         }
       else if ( IS_SUBKEY_SIG (sig) )
         {
           /* Note that this works based solely on the timestamps like
              the rest of gpg.  If the standard gets revocation
              targets, this may need to be revised.  */
 
           if ( !knode )
             {
               if (opt.verbose)
                 log_info (_("key %s: no subkey for key binding\n"),
                           keystr (keyid));
               n->flag |= NODE_DELETION_MARK;
             }
           else
             {
               rc = check_key_signature (ctrl, keyblock, n, NULL);
               if ( rc )
                 {
                   if (opt.verbose)
                     {
                       keyid_from_pk (subpk, NULL);
                       log_info (gpg_err_code (rc) == GPG_ERR_PUBKEY_ALGO ?
                                 _("key %s: unsupported public key"
                                   " algorithm\n"):
                                 _("key %s: invalid subkey binding\n"),
                                 keystr_with_sub (keyid, subpk->keyid));
                     }
                   n->flag |= NODE_DELETION_MARK;
                 }
               else
                 {
                   /* It's valid, so is it newer? */
                   if (sig->timestamp >= bsdate)
                     {
                       knode->flag |= NODE_GOOD_SELFSIG; /* Subkey is valid.  */
                       if (bsnode)
                         {
                           /* Delete the last binding sig since this
                              one is newer */
                           bsnode->flag |= NODE_DELETION_MARK;
                           if (opt.verbose)
                             {
                               keyid_from_pk (subpk, NULL);
                               log_info (_("key %s: removed multiple subkey"
                                           " binding\n"),
                                         keystr_with_sub (keyid, subpk->keyid));
                             }
                         }
 
                       bsnode = n;
                       bsdate = sig->timestamp;
                     }
                   else
                     n->flag |= NODE_DELETION_MARK; /* older */
                 }
             }
         }
       else if ( IS_SUBKEY_REV (sig) )
         {
           /* We don't actually mark the subkey as revoked right now,
              so just check that the revocation sig is the most recent
              valid one.  Note that we don't care if the binding sig is
              newer than the revocation sig.  See the comment in
              getkey.c:merge_selfsigs_subkey for more.  */
           if ( !knode )
             {
               if (opt.verbose)
                 log_info (_("key %s: no subkey for key revocation\n"),
                           keystr(keyid));
               n->flag |= NODE_DELETION_MARK;
             }
           else
             {
               rc = check_key_signature (ctrl, keyblock, n, NULL);
               if ( rc )
                 {
                   if(opt.verbose)
                     log_info (gpg_err_code (rc) == GPG_ERR_PUBKEY_ALGO ?
                               _("key %s: unsupported public"
                                 " key algorithm\n"):
                               _("key %s: invalid subkey revocation\n"),
                               keystr(keyid));
                   n->flag |= NODE_DELETION_MARK;
                 }
               else
                 {
                   /* It's valid, so is it newer? */
                   if (sig->timestamp >= rsdate)
                     {
                       if (rsnode)
                         {
                           /* Delete the last revocation sig since
                              this one is newer.  */
                           rsnode->flag |= NODE_DELETION_MARK;
                           if (opt.verbose)
                             log_info (_("key %s: removed multiple subkey"
                                         " revocation\n"),keystr(keyid));
                         }
 
                       rsnode = n;
                       rsdate = sig->timestamp;
                     }
                   else
                     n->flag |= NODE_DELETION_MARK; /* older */
                 }
             }
         }
     }
 
   return 0;
 }
 
 
 /* Delete all parts which are invalid and those signatures whose
  * public key algorithm is not available in this implementation; but
  * consider RSA as valid, because parse/build_packets knows about it.
  *
  * Returns: True if at least one valid user-id is left over.
  */
 static int
 delete_inv_parts (ctrl_t ctrl, kbnode_t keyblock, u32 *keyid,
                   unsigned int options)
 {
   kbnode_t node;
   int nvalid=0, uid_seen=0, subkey_seen=0;
   PKT_public_key *pk;
 
   for (node=keyblock->next; node; node = node->next )
     {
       if (node->pkt->pkttype == PKT_USER_ID)
         {
           uid_seen = 1;
           if ((node->flag & NODE_BAD_SELFSIG)
               || !(node->flag & NODE_GOOD_SELFSIG))
             {
               if (opt.verbose )
                 {
                   char *p=utf8_to_native(node->pkt->pkt.user_id->name,
                                          node->pkt->pkt.user_id->len,0);
                   log_info( _("key %s: skipped user ID \"%s\"\n"),
                             keystr(keyid),p);
                   xfree(p);
                 }
               delete_kbnode( node ); /* the user-id */
               /* and all following packets up to the next user-id */
               while (node->next
                      && node->next->pkt->pkttype != PKT_USER_ID
                      && node->next->pkt->pkttype != PKT_PUBLIC_SUBKEY
                      && node->next->pkt->pkttype != PKT_SECRET_SUBKEY ){
                 delete_kbnode( node->next );
                 node = node->next;
               }
 	    }
           else
             nvalid++;
 	}
       else if (   node->pkt->pkttype == PKT_PUBLIC_SUBKEY
                || node->pkt->pkttype == PKT_SECRET_SUBKEY )
         {
           if ((node->flag & NODE_BAD_SELFSIG)
               || !(node->flag & NODE_GOOD_SELFSIG))
             {
               if (opt.verbose )
                 {
                   pk = node->pkt->pkt.public_key;
                   keyid_from_pk (pk, NULL);
                   log_info (_("key %s: skipped subkey\n"),
                             keystr_with_sub (keyid, pk->keyid));
                 }
 
               delete_kbnode( node ); /* the subkey */
               /* and all following signature packets */
               while (node->next
                      && node->next->pkt->pkttype == PKT_SIGNATURE ) {
                 delete_kbnode( node->next );
                 node = node->next;
               }
 	    }
           else
             subkey_seen = 1;
 	}
       else if (node->pkt->pkttype == PKT_SIGNATURE
                && openpgp_pk_test_algo (node->pkt->pkt.signature->pubkey_algo)
                && node->pkt->pkt.signature->pubkey_algo != PUBKEY_ALGO_RSA )
         {
           delete_kbnode( node ); /* build_packet() can't handle this */
         }
       else if (node->pkt->pkttype == PKT_SIGNATURE
                && !node->pkt->pkt.signature->flags.exportable
                && !(options&IMPORT_LOCAL_SIGS)
                && !have_secret_key_with_kid (ctrl,
                                              node->pkt->pkt.signature->keyid))
         {
           /* here we violate the rfc a bit by still allowing
            * to import non-exportable signature when we have the
            * the secret key used to create this signature - it
            * seems that this makes sense */
           if(opt.verbose)
             log_info( _("key %s: non exportable signature"
                         " (class 0x%02X) - skipped\n"),
                       keystr(keyid), node->pkt->pkt.signature->sig_class );
           delete_kbnode( node );
         }
       else if (node->pkt->pkttype == PKT_SIGNATURE
                && IS_KEY_REV (node->pkt->pkt.signature))
         {
           if (uid_seen )
             {
               if(opt.verbose)
                 log_info( _("key %s: revocation certificate"
                             " at wrong place - skipped\n"),keystr(keyid));
               delete_kbnode( node );
             }
           else
             {
 	      /* If the revocation cert is from a different key than
                  the one we're working on don't check it - it's
                  probably from a revocation key and won't be
                  verifiable with this key anyway. */
 
 	      if(node->pkt->pkt.signature->keyid[0]==keyid[0]
                  && node->pkt->pkt.signature->keyid[1]==keyid[1])
 		{
 		  int rc = check_key_signature (ctrl, keyblock, node, NULL);
 		  if (rc )
 		    {
 		      if(opt.verbose)
 			log_info( _("key %s: invalid revocation"
 				    " certificate: %s - skipped\n"),
 				  keystr(keyid), gpg_strerror (rc));
 		      delete_kbnode( node );
 		    }
 		}
 	    }
 	}
       else if (node->pkt->pkttype == PKT_SIGNATURE
                && (IS_SUBKEY_SIG (node->pkt->pkt.signature)
                    || IS_SUBKEY_REV (node->pkt->pkt.signature))
                && !subkey_seen )
         {
           if(opt.verbose)
             log_info( _("key %s: subkey signature"
                         " in wrong place - skipped\n"), keystr(keyid));
           delete_kbnode( node );
         }
       else if (node->pkt->pkttype == PKT_SIGNATURE
                && !IS_CERT(node->pkt->pkt.signature))
         {
           if(opt.verbose)
             log_info(_("key %s: unexpected signature class (0x%02X) -"
                        " skipped\n"),keystr(keyid),
                      node->pkt->pkt.signature->sig_class);
           delete_kbnode(node);
 	  }
       else if ((node->flag & NODE_DELETION_MARK))
         delete_kbnode( node );
     }
 
   /* note: because keyblock is the public key, it is never marked
    * for deletion and so keyblock cannot change */
   commit_kbnode( &keyblock );
   return nvalid;
 }
 
 /* This function returns true if any UID is left in the keyring.  */
 static int
 any_uid_left (kbnode_t keyblock)
 {
   kbnode_t node;
 
   for (node=keyblock->next; node; node = node->next)
     if (node->pkt->pkttype == PKT_USER_ID)
       return 1;
   return 0;
 }
 
 
 /* Delete all non-self-sigs from KEYBLOCK.
  * Returns: True if the keyblock has changed.  */
 static void
 remove_all_non_self_sigs (kbnode_t *keyblock, u32 *keyid)
 {
   kbnode_t node;
   unsigned int dropped = 0;
 
   for (node = *keyblock; node; node = node->next)
     {
       if (is_deleted_kbnode (node))
 	continue;
 
       if (node->pkt->pkttype != PKT_SIGNATURE)
 	continue;
 
       if (node->pkt->pkt.signature->keyid[0] == keyid[0]
           && node->pkt->pkt.signature->keyid[1] == keyid[1])
         continue;
       delete_kbnode (node);
       dropped++;
     }
 
   if (dropped)
     commit_kbnode (keyblock);
 
   if (dropped && opt.verbose)
     log_info ("key %s: number of dropped non-self-signatures: %u\n",
               keystr (keyid), dropped);
 }
 
 
 /*
  * It may happen that the imported keyblock has duplicated user IDs.
  * We check this here and collapse those user IDs together with their
  * sigs into one.
  * Returns: True if the keyblock has changed.
  */
 int
 collapse_uids (kbnode_t *keyblock)
 {
   kbnode_t uid1;
   int any=0;
 
   for(uid1=*keyblock;uid1;uid1=uid1->next)
     {
       kbnode_t uid2;
 
       if(is_deleted_kbnode(uid1))
 	continue;
 
       if(uid1->pkt->pkttype!=PKT_USER_ID)
 	continue;
 
       for(uid2=uid1->next;uid2;uid2=uid2->next)
 	{
 	  if(is_deleted_kbnode(uid2))
 	    continue;
 
 	  if(uid2->pkt->pkttype!=PKT_USER_ID)
 	    continue;
 
 	  if(cmp_user_ids(uid1->pkt->pkt.user_id,
 			  uid2->pkt->pkt.user_id)==0)
 	    {
 	      /* We have a duplicated uid */
 	      kbnode_t sig1,last;
 
 	      any=1;
 
 	      /* Now take uid2's signatures, and attach them to
 		 uid1 */
 	      for(last=uid2;last->next;last=last->next)
 		{
 		  if(is_deleted_kbnode(last))
 		    continue;
 
 		  if(last->next->pkt->pkttype==PKT_USER_ID
 		     || last->next->pkt->pkttype==PKT_PUBLIC_SUBKEY
 		     || last->next->pkt->pkttype==PKT_SECRET_SUBKEY)
 		    break;
 		}
 
 	      /* Snip out uid2 */
 	      (find_prev_kbnode(*keyblock,uid2,0))->next=last->next;
 
 	      /* Now put uid2 in place as part of uid1 */
 	      last->next=uid1->next;
 	      uid1->next=uid2;
 	      delete_kbnode(uid2);
 
 	      /* Now dedupe uid1 */
 	      for(sig1=uid1->next;sig1;sig1=sig1->next)
 		{
 		  kbnode_t sig2;
 
 		  if(is_deleted_kbnode(sig1))
 		    continue;
 
 		  if(sig1->pkt->pkttype==PKT_USER_ID
 		     || sig1->pkt->pkttype==PKT_PUBLIC_SUBKEY
 		     || sig1->pkt->pkttype==PKT_SECRET_SUBKEY)
 		    break;
 
 		  if(sig1->pkt->pkttype!=PKT_SIGNATURE)
 		    continue;
 
 		  for(sig2=sig1->next,last=sig1;sig2;last=sig2,sig2=sig2->next)
 		    {
 		      if(is_deleted_kbnode(sig2))
 			continue;
 
 		      if(sig2->pkt->pkttype==PKT_USER_ID
 			 || sig2->pkt->pkttype==PKT_PUBLIC_SUBKEY
 			 || sig2->pkt->pkttype==PKT_SECRET_SUBKEY)
 			break;
 
 		      if(sig2->pkt->pkttype!=PKT_SIGNATURE)
 			continue;
 
 		      if(cmp_signatures(sig1->pkt->pkt.signature,
 					sig2->pkt->pkt.signature)==0)
 			{
 			  /* We have a match, so delete the second
 			     signature */
 			  delete_kbnode(sig2);
 			  sig2=last;
 			}
 		    }
 		}
 	    }
 	}
     }
 
   commit_kbnode(keyblock);
 
   if(any && !opt.quiet)
     {
       const char *key="???";
 
       if ((uid1 = find_kbnode (*keyblock, PKT_PUBLIC_KEY)) )
 	key = keystr_from_pk (uid1->pkt->pkt.public_key);
       else if ((uid1 = find_kbnode( *keyblock, PKT_SECRET_KEY)) )
 	key = keystr_from_pk (uid1->pkt->pkt.public_key);
 
       log_info (_("key %s: duplicated user ID detected - merged\n"), key);
     }
 
   return any;
 }
 
 
 /*
  * It may happen that the imported keyblock has duplicated subkeys.
  * We check this here and collapse those subkeys along with their
  * binding self-signatures.
  * Returns: True if the keyblock has changed.
  */
 int
 collapse_subkeys (kbnode_t *keyblock)
 {
   kbnode_t kb1, kb2, sig1, sig2, last;
   int any = 0;
 
   for (kb1 = *keyblock; kb1; kb1 = kb1->next)
     {
       if (is_deleted_kbnode (kb1))
 	continue;
 
       if (kb1->pkt->pkttype != PKT_PUBLIC_SUBKEY
           && kb1->pkt->pkttype != PKT_SECRET_SUBKEY)
 	continue;
 
       /* We assume just a few duplicates and use a straightforward
        * algorithm.  */
       for (kb2 = kb1->next; kb2; kb2 = kb2->next)
 	{
 	  if (is_deleted_kbnode (kb2))
 	    continue;
 
           if (kb2->pkt->pkttype != PKT_PUBLIC_SUBKEY
               && kb2->pkt->pkttype != PKT_SECRET_SUBKEY)
 	    continue;
 
           if (cmp_public_keys (kb1->pkt->pkt.public_key,
                                kb2->pkt->pkt.public_key))
             continue;
 
           /* We have a duplicated subkey. */
           any = 1;
 
           /* Take subkey-2's signatures, and attach them to subkey-1. */
           for (last = kb2; last->next; last = last->next)
             {
               if (is_deleted_kbnode (last))
                 continue;
 
               if (last->next->pkt->pkttype != PKT_SIGNATURE)
                 break;
             }
 
           /* Snip out subkye-2 */
           find_prev_kbnode (*keyblock, kb2, 0)->next = last->next;
 
 	  /* Put subkey-2 in place as part of subkey-1 */
           last->next = kb1->next;
           kb1->next = kb2;
           delete_kbnode (kb2);
 
           /* Now dedupe kb1 */
           for (sig1 = kb1->next; sig1; sig1 = sig1->next)
             {
               if (is_deleted_kbnode (sig1))
                 continue;
 
               if (sig1->pkt->pkttype != PKT_SIGNATURE)
                 break;
 
               for (sig2 = sig1->next, last = sig1;
                    sig2;
                    last = sig2, sig2 = sig2->next)
                 {
                   if (is_deleted_kbnode (sig2))
                     continue;
 
                   if (sig2->pkt->pkttype != PKT_SIGNATURE)
                     break;
 
                   if (!cmp_signatures (sig1->pkt->pkt.signature,
                                        sig2->pkt->pkt.signature))
                     {
                       /* We have a match, so delete the second
                          signature */
                       delete_kbnode (sig2);
                       sig2 = last;
                     }
                 }
             }
         }
     }
 
   commit_kbnode (keyblock);
 
   if (any && !opt.quiet)
     {
       const char *key="???";
 
       if ((kb1 = find_kbnode (*keyblock, PKT_PUBLIC_KEY)) )
 	key = keystr_from_pk (kb1->pkt->pkt.public_key);
       else if ((kb1 = find_kbnode (*keyblock, PKT_SECRET_KEY)) )
 	key = keystr_from_pk (kb1->pkt->pkt.public_key);
 
       log_info (_("key %s: duplicated subkeys detected - merged\n"), key);
     }
 
   return any;
 }
 
 
 /* Check for a 0x20 revocation from a revocation key that is not
    present.  This may be called without the benefit of merge_xxxx so
    you can't rely on pk->revkey and friends. */
 static void
 revocation_present (ctrl_t ctrl, kbnode_t keyblock)
 {
   kbnode_t onode, inode;
   PKT_public_key *pk = keyblock->pkt->pkt.public_key;
 
   for(onode=keyblock->next;onode;onode=onode->next)
     {
       /* If we reach user IDs, we're done. */
       if(onode->pkt->pkttype==PKT_USER_ID)
 	break;
 
       if (onode->pkt->pkttype == PKT_SIGNATURE
           && IS_KEY_SIG (onode->pkt->pkt.signature)
           && onode->pkt->pkt.signature->revkey)
 	{
 	  int idx;
 	  PKT_signature *sig=onode->pkt->pkt.signature;
 
 	  for(idx=0;idx<sig->numrevkeys;idx++)
 	    {
 	      u32 keyid[2];
 
 	      keyid_from_fingerprint (ctrl, sig->revkey[idx].fpr,
                                       sig->revkey[idx].fprlen, keyid);
 
 	      for(inode=keyblock->next;inode;inode=inode->next)
 		{
 		  /* If we reach user IDs, we're done. */
 		  if(inode->pkt->pkttype==PKT_USER_ID)
 		    break;
 
 		  if (inode->pkt->pkttype == PKT_SIGNATURE
                       && IS_KEY_REV (inode->pkt->pkt.signature)
                       && inode->pkt->pkt.signature->keyid[0]==keyid[0]
                       && inode->pkt->pkt.signature->keyid[1]==keyid[1])
 		    {
 		      /* Okay, we have a revocation key, and a
                        * revocation issued by it.  Do we have the key
                        * itself?  */
                       gpg_error_t err;
 
 		      err = get_pubkey_byfprint_fast (ctrl, NULL,
                                                       sig->revkey[idx].fpr,
                                                       sig->revkey[idx].fprlen);
 		      if (gpg_err_code (err) == GPG_ERR_NO_PUBKEY
                           || gpg_err_code (err) == GPG_ERR_UNUSABLE_PUBKEY)
 			{
 			  char *tempkeystr = xstrdup (keystr_from_pk (pk));
 
 			  /* No, so try and get it */
 			  if ((opt.keyserver_options.options
                                & KEYSERVER_AUTO_KEY_RETRIEVE)
                               && keyserver_any_configured (ctrl))
 			    {
 			      log_info(_("WARNING: key %s may be revoked:"
 					 " fetching revocation key %s\n"),
 				       tempkeystr,keystr(keyid));
 			      keyserver_import_fprint (ctrl,
                                                        sig->revkey[idx].fpr,
                                                        sig->revkey[idx].fprlen,
                                                        opt.keyserver, 0);
 
 			      /* Do we have it now? */
 			      err = get_pubkey_byfprint_fast (ctrl, NULL,
 						     sig->revkey[idx].fpr,
                                                      sig->revkey[idx].fprlen);
 			    }
 
 			  if (gpg_err_code (err) == GPG_ERR_NO_PUBKEY
                               || gpg_err_code (err) == GPG_ERR_UNUSABLE_PUBKEY)
 			    log_info(_("WARNING: key %s may be revoked:"
 				       " revocation key %s not present.\n"),
 				     tempkeystr,keystr(keyid));
 
 			  xfree(tempkeystr);
 			}
 		    }
 		}
 	    }
 	}
     }
 }
 
 
 /*
  * compare and merge the blocks
  *
  * o compare the signatures: If we already have this signature, check
  *   that they compare okay; if not, issue a warning and ask the user.
  * o Simply add the signature.	Can't verify here because we may not have
  *   the signature's public key yet; verification is done when putting it
  *   into the trustdb, which is done automagically as soon as this pubkey
  *   is used.
  * Note: We indicate newly inserted packets with NODE_FLAG_A.
  */
 static int
 merge_blocks (ctrl_t ctrl, unsigned int options,
               kbnode_t keyblock_orig, kbnode_t keyblock,
               u32 *keyid, u32 curtime, int origin, const char *url,
 	      int *n_uids, int *n_sigs, int *n_subk )
 {
   kbnode_t onode, node;
   int rc, found;
 
   /* 1st: handle revocation certificates */
   for (node=keyblock->next; node; node=node->next )
     {
       if (node->pkt->pkttype == PKT_USER_ID )
         break;
       else if (node->pkt->pkttype == PKT_SIGNATURE
                && IS_KEY_REV (node->pkt->pkt.signature))
         {
           /* check whether we already have this */
           found = 0;
           for (onode=keyblock_orig->next; onode; onode=onode->next)
             {
               if (onode->pkt->pkttype == PKT_USER_ID )
                 break;
               else if (onode->pkt->pkttype == PKT_SIGNATURE
                        && IS_KEY_REV (onode->pkt->pkt.signature)
                        && !cmp_signatures(onode->pkt->pkt.signature,
                                           node->pkt->pkt.signature))
                 {
                   found = 1;
                   break;
                 }
 	    }
           if (!found)
             {
               kbnode_t n2 = clone_kbnode(node);
               insert_kbnode( keyblock_orig, n2, 0 );
               n2->flag |= NODE_FLAG_A;
               ++*n_sigs;
               if(!opt.quiet)
                 {
                   char *p = get_user_id_native (ctrl, keyid);
                   log_info(_("key %s: \"%s\" revocation"
                              " certificate added\n"), keystr(keyid),p);
                   xfree(p);
                 }
 	    }
 	}
     }
 
   /* 2nd: merge in any direct key (0x1F) sigs */
   for(node=keyblock->next; node; node=node->next)
     {
       if (node->pkt->pkttype == PKT_USER_ID )
         break;
       else if (node->pkt->pkttype == PKT_SIGNATURE
                && IS_KEY_SIG (node->pkt->pkt.signature))
         {
           /* check whether we already have this */
           found = 0;
           for (onode=keyblock_orig->next; onode; onode=onode->next)
             {
               if (onode->pkt->pkttype == PKT_USER_ID)
                 break;
               else if (onode->pkt->pkttype == PKT_SIGNATURE
                        && IS_KEY_SIG (onode->pkt->pkt.signature)
                        && !cmp_signatures(onode->pkt->pkt.signature,
                                           node->pkt->pkt.signature))
                 {
                   found = 1;
                   break;
 		}
 	    }
           if (!found )
             {
               kbnode_t n2 = clone_kbnode(node);
               insert_kbnode( keyblock_orig, n2, 0 );
               n2->flag |= NODE_FLAG_A;
               ++*n_sigs;
               if(!opt.quiet)
                 log_info( _("key %s: direct key signature added\n"),
                           keystr(keyid));
             }
 	}
     }
 
   /* 3rd: try to merge new certificates in */
   for (onode=keyblock_orig->next; onode; onode=onode->next)
     {
       if (!(onode->flag & NODE_FLAG_A) && onode->pkt->pkttype == PKT_USER_ID)
         {
           /* find the user id in the imported keyblock */
           for (node=keyblock->next; node; node=node->next)
             if (node->pkt->pkttype == PKT_USER_ID
                 && !cmp_user_ids( onode->pkt->pkt.user_id,
                                   node->pkt->pkt.user_id ) )
               break;
           if (node ) /* found: merge */
             {
               rc = merge_sigs (onode, node, n_sigs);
               if (rc )
                 return rc;
 	    }
 	}
     }
 
   /* 4th: add new user-ids */
   for (node=keyblock->next; node; node=node->next)
     {
       if (node->pkt->pkttype == PKT_USER_ID)
         {
           /* do we have this in the original keyblock */
           for (onode=keyblock_orig->next; onode; onode=onode->next )
             if (onode->pkt->pkttype == PKT_USER_ID
                 && !cmp_user_ids( onode->pkt->pkt.user_id,
                                   node->pkt->pkt.user_id ) )
               break;
           if (!onode ) /* this is a new user id: append */
             {
               rc = append_new_uid (options, keyblock_orig, node,
                                    curtime, origin, url, n_sigs);
               if (rc )
                 return rc;
               ++*n_uids;
 	    }
 	}
     }
 
   /* 5th: add new subkeys */
   for (node=keyblock->next; node; node=node->next)
     {
       onode = NULL;
       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
         {
           /* do we have this in the original keyblock? */
           for(onode=keyblock_orig->next; onode; onode=onode->next)
             if (onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
                 && !cmp_public_keys( onode->pkt->pkt.public_key,
                                      node->pkt->pkt.public_key))
               break;
           if (!onode ) /* This is a new subkey: append.  */
             {
               rc = append_key (keyblock_orig, node, n_sigs);
               if (rc)
                 return rc;
               ++*n_subk;
 	    }
 	}
       else if (node->pkt->pkttype == PKT_SECRET_SUBKEY)
         {
           /* do we have this in the original keyblock? */
           for (onode=keyblock_orig->next; onode; onode=onode->next )
             if (onode->pkt->pkttype == PKT_SECRET_SUBKEY
                 && !cmp_public_keys (onode->pkt->pkt.public_key,
                                      node->pkt->pkt.public_key) )
               break;
           if (!onode ) /* This is a new subkey: append.  */
             {
               rc = append_key (keyblock_orig, node, n_sigs);
               if (rc )
                 return rc;
               ++*n_subk;
 	    }
 	}
     }
 
   /* 6th: merge subkey certificates */
   for (onode=keyblock_orig->next; onode; onode=onode->next)
     {
       if (!(onode->flag & NODE_FLAG_A)
           && (onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
               || onode->pkt->pkttype == PKT_SECRET_SUBKEY))
         {
           /* find the subkey in the imported keyblock */
           for(node=keyblock->next; node; node=node->next)
             {
               if ((node->pkt->pkttype == PKT_PUBLIC_SUBKEY
                    || node->pkt->pkttype == PKT_SECRET_SUBKEY)
                   && !cmp_public_keys( onode->pkt->pkt.public_key,
                                        node->pkt->pkt.public_key ) )
                 break;
 	    }
           if (node) /* Found: merge.  */
             {
               rc = merge_keysigs( onode, node, n_sigs);
               if (rc )
                 return rc;
 	    }
 	}
     }
 
   return 0;
 }
 
 
 /* Helper function for merge_blocks.
  *
  * Append the new userid starting with NODE and all signatures to
  * KEYBLOCK.  ORIGIN and URL conveys the usual key origin info.  The
  * integer at N_SIGS is updated with the number of new signatures.
  */
 static gpg_error_t
 append_new_uid (unsigned int options,
                 kbnode_t keyblock, kbnode_t node, u32 curtime,
                 int origin, const char *url, int *n_sigs)
 {
   gpg_error_t err;
   kbnode_t n;
   kbnode_t n_where = NULL;
 
   log_assert (node->pkt->pkttype == PKT_USER_ID);
 
   /* Find the right position for the new user id and its signatures.  */
   for (n = keyblock; n; n_where = n, n = n->next)
     {
       if (n->pkt->pkttype == PKT_PUBLIC_SUBKEY
           || n->pkt->pkttype == PKT_SECRET_SUBKEY )
         break;
     }
   if (!n)
     n_where = NULL;
 
   /* and append/insert */
   while (node)
     {
       /* we add a clone to the original keyblock, because this
        * one is released first. */
       n = clone_kbnode(node);
       if (n->pkt->pkttype == PKT_USER_ID
           && !(options & IMPORT_RESTORE) )
         {
           err = insert_key_origin_uid (n->pkt->pkt.user_id,
                                        curtime, origin, url);
           if (err)
-            return err;
+            {
+              release_kbnode (n);
+              return err;
+            }
         }
 
       if (n_where)
         {
           insert_kbnode( n_where, n, 0 );
           n_where = n;
 	}
       else
         add_kbnode( keyblock, n );
       n->flag |= NODE_FLAG_A;
       node->flag |= NODE_FLAG_A;
       if (n->pkt->pkttype == PKT_SIGNATURE )
         ++*n_sigs;
 
       node = node->next;
       if (node && node->pkt->pkttype != PKT_SIGNATURE )
         break;
     }
 
   return 0;
 }
 
 
 /* Helper function for merge_blocks
  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_USER_ID.
  * (how should we handle comment packets here?)
  */
 static int
 merge_sigs (kbnode_t dst, kbnode_t src, int *n_sigs)
 {
   kbnode_t n, n2;
   int found = 0;
 
   log_assert (dst->pkt->pkttype == PKT_USER_ID);
   log_assert (src->pkt->pkttype == PKT_USER_ID);
 
   for (n=src->next; n && n->pkt->pkttype != PKT_USER_ID; n = n->next)
     {
       if (n->pkt->pkttype != PKT_SIGNATURE )
         continue;
       if (IS_SUBKEY_SIG (n->pkt->pkt.signature)
           || IS_SUBKEY_REV (n->pkt->pkt.signature) )
         continue; /* skip signatures which are only valid on subkeys */
 
       found = 0;
       for (n2=dst->next; n2 && n2->pkt->pkttype != PKT_USER_ID; n2 = n2->next)
         if (!cmp_signatures(n->pkt->pkt.signature,n2->pkt->pkt.signature))
           {
             found++;
             break;
           }
       if (!found )
         {
           /* This signature is new or newer, append N to DST.
            * We add a clone to the original keyblock, because this
            * one is released first */
           n2 = clone_kbnode(n);
           insert_kbnode( dst, n2, PKT_SIGNATURE );
           n2->flag |= NODE_FLAG_A;
           n->flag |= NODE_FLAG_A;
           ++*n_sigs;
 	}
     }
 
   return 0;
 }
 
 
 /* Helper function for merge_blocks
  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_xxx_SUBKEY.
  */
 static int
 merge_keysigs (kbnode_t dst, kbnode_t src, int *n_sigs)
 {
   kbnode_t n, n2;
   int found = 0;
 
   log_assert (dst->pkt->pkttype == PKT_PUBLIC_SUBKEY
               || dst->pkt->pkttype == PKT_SECRET_SUBKEY);
 
   for (n=src->next; n ; n = n->next)
     {
       if (n->pkt->pkttype == PKT_PUBLIC_SUBKEY
           || n->pkt->pkttype == PKT_PUBLIC_KEY )
         break;
       if (n->pkt->pkttype != PKT_SIGNATURE )
         continue;
 
       found = 0;
       for (n2=dst->next; n2; n2 = n2->next)
         {
           if (n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
               || n2->pkt->pkttype == PKT_PUBLIC_KEY )
             break;
           if (n2->pkt->pkttype == PKT_SIGNATURE
               && (n->pkt->pkt.signature->keyid[0]
                   == n2->pkt->pkt.signature->keyid[0])
               && (n->pkt->pkt.signature->keyid[1]
                   == n2->pkt->pkt.signature->keyid[1])
               && (n->pkt->pkt.signature->timestamp
                   <= n2->pkt->pkt.signature->timestamp)
               && (n->pkt->pkt.signature->sig_class
                   == n2->pkt->pkt.signature->sig_class))
             {
               found++;
               break;
 	    }
 	}
       if (!found )
         {
           /* This signature is new or newer, append N to DST.
            * We add a clone to the original keyblock, because this
            * one is released first */
           n2 = clone_kbnode(n);
           insert_kbnode( dst, n2, PKT_SIGNATURE );
           n2->flag |= NODE_FLAG_A;
           n->flag |= NODE_FLAG_A;
           ++*n_sigs;
 	}
     }
 
   return 0;
 }
 
 
 /* Helper function for merge_blocks.
  * Append the subkey starting with NODE and all signatures to KEYBLOCK.
  * Mark all new and copied packets by setting flag bit 0.
  */
 static int
 append_key (kbnode_t keyblock, kbnode_t node, int *n_sigs)
 {
   kbnode_t n;
 
   log_assert (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
               || node->pkt->pkttype == PKT_SECRET_SUBKEY);
 
   while (node)
     {
       /* we add a clone to the original keyblock, because this
        * one is released first */
       n = clone_kbnode(node);
       add_kbnode( keyblock, n );
       n->flag |= NODE_FLAG_A;
       node->flag |= NODE_FLAG_A;
       if (n->pkt->pkttype == PKT_SIGNATURE )
         ++*n_sigs;
 
       node = node->next;
       if (node && node->pkt->pkttype != PKT_SIGNATURE )
         break;
     }
 
   return 0;
 }
diff --git a/g10/keyedit.c b/g10/keyedit.c
index 531d3e128..7255676e7 100644
--- a/g10/keyedit.c
+++ b/g10/keyedit.c
@@ -1,6558 +1,6564 @@
 /* keyedit.c - Edit properties of a key
  * Copyright (C) 1998-2010 Free Software Foundation, Inc.
  * Copyright (C) 1998-2017 Werner Koch
  * Copyright (C) 2015, 2016 g10 Code GmbH
  *
  * 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 <ctype.h>
 #ifdef HAVE_LIBREADLINE
 # define GNUPG_LIBREADLINE_H_INCLUDED
 # include <readline/readline.h>
 #endif
 
 #include "gpg.h"
 #include "options.h"
 #include "packet.h"
 #include "../common/status.h"
 #include "../common/iobuf.h"
 #include "keydb.h"
 #include "photoid.h"
 #include "../common/util.h"
 #include "main.h"
 #include "trustdb.h"
 #include "filter.h"
 #include "../common/ttyio.h"
 #include "../common/status.h"
 #include "../common/i18n.h"
 #include "keyserver-internal.h"
 #include "call-agent.h"
 #include "../common/host2net.h"
 #include "tofu.h"
 #include "key-check.h"
 #include "key-clean.h"
 #include "keyedit.h"
 
 static void show_prefs (PKT_user_id * uid, PKT_signature * selfsig,
 			int verbose);
 static void show_names (ctrl_t ctrl, estream_t fp,
                         kbnode_t keyblock, PKT_public_key * pk,
 			unsigned int flag, int with_prefs);
 static void show_key_with_all_names (ctrl_t ctrl, estream_t fp,
                                      KBNODE keyblock, int only_marked,
 				     int with_revoker, int with_fpr,
 				     int with_subkeys, int with_prefs,
                                      int nowarn);
 static void show_key_and_fingerprint (ctrl_t ctrl,
                                       kbnode_t keyblock, int with_subkeys);
 static void show_key_and_grip (kbnode_t keyblock);
 static void subkey_expire_warning (kbnode_t keyblock);
 static int menu_adduid (ctrl_t ctrl, kbnode_t keyblock,
                         int photo, const char *photo_name, const char *uidstr);
 static void menu_deluid (KBNODE pub_keyblock);
 static int menu_delsig (ctrl_t ctrl, kbnode_t pub_keyblock);
 static int menu_clean (ctrl_t ctrl, kbnode_t keyblock, int self_only);
 static void menu_delkey (KBNODE pub_keyblock);
 static int menu_addrevoker (ctrl_t ctrl, kbnode_t pub_keyblock, int sensitive);
 static gpg_error_t menu_expire (ctrl_t ctrl, kbnode_t pub_keyblock,
                                 int unattended, u32 newexpiration);
 static int menu_changeusage (ctrl_t ctrl, kbnode_t keyblock);
 static int menu_backsign (ctrl_t ctrl, kbnode_t pub_keyblock);
 static int menu_set_primary_uid (ctrl_t ctrl, kbnode_t pub_keyblock);
 static int menu_set_preferences (ctrl_t ctrl, kbnode_t pub_keyblock);
 static int menu_set_keyserver_url (ctrl_t ctrl,
                                    const char *url, kbnode_t pub_keyblock);
 static int menu_set_notation (ctrl_t ctrl,
                               const char *string, kbnode_t pub_keyblock);
 static int menu_select_uid (KBNODE keyblock, int idx);
 static int menu_select_uid_namehash (KBNODE keyblock, const char *namehash);
 static int menu_select_key (KBNODE keyblock, int idx, char *p);
 static int count_uids (KBNODE keyblock);
 static int count_uids_with_flag (KBNODE keyblock, unsigned flag);
 static int count_keys_with_flag (KBNODE keyblock, unsigned flag);
 static int count_selected_uids (KBNODE keyblock);
 static int real_uids_left (KBNODE keyblock);
 static int count_selected_keys (KBNODE keyblock);
 static int menu_revsig (ctrl_t ctrl, kbnode_t keyblock);
 static int menu_revuid (ctrl_t ctrl, kbnode_t keyblock);
 static int core_revuid (ctrl_t ctrl, kbnode_t keyblock, KBNODE node,
                         const struct revocation_reason_info *reason,
                         int *modified);
 static int menu_revkey (ctrl_t ctrl, kbnode_t pub_keyblock);
 static int menu_revsubkey (ctrl_t ctrl, kbnode_t pub_keyblock);
 #ifndef NO_TRUST_MODELS
 static int enable_disable_key (ctrl_t ctrl, kbnode_t keyblock, int disable);
 #endif /*!NO_TRUST_MODELS*/
 static void menu_showphoto (ctrl_t ctrl, kbnode_t keyblock);
 
 static int update_trust = 0;
 
 #define CONTROL_D ('D' - 'A' + 1)
 
 struct sign_attrib
 {
   int non_exportable, non_revocable;
   struct revocation_reason_info *reason;
   byte trust_depth, trust_value;
   char *trust_regexp;
 };
 
 
 
 /* TODO: Fix duplicated code between here and the check-sigs/list-sigs
    code in keylist.c. */
 static int
 print_and_check_one_sig_colon (ctrl_t ctrl, kbnode_t keyblock, kbnode_t node,
 			       int *inv_sigs, int *no_key, int *oth_err,
 			       int *is_selfsig, int print_without_key)
 {
   PKT_signature *sig = node->pkt->pkt.signature;
   int rc, sigrc;
 
   /* TODO: Make sure a cached sig record here still has the pk that
      issued it.  See also keylist.c:list_keyblock_print */
 
   rc = check_key_signature (ctrl, keyblock, node, is_selfsig);
   switch (gpg_err_code (rc))
     {
     case 0:
       node->flag &= ~(NODFLG_BADSIG | NODFLG_NOKEY | NODFLG_SIGERR);
       sigrc = '!';
       break;
     case GPG_ERR_BAD_SIGNATURE:
       node->flag = NODFLG_BADSIG;
       sigrc = '-';
       if (inv_sigs)
 	++ * inv_sigs;
       break;
     case GPG_ERR_NO_PUBKEY:
     case GPG_ERR_UNUSABLE_PUBKEY:
       node->flag = NODFLG_NOKEY;
       sigrc = '?';
       if (no_key)
 	++ * no_key;
       break;
     default:
       node->flag = NODFLG_SIGERR;
       sigrc = '%';
       if (oth_err)
 	++ * oth_err;
       break;
     }
 
   if (sigrc != '?' || print_without_key)
     {
       es_printf ("sig:%c::%d:%08lX%08lX:%lu:%lu:",
                  sigrc, sig->pubkey_algo, (ulong) sig->keyid[0],
                  (ulong) sig->keyid[1], (ulong) sig->timestamp,
                  (ulong) sig->expiredate);
 
       if (sig->trust_depth || sig->trust_value)
 	es_printf ("%d %d", sig->trust_depth, sig->trust_value);
 
       es_printf (":");
 
       if (sig->trust_regexp)
 	es_write_sanitized (es_stdout,
 			    sig->trust_regexp, strlen (sig->trust_regexp),
 			    ":", NULL);
 
       es_printf ("::%02x%c\n", sig->sig_class,
                  sig->flags.exportable ? 'x' : 'l');
 
       if (opt.show_subpackets)
 	print_subpackets_colon (sig);
     }
 
   return (sigrc == '!');
 }
 
 
 /*
  * Print information about a signature (rc is its status), check it
  * and return true if the signature is okay.  NODE must be a signature
  * packet.  With EXTENDED set all possible signature list options will
  * always be printed.
  */
 int
 keyedit_print_one_sig (ctrl_t ctrl, estream_t fp,
                        int rc, kbnode_t keyblock, kbnode_t node,
 		       int *inv_sigs, int *no_key, int *oth_err,
 		       int is_selfsig, int print_without_key, int extended)
 {
   PKT_signature *sig = node->pkt->pkt.signature;
   int sigrc;
   int is_rev = sig->sig_class == 0x30;
 
   /* TODO: Make sure a cached sig record here still has the pk that
      issued it.  See also keylist.c:list_keyblock_print */
 
   switch (gpg_err_code (rc))
     {
     case 0:
       node->flag &= ~(NODFLG_BADSIG | NODFLG_NOKEY | NODFLG_SIGERR);
       sigrc = '!';
       break;
     case GPG_ERR_BAD_SIGNATURE:
       node->flag = NODFLG_BADSIG;
       sigrc = '-';
       if (inv_sigs)
 	++ * inv_sigs;
       break;
     case GPG_ERR_NO_PUBKEY:
     case GPG_ERR_UNUSABLE_PUBKEY:
       node->flag = NODFLG_NOKEY;
       sigrc = '?';
       if (no_key)
 	++ * no_key;
       break;
     default:
       node->flag = NODFLG_SIGERR;
       sigrc = '%';
       if (oth_err)
 	++ * oth_err;
       break;
     }
   if (sigrc != '?' || print_without_key)
     {
       tty_fprintf (fp, "%s%c%c %c%c%c%c%c%c %s %s",
 		  is_rev ? "rev" : "sig", sigrc,
 		  (sig->sig_class - 0x10 > 0 &&
 		   sig->sig_class - 0x10 <
 		   4) ? '0' + sig->sig_class - 0x10 : ' ',
 		  sig->flags.exportable ? ' ' : 'L',
 		  sig->flags.revocable ? ' ' : 'R',
 		  sig->flags.policy_url ? 'P' : ' ',
 		  sig->flags.notation ? 'N' : ' ',
 		  sig->flags.expired ? 'X' : ' ',
 		  (sig->trust_depth > 9) ? 'T' : (sig->trust_depth >
 						  0) ? '0' +
 		  sig->trust_depth : ' ',
                   keystr (sig->keyid),
 		  datestr_from_sig (sig));
       if ((opt.list_options & LIST_SHOW_SIG_EXPIRE) || extended )
 	tty_fprintf (fp, " %s", expirestr_from_sig (sig));
       tty_fprintf (fp, "  ");
       if (sigrc == '%')
 	tty_fprintf (fp, "[%s] ", gpg_strerror (rc));
       else if (sigrc == '?')
 	;
       else if (is_selfsig)
 	{
 	  tty_fprintf (fp, is_rev ? _("[revocation]") : _("[self-signature]"));
           if (extended && sig->flags.chosen_selfsig)
             tty_fprintf (fp, "*");
 	}
       else
 	{
 	  size_t n;
 	  char *p = get_user_id (ctrl, sig->keyid, &n, NULL);
 	  tty_print_utf8_string2 (fp, p, n,
 				  opt.screen_columns - keystrlen () - 26 -
 				  ((opt.
 				    list_options & LIST_SHOW_SIG_EXPIRE) ? 11
 				   : 0));
 	  xfree (p);
 	}
       if (fp == log_get_stream ())
         log_printf ("\n");
       else
         tty_fprintf (fp, "\n");
 
       if (sig->flags.policy_url
           && ((opt.list_options & LIST_SHOW_POLICY_URLS) || extended))
 	show_policy_url (sig, 3, (!fp? -1 : fp == log_get_stream ()? 1 : 0));
 
       if (sig->flags.notation
           && ((opt.list_options & LIST_SHOW_NOTATIONS) || extended))
 	show_notation (sig, 3, (!fp? -1 : fp == log_get_stream ()? 1 : 0),
 		       ((opt.
 			 list_options & LIST_SHOW_STD_NOTATIONS) ? 1 : 0) +
 		       ((opt.
 			 list_options & LIST_SHOW_USER_NOTATIONS) ? 2 : 0));
 
       if (sig->flags.pref_ks
           && ((opt.list_options & LIST_SHOW_KEYSERVER_URLS) || extended))
 	show_keyserver_url (sig, 3, (!fp? -1 : fp == log_get_stream ()? 1 : 0));
 
       if (extended)
         {
           PKT_public_key *pk = keyblock->pkt->pkt.public_key;
           const unsigned char *s;
 
           s = parse_sig_subpkt (sig, 1, SIGSUBPKT_PRIMARY_UID, NULL);
           if (s && *s)
             tty_fprintf (fp, "             [primary]\n");
 
           s = parse_sig_subpkt (sig, 1, SIGSUBPKT_KEY_EXPIRE, NULL);
           if (s && buf32_to_u32 (s))
             tty_fprintf (fp, "             [expires: %s]\n",
                          isotimestamp (pk->timestamp + buf32_to_u32 (s)));
         }
     }
 
   return (sigrc == '!');
 }
 
 
 static int
 print_and_check_one_sig (ctrl_t ctrl, kbnode_t keyblock, kbnode_t node,
 			 int *inv_sigs, int *no_key, int *oth_err,
 			 int *is_selfsig, int print_without_key, int extended)
 {
   int rc;
 
   rc = check_key_signature (ctrl, keyblock, node, is_selfsig);
   return keyedit_print_one_sig (ctrl, NULL, rc,
 				keyblock, node, inv_sigs, no_key, oth_err,
 				*is_selfsig, print_without_key, extended);
 }
 
 
 static int
 sign_mk_attrib (PKT_signature * sig, void *opaque)
 {
   struct sign_attrib *attrib = opaque;
   byte buf[8];
 
   if (attrib->non_exportable)
     {
       buf[0] = 0;		/* not exportable */
       build_sig_subpkt (sig, SIGSUBPKT_EXPORTABLE, buf, 1);
     }
 
   if (attrib->non_revocable)
     {
       buf[0] = 0;		/* not revocable */
       build_sig_subpkt (sig, SIGSUBPKT_REVOCABLE, buf, 1);
     }
 
   if (attrib->reason)
     revocation_reason_build_cb (sig, attrib->reason);
 
   if (attrib->trust_depth)
     {
       /* Not critical.  If someone doesn't understand trust sigs,
          this can still be a valid regular signature. */
       buf[0] = attrib->trust_depth;
       buf[1] = attrib->trust_value;
       build_sig_subpkt (sig, SIGSUBPKT_TRUST, buf, 2);
 
       /* Critical.  If someone doesn't understands regexps, this
          whole sig should be invalid.  Note the +1 for the length -
          regexps are null terminated. */
       if (attrib->trust_regexp)
 	build_sig_subpkt (sig, SIGSUBPKT_FLAG_CRITICAL | SIGSUBPKT_REGEXP,
 			  attrib->trust_regexp,
 			  strlen (attrib->trust_regexp) + 1);
     }
 
   return 0;
 }
 
 
 static void
 trustsig_prompt (byte * trust_value, byte * trust_depth, char **regexp)
 {
   char *p;
 
   *trust_value = 0;
   *trust_depth = 0;
   *regexp = NULL;
 
   /* Same string as pkclist.c:do_edit_ownertrust */
   tty_printf (_
 	      ("Please decide how far you trust this user to correctly verify"
 	       " other users' keys\n(by looking at passports, checking"
 	       " fingerprints from different sources, etc.)\n"));
   tty_printf ("\n");
   tty_printf (_("  %d = I trust marginally\n"), 1);
   tty_printf (_("  %d = I trust fully\n"), 2);
   tty_printf ("\n");
 
   while (*trust_value == 0)
     {
       p = cpr_get ("trustsig_prompt.trust_value", _("Your selection? "));
       trim_spaces (p);
       cpr_kill_prompt ();
       /* 60 and 120 are as per RFC2440 */
       if (p[0] == '1' && !p[1])
 	*trust_value = 60;
       else if (p[0] == '2' && !p[1])
 	*trust_value = 120;
       xfree (p);
     }
 
   tty_printf ("\n");
 
   tty_printf (_("Please enter the depth of this trust signature.\n"
 		"A depth greater than 1 allows the key you are"
                 " signing to make\n"
 		"trust signatures on your behalf.\n"));
   tty_printf ("\n");
 
   while (*trust_depth == 0)
     {
       p = cpr_get ("trustsig_prompt.trust_depth", _("Your selection? "));
       trim_spaces (p);
       cpr_kill_prompt ();
       *trust_depth = atoi (p);
       xfree (p);
     }
 
   tty_printf ("\n");
 
   tty_printf (_("Please enter a domain to restrict this signature, "
 		"or enter for none.\n"));
 
   tty_printf ("\n");
 
   p = cpr_get ("trustsig_prompt.trust_regexp", _("Your selection? "));
   trim_spaces (p);
   cpr_kill_prompt ();
 
   if (strlen (p) > 0)
     {
       char *q = p;
       int regexplen = 100, ind;
 
       *regexp = xmalloc (regexplen);
 
       /* Now mangle the domain the user entered into a regexp.  To do
          this, \-escape everything that isn't alphanumeric, and attach
          "<[^>]+[@.]" to the front, and ">$" to the end. */
 
       strcpy (*regexp, "<[^>]+[@.]");
       ind = strlen (*regexp);
 
       while (*q)
 	{
 	  if (!((*q >= 'A' && *q <= 'Z')
 		|| (*q >= 'a' && *q <= 'z') || (*q >= '0' && *q <= '9')))
 	    (*regexp)[ind++] = '\\';
 
 	  (*regexp)[ind++] = *q;
 
 	  if ((regexplen - ind) < 3)
 	    {
 	      regexplen += 100;
 	      *regexp = xrealloc (*regexp, regexplen);
 	    }
 
 	  q++;
 	}
 
       (*regexp)[ind] = '\0';
       strcat (*regexp, ">$");
     }
 
   xfree (p);
   tty_printf ("\n");
 }
 
 
 /*
  * Loop over all LOCUSR and sign the uids after asking.  If no
  * user id is marked, all user ids will be signed; if some user_ids
  * are marked only those will be signed.  If QUICK is true the
  * function won't ask the user and use sensible defaults.
  */
 static int
 sign_uids (ctrl_t ctrl, estream_t fp,
            kbnode_t keyblock, strlist_t locusr, int *ret_modified,
 	   int local, int nonrevocable, int trust, int interactive,
            int quick)
 {
   int rc = 0;
   SK_LIST sk_list = NULL;
   SK_LIST sk_rover = NULL;
   PKT_public_key *pk = NULL;
   KBNODE node, uidnode;
   PKT_public_key *primary_pk = NULL;
   int select_all = !count_selected_uids (keyblock) || interactive;
 
   /* Build a list of all signators.
    *
    * We use the CERT flag to request the primary which must always
    * be one which is capable of signing keys.  I can't see a reason
    * why to sign keys using a subkey.  Implementation of USAGE_CERT
    * is just a hack in getkey.c and does not mean that a subkey
    * marked as certification capable will be used. */
   rc = build_sk_list (ctrl, locusr, &sk_list, PUBKEY_USAGE_CERT);
   if (rc)
     goto leave;
 
   /* Loop over all signators.  */
   for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
     {
       u32 sk_keyid[2], pk_keyid[2];
       char *p, *trust_regexp = NULL;
       int class = 0, selfsig = 0;
       u32 duration = 0, timestamp = 0;
       byte trust_depth = 0, trust_value = 0;
 
       pk = sk_rover->pk;
       keyid_from_pk (pk, sk_keyid);
 
       /* Set mark A for all selected user ids.  */
       for (node = keyblock; node; node = node->next)
 	{
 	  if (select_all || (node->flag & NODFLG_SELUID))
 	    node->flag |= NODFLG_MARK_A;
 	  else
 	    node->flag &= ~NODFLG_MARK_A;
 	}
 
       /* Reset mark for uids which are already signed.  */
       uidnode = NULL;
       for (node = keyblock; node; node = node->next)
 	{
 	  if (node->pkt->pkttype == PKT_PUBLIC_KEY)
 	    {
 	      primary_pk = node->pkt->pkt.public_key;
 	      keyid_from_pk (primary_pk, pk_keyid);
 
 	      /* Is this a self-sig? */
 	      if (pk_keyid[0] == sk_keyid[0] && pk_keyid[1] == sk_keyid[1])
                 selfsig = 1;
 	    }
 	  else if (node->pkt->pkttype == PKT_USER_ID)
 	    {
 	      uidnode = (node->flag & NODFLG_MARK_A) ? node : NULL;
 	      if (uidnode)
 		{
 		  int yesreally = 0;
 		  char *user;
 
                   user = utf8_to_native (uidnode->pkt->pkt.user_id->name,
                                          uidnode->pkt->pkt.user_id->len, 0);
 
                   if (opt.only_sign_text_ids
                       && uidnode->pkt->pkt.user_id->attribs)
                     {
                       tty_fprintf (fp, _("Skipping user ID \"%s\","
                                          " which is not a text ID.\n"),
                                    user);
                       uidnode->flag &= ~NODFLG_MARK_A;
                       uidnode = NULL;
                     }
 		  else if (uidnode->pkt->pkt.user_id->flags.revoked)
 		    {
 		      tty_fprintf (fp, _("User ID \"%s\" is revoked."), user);
 
 		      if (selfsig)
 			tty_fprintf (fp, "\n");
 		      else if (opt.expert && !quick)
 			{
 			  tty_fprintf (fp, "\n");
 			  /* No, so remove the mark and continue */
 			  if (!cpr_get_answer_is_yes ("sign_uid.revoke_okay",
 						      _("Are you sure you "
 							"still want to sign "
 							"it? (y/N) ")))
 			    {
 			      uidnode->flag &= ~NODFLG_MARK_A;
 			      uidnode = NULL;
 			    }
 			  else if (interactive)
 			    yesreally = 1;
 			}
 		      else
 			{
 			  uidnode->flag &= ~NODFLG_MARK_A;
 			  uidnode = NULL;
 			  tty_fprintf (fp, _("  Unable to sign.\n"));
 			}
 		    }
 		  else if (uidnode->pkt->pkt.user_id->flags.expired)
 		    {
 		      tty_fprintf (fp, _("User ID \"%s\" is expired."), user);
 
 		      if (selfsig)
 			tty_fprintf (fp, "\n");
 		      else if (opt.expert && !quick)
 			{
 			  tty_fprintf (fp, "\n");
 			  /* No, so remove the mark and continue */
 			  if (!cpr_get_answer_is_yes ("sign_uid.expire_okay",
 						      _("Are you sure you "
 							"still want to sign "
 							"it? (y/N) ")))
 			    {
 			      uidnode->flag &= ~NODFLG_MARK_A;
 			      uidnode = NULL;
 			    }
 			  else if (interactive)
 			    yesreally = 1;
 			}
 		      else
 			{
 			  uidnode->flag &= ~NODFLG_MARK_A;
 			  uidnode = NULL;
 			  tty_fprintf (fp, _("  Unable to sign.\n"));
 			}
 		    }
 		  else if (!uidnode->pkt->pkt.user_id->created && !selfsig)
 		    {
 		      tty_fprintf (fp, _("User ID \"%s\" is not self-signed."),
                                    user);
 
 		      if (opt.expert && !quick)
 			{
 			  tty_fprintf (fp, "\n");
 			  /* No, so remove the mark and continue */
 			  if (!cpr_get_answer_is_yes ("sign_uid.nosig_okay",
 						      _("Are you sure you "
 							"still want to sign "
 							"it? (y/N) ")))
 			    {
 			      uidnode->flag &= ~NODFLG_MARK_A;
 			      uidnode = NULL;
 			    }
 			  else if (interactive)
 			    yesreally = 1;
 			}
 		      else
 			{
 			  uidnode->flag &= ~NODFLG_MARK_A;
 			  uidnode = NULL;
 			  tty_fprintf (fp, _("  Unable to sign.\n"));
 			}
 		    }
 
 		  if (uidnode && interactive && !yesreally && !quick)
 		    {
 		      tty_fprintf (fp,
                                    _("User ID \"%s\" is signable.  "), user);
 		      if (!cpr_get_answer_is_yes ("sign_uid.sign_okay",
 						  _("Sign it? (y/N) ")))
 			{
 			  uidnode->flag &= ~NODFLG_MARK_A;
 			  uidnode = NULL;
 			}
 		    }
 
 		  xfree (user);
 		}
 	    }
 	  else if (uidnode && node->pkt->pkttype == PKT_SIGNATURE
 		   && (node->pkt->pkt.signature->sig_class & ~3) == 0x10)
 	    {
 	      if (sk_keyid[0] == node->pkt->pkt.signature->keyid[0]
 		  && sk_keyid[1] == node->pkt->pkt.signature->keyid[1])
 		{
 		  char buf[50];
 		  char *user;
 
                   user = utf8_to_native (uidnode->pkt->pkt.user_id->name,
                                          uidnode->pkt->pkt.user_id->len, 0);
 
 		  /* It's a v3 self-sig.  Make it into a v4 self-sig? */
 		  if (node->pkt->pkt.signature->version < 4
                       && selfsig && !quick)
 		    {
 		      tty_fprintf (fp,
                                    _("The self-signature on \"%s\"\n"
                                      "is a PGP 2.x-style signature.\n"), user);
 
 		      /* Note that the regular PGP2 warning below
 		         still applies if there are no v4 sigs on
 		         this key at all. */
 
 		      if (opt.expert)
 			if (cpr_get_answer_is_yes ("sign_uid.v4_promote_okay",
 						   _("Do you want to promote "
 						     "it to an OpenPGP self-"
 						     "signature? (y/N) ")))
 			  {
 			    node->flag |= NODFLG_DELSIG;
 			    xfree (user);
 			    continue;
 			  }
 		    }
 
 		  /* Is the current signature expired? */
 		  if (node->pkt->pkt.signature->flags.expired)
 		    {
 		      tty_fprintf (fp, _("Your current signature on \"%s\"\n"
                                          "has expired.\n"), user);
 
 		      if (quick || cpr_get_answer_is_yes
 			  ("sign_uid.replace_expired_okay",
 			   _("Do you want to issue a "
 			     "new signature to replace "
 			     "the expired one? (y/N) ")))
 			{
 			  /* Mark these for later deletion.  We
 			     don't want to delete them here, just in
 			     case the replacement signature doesn't
 			     happen for some reason.  We only delete
 			     these after the replacement is already
 			     in place. */
 
 			  node->flag |= NODFLG_DELSIG;
 			  xfree (user);
 			  continue;
 			}
 		    }
 
 		  if (!node->pkt->pkt.signature->flags.exportable && !local)
 		    {
 		      /* It's a local sig, and we want to make a
 		         exportable sig. */
 		      tty_fprintf (fp, _("Your current signature on \"%s\"\n"
                                          "is a local signature.\n"), user);
 
 		      if (quick || cpr_get_answer_is_yes
 			  ("sign_uid.local_promote_okay",
 			   _("Do you want to promote "
 			     "it to a full exportable " "signature? (y/N) ")))
 			{
 			  /* Mark these for later deletion.  We
 			     don't want to delete them here, just in
 			     case the replacement signature doesn't
 			     happen for some reason.  We only delete
 			     these after the replacement is already
 			     in place. */
 
 			  node->flag |= NODFLG_DELSIG;
 			  xfree (user);
 			  continue;
 			}
 		    }
 
 		  /* Fixme: see whether there is a revocation in which
 		   * case we should allow signing it again. */
 		  if (!node->pkt->pkt.signature->flags.exportable && local)
 		    tty_fprintf ( fp,
                        _("\"%s\" was already locally signed by key %s\n"),
                        user, keystr_from_pk (pk));
 		  else
 		    tty_fprintf (fp,
                                 _("\"%s\" was already signed by key %s\n"),
 				user, keystr_from_pk (pk));
 
 		  if (opt.flags.force_sign_key
                       || (opt.expert && !quick
                           && cpr_get_answer_is_yes ("sign_uid.dupe_okay",
                                                     _("Do you want to sign it "
                                                       "again anyway? (y/N) "))))
 		    {
 		      /* Don't delete the old sig here since this is
 		         an --expert thing. */
 		      xfree (user);
 		      continue;
 		    }
 
 		  snprintf (buf, sizeof buf, "%08lX%08lX",
 			    (ulong) pk->keyid[0], (ulong) pk->keyid[1]);
 		  write_status_text (STATUS_ALREADY_SIGNED, buf);
 		  uidnode->flag &= ~NODFLG_MARK_A;	/* remove mark */
 
 		  xfree (user);
 		}
 	    }
 	}
 
       /* Check whether any uids are left for signing.  */
       if (!count_uids_with_flag (keyblock, NODFLG_MARK_A))
 	{
 	  tty_fprintf (fp, _("Nothing to sign with key %s\n"),
 		      keystr_from_pk (pk));
 	  continue;
 	}
 
       /* Ask whether we really should sign these user id(s). */
       tty_fprintf (fp, "\n");
       show_key_with_all_names (ctrl, fp, keyblock, 1, 0, 1, 0, 0, 0);
       tty_fprintf (fp, "\n");
 
       if (primary_pk->expiredate && !selfsig)
 	{
           /* Static analyzer note: A claim that PRIMARY_PK might be
              NULL is not correct because it set from the public key
              packet which is always the first packet in a keyblock and
              parsed in the above loop over the keyblock.  In case the
              keyblock has no packets at all and thus the loop was not
              entered the above count_uids_with_flag would have
              detected this case.  */
 
 	  u32 now = make_timestamp ();
 
 	  if (primary_pk->expiredate <= now)
 	    {
 	      tty_fprintf (fp, _("This key has expired!"));
 
 	      if (opt.expert && !quick)
 		{
 		  tty_fprintf (fp, "  ");
 		  if (!cpr_get_answer_is_yes ("sign_uid.expired_okay",
 					      _("Are you sure you still "
 						"want to sign it? (y/N) ")))
 		    continue;
 		}
 	      else
 		{
 		  tty_fprintf (fp, _("  Unable to sign.\n"));
 		  continue;
 		}
 	    }
 	  else
 	    {
 	      tty_fprintf (fp, _("This key is due to expire on %s.\n"),
                            expirestr_from_pk (primary_pk));
 
 	      if (opt.ask_cert_expire && !quick)
 		{
 		  char *answer = cpr_get ("sign_uid.expire",
 					  _("Do you want your signature to "
 					    "expire at the same time? (Y/n) "));
 		  if (answer_is_yes_no_default (answer, 1))
 		    {
 		      /* This fixes the signature timestamp we're
 		         going to make as now.  This is so the
 		         expiration date is exactly correct, and not
 		         a few seconds off (due to the time it takes
 		         to answer the questions, enter the
 		         passphrase, etc). */
 		      timestamp = now;
 		      duration = primary_pk->expiredate - now;
 		    }
 
 		  cpr_kill_prompt ();
 		  xfree (answer);
 		}
 	    }
 	}
 
       /* Only ask for duration if we haven't already set it to match
          the expiration of the pk */
       if (!duration && !selfsig)
 	{
 	  if (opt.ask_cert_expire && !quick)
 	    duration = ask_expire_interval (1, opt.def_cert_expire);
 	  else
 	    duration = parse_expire_string (opt.def_cert_expire);
 	}
 
       if (selfsig)
 	;
       else
 	{
 	  if (opt.batch || !opt.ask_cert_level || quick)
 	    class = 0x10 + opt.def_cert_level;
 	  else
 	    {
 	      char *answer;
 
 	      tty_fprintf (fp,
                            _("How carefully have you verified the key you are "
 			    "about to sign actually belongs\nto the person "
 			    "named above?  If you don't know what to "
 			    "answer, enter \"0\".\n"));
 	      tty_fprintf (fp, "\n");
 	      tty_fprintf (fp, _("   (0) I will not answer.%s\n"),
 			  opt.def_cert_level == 0 ? " (default)" : "");
 	      tty_fprintf (fp, _("   (1) I have not checked at all.%s\n"),
 			  opt.def_cert_level == 1 ? " (default)" : "");
 	      tty_fprintf (fp, _("   (2) I have done casual checking.%s\n"),
 			  opt.def_cert_level == 2 ? " (default)" : "");
 	      tty_fprintf (fp,
                            _("   (3) I have done very careful checking.%s\n"),
 			  opt.def_cert_level == 3 ? " (default)" : "");
 	      tty_fprintf (fp, "\n");
 
 	      while (class == 0)
 		{
 		  answer = cpr_get ("sign_uid.class",
                                     _("Your selection? "
                                       "(enter '?' for more information): "));
 		  if (answer[0] == '\0')
 		    class = 0x10 + opt.def_cert_level;	/* Default */
 		  else if (ascii_strcasecmp (answer, "0") == 0)
 		    class = 0x10;	/* Generic */
 		  else if (ascii_strcasecmp (answer, "1") == 0)
 		    class = 0x11;	/* Persona */
 		  else if (ascii_strcasecmp (answer, "2") == 0)
 		    class = 0x12;	/* Casual */
 		  else if (ascii_strcasecmp (answer, "3") == 0)
 		    class = 0x13;	/* Positive */
 		  else
 		    tty_fprintf (fp, _("Invalid selection.\n"));
 
 		  xfree (answer);
 		}
 	    }
 
 	  if (trust && !quick)
 	    trustsig_prompt (&trust_value, &trust_depth, &trust_regexp);
 	}
 
       if (!quick)
         {
           p = get_user_id_native (ctrl, sk_keyid);
           tty_fprintf (fp,
                    _("Are you sure that you want to sign this key with your\n"
                      "key \"%s\" (%s)\n"), p, keystr_from_pk (pk));
           xfree (p);
         }
 
       if (selfsig)
 	{
 	  tty_fprintf (fp, "\n");
 	  tty_fprintf (fp, _("This will be a self-signature.\n"));
 
 	  if (local)
 	    {
 	      tty_fprintf (fp, "\n");
 	      tty_fprintf (fp, _("WARNING: the signature will not be marked "
                                  "as non-exportable.\n"));
 	    }
 
 	  if (nonrevocable)
 	    {
 	      tty_fprintf (fp, "\n");
 	      tty_fprintf (fp, _("WARNING: the signature will not be marked "
                                  "as non-revocable.\n"));
 	    }
 	}
       else
 	{
 	  if (local)
 	    {
 	      tty_fprintf (fp, "\n");
 	      tty_fprintf (fp,
                  _("The signature will be marked as non-exportable.\n"));
 	    }
 
 	  if (nonrevocable)
 	    {
 	      tty_fprintf (fp, "\n");
 	      tty_fprintf (fp,
                  _("The signature will be marked as non-revocable.\n"));
 	    }
 
 	  switch (class)
 	    {
 	    case 0x11:
 	      tty_fprintf (fp, "\n");
 	      tty_fprintf (fp, _("I have not checked this key at all.\n"));
 	      break;
 
 	    case 0x12:
 	      tty_fprintf (fp, "\n");
 	      tty_fprintf (fp, _("I have checked this key casually.\n"));
 	      break;
 
 	    case 0x13:
 	      tty_fprintf (fp, "\n");
 	      tty_fprintf (fp, _("I have checked this key very carefully.\n"));
 	      break;
 	    }
 	}
 
       tty_fprintf (fp, "\n");
 
       if (opt.batch && opt.answer_yes)
 	;
       else if (quick)
         ;
       else if (!cpr_get_answer_is_yes ("sign_uid.okay",
 				       _("Really sign? (y/N) ")))
 	continue;
 
       /* Now we can sign the user ids.  */
     reloop:  /* (Must use this, because we are modifying the list.)  */
       primary_pk = NULL;
       for (node = keyblock; node; node = node->next)
 	{
 	  if (node->pkt->pkttype == PKT_PUBLIC_KEY)
 	    primary_pk = node->pkt->pkt.public_key;
 	  else if (node->pkt->pkttype == PKT_USER_ID
 		   && (node->flag & NODFLG_MARK_A))
 	    {
 	      PACKET *pkt;
 	      PKT_signature *sig;
 	      struct sign_attrib attrib;
 
 	      log_assert (primary_pk);
 	      memset (&attrib, 0, sizeof attrib);
 	      attrib.non_exportable = local;
 	      attrib.non_revocable = nonrevocable;
 	      attrib.trust_depth = trust_depth;
 	      attrib.trust_value = trust_value;
 	      attrib.trust_regexp = trust_regexp;
 	      node->flag &= ~NODFLG_MARK_A;
 
 	      /* We force creation of a v4 signature for local
 	       * signatures, otherwise we would not generate the
 	       * subpacket with v3 keys and the signature becomes
 	       * exportable.  */
 
 	      if (selfsig)
 		rc = make_keysig_packet (ctrl, &sig, primary_pk,
 					 node->pkt->pkt.user_id,
 					 NULL,
 					 pk,
 					 0x13,
                                          0, 0,
 					 keygen_add_std_prefs, primary_pk,
                                          NULL);
 	      else
 		rc = make_keysig_packet (ctrl, &sig, primary_pk,
 					 node->pkt->pkt.user_id,
 					 NULL,
 					 pk,
 					 class,
 					 timestamp, duration,
 					 sign_mk_attrib, &attrib,
                                          NULL);
 	      if (rc)
 		{
                   write_status_error ("keysig", rc);
 		  log_error (_("signing failed: %s\n"), gpg_strerror (rc));
 		  goto leave;
 		}
 
 	      *ret_modified = 1;	/* We changed the keyblock. */
 	      update_trust = 1;
 
 	      pkt = xmalloc_clear (sizeof *pkt);
 	      pkt->pkttype = PKT_SIGNATURE;
 	      pkt->pkt.signature = sig;
 	      insert_kbnode (node, new_kbnode (pkt), PKT_SIGNATURE);
 	      goto reloop;
 	    }
 	}
 
       /* Delete any sigs that got promoted */
       for (node = keyblock; node; node = node->next)
 	if (node->flag & NODFLG_DELSIG)
 	  delete_kbnode (node);
     } /* End loop over signators.  */
 
  leave:
   release_sk_list (sk_list);
   return rc;
 }
 
 
 /*
  * Change the passphrase of the primary and all secondary keys.  Note
  * that it is common to use only one passphrase for the primary and
  * all subkeys.  However, this is now (since GnuPG 2.1) all up to the
  * gpg-agent.  Returns 0 on success or an error code.
  */
 static gpg_error_t
 change_passphrase (ctrl_t ctrl, kbnode_t keyblock)
 {
   gpg_error_t err;
   kbnode_t node;
   PKT_public_key *pk;
   int any;
   u32 keyid[2], subid[2];
   char *hexgrip = NULL;
   char *cache_nonce = NULL;
   char *passwd_nonce = NULL;
 
   node = find_kbnode (keyblock, PKT_PUBLIC_KEY);
   if (!node)
     {
       log_error ("Oops; public key missing!\n");
       err = gpg_error (GPG_ERR_INTERNAL);
       goto leave;
     }
   pk = node->pkt->pkt.public_key;
   keyid_from_pk (pk, keyid);
 
   /* Check whether it is likely that we will be able to change the
      passphrase for any subkey.  */
   for (any = 0, node = keyblock; node; node = node->next)
     {
       if (node->pkt->pkttype == PKT_PUBLIC_KEY
 	  || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
 	{
           char *serialno;
 
           pk = node->pkt->pkt.public_key;
           keyid_from_pk (pk, subid);
 
           xfree (hexgrip);
           err = hexkeygrip_from_pk (pk, &hexgrip);
           if (err)
             goto leave;
           err = agent_get_keyinfo (ctrl, hexgrip, &serialno, NULL);
           if (!err && serialno)
             ; /* Key on card.  */
           else if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
             ; /* Maybe stub key. */
           else if (!err)
             any = 1; /* Key is known.  */
           else
             log_error ("key %s: error getting keyinfo from agent: %s\n",
                        keystr_with_sub (keyid, subid), gpg_strerror (err));
           xfree (serialno);
 	}
     }
   err = 0;
   if (!any)
     {
       tty_printf (_("Key has only stub or on-card key items - "
 		    "no passphrase to change.\n"));
       goto leave;
     }
 
   /* Change the passphrase for all keys.  */
   for (node = keyblock; node; node = node->next)
     {
       if (node->pkt->pkttype == PKT_PUBLIC_KEY
 	  || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
         {
           char *desc;
 
           pk = node->pkt->pkt.public_key;
           keyid_from_pk (pk, subid);
 
           xfree (hexgrip);
           err = hexkeygrip_from_pk (pk, &hexgrip);
           if (err)
             goto leave;
 
           /* Note that when using --dry-run we don't change the
            * passphrase but merely verify the current passphrase.  */
           desc = gpg_format_keydesc (ctrl, pk, FORMAT_KEYDESC_NORMAL, 1);
           err = agent_passwd (ctrl, hexgrip, desc, !!opt.dry_run,
                               &cache_nonce, &passwd_nonce);
           xfree (desc);
 
           if (err)
             log_log ((gpg_err_code (err) == GPG_ERR_CANCELED
                       || gpg_err_code (err) == GPG_ERR_FULLY_CANCELED)
                      ? GPGRT_LOGLVL_INFO : GPGRT_LOGLVL_ERROR,
                      _("key %s: error changing passphrase: %s\n"),
                        keystr_with_sub (keyid, subid),
                        gpg_strerror (err));
           if (gpg_err_code (err) == GPG_ERR_FULLY_CANCELED)
             break;
         }
     }
 
  leave:
   xfree (hexgrip);
   xfree (cache_nonce);
   xfree (passwd_nonce);
   return err;
 }
 
 
 
 /* Fix various problems in the keyblock.  Returns true if the keyblock
    was changed.  Note that a pointer to the keyblock must be given and
    the function may change it (i.e. replacing the first node).  */
 static int
 fix_keyblock (ctrl_t ctrl, kbnode_t *keyblockp)
 {
   int changed = 0;
 
   if (collapse_uids (keyblockp))
     changed++;
   if (collapse_subkeys (keyblockp))
     changed++;
   if (key_check_all_keysigs (ctrl, 1, *keyblockp, 0, 1))
     changed++;
   reorder_keyblock (*keyblockp);
   /* If we modified the keyblock, make sure the flags are right. */
   if (changed)
     merge_keys_and_selfsig (ctrl, *keyblockp);
 
   return changed;
 }
 
 
 static int
 parse_sign_type (const char *str, int *localsig, int *nonrevokesig,
 		 int *trustsig)
 {
   const char *p = str;
 
   while (*p)
     {
       if (ascii_strncasecmp (p, "l", 1) == 0)
 	{
 	  *localsig = 1;
 	  p++;
 	}
       else if (ascii_strncasecmp (p, "nr", 2) == 0)
 	{
 	  *nonrevokesig = 1;
 	  p += 2;
 	}
       else if (ascii_strncasecmp (p, "t", 1) == 0)
 	{
 	  *trustsig = 1;
 	  p++;
 	}
       else
 	return 0;
     }
 
   return 1;
 }
 
 
 
 /*
  * Menu driven key editor.  If seckey_check is true, then a secret key
  * that matches username will be looked for.  If it is false, not all
  * commands will be available.
  *
  * Note: to keep track of certain selections we use node->mark MARKBIT_xxxx.
  */
 
 /* Need an SK for this command */
 #define KEYEDIT_NEED_SK 1
 /* Need an SUB KEY for this command */
 #define KEYEDIT_NEED_SUBSK 2
 /* Match the tail of the string */
 #define KEYEDIT_TAIL_MATCH 8
 
 enum cmdids
 {
   cmdNONE = 0,
   cmdQUIT, cmdHELP, cmdFPR, cmdLIST, cmdSELUID, cmdCHECK, cmdSIGN,
   cmdREVSIG, cmdREVKEY, cmdREVUID, cmdDELSIG, cmdPRIMARY, cmdDEBUG,
   cmdSAVE, cmdADDUID, cmdADDPHOTO, cmdDELUID, cmdADDKEY, cmdDELKEY,
   cmdADDREVOKER, cmdTOGGLE, cmdSELKEY, cmdPASSWD, cmdTRUST, cmdPREF,
   cmdEXPIRE, cmdCHANGEUSAGE, cmdBACKSIGN,
 #ifndef NO_TRUST_MODELS
   cmdENABLEKEY, cmdDISABLEKEY,
 #endif /*!NO_TRUST_MODELS*/
   cmdSHOWPREF,
   cmdSETPREF, cmdPREFKS, cmdNOTATION, cmdINVCMD, cmdSHOWPHOTO, cmdUPDTRUST,
   cmdCHKTRUST, cmdADDCARDKEY, cmdKEYTOCARD, cmdKEYTOTPM, cmdBKUPTOCARD,
   cmdCLEAN, cmdMINIMIZE, cmdGRIP, cmdNOP
 };
 
 static struct
 {
   const char *name;
   enum cmdids id;
   int flags;
   const char *desc;
 } cmds[] =
 {
   { "quit", cmdQUIT, 0, N_("quit this menu")},
   { "q", cmdQUIT, 0, NULL},
   { "save", cmdSAVE, 0, N_("save and quit")},
   { "help", cmdHELP, 0, N_("show this help")},
   { "?", cmdHELP, 0, NULL},
   { "fpr", cmdFPR, 0, N_("show key fingerprint")},
   { "grip", cmdGRIP, 0, N_("show the keygrip")},
   { "list", cmdLIST, 0, N_("list key and user IDs")},
   { "l", cmdLIST, 0, NULL},
   { "uid", cmdSELUID, 0, N_("select user ID N")},
   { "key", cmdSELKEY, 0, N_("select subkey N")},
   { "check", cmdCHECK, 0, N_("check signatures")},
   { "c", cmdCHECK, 0, NULL},
   { "change-usage", cmdCHANGEUSAGE, KEYEDIT_NEED_SK, NULL},
   { "cross-certify", cmdBACKSIGN, KEYEDIT_NEED_SK, NULL},
   { "backsign", cmdBACKSIGN,  KEYEDIT_NEED_SK, NULL},
   { "sign", cmdSIGN,  KEYEDIT_TAIL_MATCH,
     N_("sign selected user IDs [* see below for related commands]")},
   { "s", cmdSIGN, 0, NULL},
     /* "lsign" and friends will never match since "sign" comes first
        and it is a tail match.  They are just here so they show up in
        the help menu. */
   { "lsign", cmdNOP, 0, N_("sign selected user IDs locally")},
   { "tsign", cmdNOP, 0, N_("sign selected user IDs with a trust signature")},
   { "nrsign", cmdNOP, 0,
     N_("sign selected user IDs with a non-revocable signature")},
   { "debug", cmdDEBUG, 0, NULL},
   { "adduid", cmdADDUID,  KEYEDIT_NEED_SK, N_("add a user ID")},
   { "addphoto", cmdADDPHOTO,  KEYEDIT_NEED_SK,
     N_("add a photo ID")},
   { "deluid", cmdDELUID, 0, N_("delete selected user IDs")},
     /* delphoto is really deluid in disguise */
   { "delphoto", cmdDELUID, 0, NULL},
   { "addkey", cmdADDKEY,  KEYEDIT_NEED_SK, N_("add a subkey")},
 #ifdef ENABLE_CARD_SUPPORT
   { "addcardkey", cmdADDCARDKEY,  KEYEDIT_NEED_SK,
     N_("add a key to a smartcard")},
   { "keytocard", cmdKEYTOCARD, KEYEDIT_NEED_SK | KEYEDIT_NEED_SUBSK,
     N_("move a key to a smartcard")},
   { "keytotpm", cmdKEYTOTPM, KEYEDIT_NEED_SK | KEYEDIT_NEED_SUBSK,
     N_("convert a key to TPM form using the local TPM")},
   { "bkuptocard", cmdBKUPTOCARD, KEYEDIT_NEED_SK | KEYEDIT_NEED_SUBSK,
     N_("move a backup key to a smartcard")},
 #endif /*ENABLE_CARD_SUPPORT */
   { "delkey", cmdDELKEY, 0, N_("delete selected subkeys")},
   { "addrevoker", cmdADDREVOKER,  KEYEDIT_NEED_SK,
     N_("add a revocation key")},
   { "delsig", cmdDELSIG, 0,
     N_("delete signatures from the selected user IDs")},
   { "expire", cmdEXPIRE,  KEYEDIT_NEED_SK | KEYEDIT_NEED_SUBSK,
     N_("change the expiration date for the key or selected subkeys")},
   { "primary", cmdPRIMARY,  KEYEDIT_NEED_SK,
     N_("flag the selected user ID as primary")},
   { "toggle", cmdTOGGLE, KEYEDIT_NEED_SK, NULL},  /* Dummy command.  */
   { "t", cmdTOGGLE, KEYEDIT_NEED_SK, NULL},
   { "pref", cmdPREF, 0, N_("list preferences (expert)")},
   { "showpref", cmdSHOWPREF, 0, N_("list preferences (verbose)")},
   { "setpref", cmdSETPREF,  KEYEDIT_NEED_SK,
     N_("set preference list for the selected user IDs")},
   { "updpref", cmdSETPREF,  KEYEDIT_NEED_SK, NULL},
   { "keyserver", cmdPREFKS,  KEYEDIT_NEED_SK,
     N_("set the preferred keyserver URL for the selected user IDs")},
   { "notation", cmdNOTATION,  KEYEDIT_NEED_SK,
     N_("set a notation for the selected user IDs")},
   { "passwd", cmdPASSWD,  KEYEDIT_NEED_SK | KEYEDIT_NEED_SUBSK,
     N_("change the passphrase")},
   { "password", cmdPASSWD,  KEYEDIT_NEED_SK | KEYEDIT_NEED_SUBSK, NULL},
 #ifndef NO_TRUST_MODELS
   { "trust", cmdTRUST, 0, N_("change the ownertrust")},
 #endif /*!NO_TRUST_MODELS*/
   { "revsig", cmdREVSIG, 0,
     N_("revoke signatures on the selected user IDs")},
   { "revuid", cmdREVUID,  KEYEDIT_NEED_SK,
     N_("revoke selected user IDs")},
   { "revphoto", cmdREVUID,  KEYEDIT_NEED_SK, NULL},
   { "revkey", cmdREVKEY,  KEYEDIT_NEED_SK,
     N_("revoke key or selected subkeys")},
 #ifndef NO_TRUST_MODELS
   { "enable", cmdENABLEKEY, 0, N_("enable key")},
   { "disable", cmdDISABLEKEY, 0, N_("disable key")},
 #endif /*!NO_TRUST_MODELS*/
   { "showphoto", cmdSHOWPHOTO, 0, N_("show selected photo IDs")},
   { "clean", cmdCLEAN, 0,
     N_("compact unusable user IDs and remove unusable signatures from key")},
   { "minimize", cmdMINIMIZE, 0,
     N_("compact unusable user IDs and remove all signatures from key")},
 
   { NULL, cmdNONE, 0, NULL}
 };
 
 
 
 #ifdef HAVE_LIBREADLINE
 
 /*
    These two functions are used by readline for command completion.
  */
 
 static char *
 command_generator (const char *text, int state)
 {
   static int list_index, len;
   const char *name;
 
   /* If this is a new word to complete, initialize now.  This includes
      saving the length of TEXT for efficiency, and initializing the
      index variable to 0. */
   if (!state)
     {
       list_index = 0;
       len = strlen (text);
     }
 
   /* Return the next partial match */
   while ((name = cmds[list_index].name))
     {
       /* Only complete commands that have help text */
       if (cmds[list_index++].desc && strncmp (name, text, len) == 0)
 	return strdup (name);
     }
 
   return NULL;
 }
 
 static char **
 keyedit_completion (const char *text, int start, int end)
 {
   /* If we are at the start of a line, we try and command-complete.
      If not, just do nothing for now. */
 
   (void) end;
 
   if (start == 0)
     return rl_completion_matches (text, command_generator);
 
   rl_attempted_completion_over = 1;
 
   return NULL;
 }
 #endif /* HAVE_LIBREADLINE */
 
 
 
 /* Main function of the menu driven key editor.  */
 void
 keyedit_menu (ctrl_t ctrl, const char *username, strlist_t locusr,
 	      strlist_t commands, int quiet, int seckey_check)
 {
   enum cmdids cmd = 0;
   gpg_error_t err = 0;
   KBNODE keyblock = NULL;
   KEYDB_HANDLE kdbhd = NULL;
   int have_seckey = 0;
   int have_anyseckey = 0;
   char *answer = NULL;
   int redisplay = 1;
   int modified = 0;
   int sec_shadowing = 0;
   int run_subkey_warnings = 0;
   int have_commands = !!commands;
 
   if (opt.command_fd != -1)
     ;
   else if (opt.batch && !have_commands)
     {
       log_error (_("can't do this in batch mode\n"));
       goto leave;
     }
 
 #ifdef HAVE_W32_SYSTEM
   /* Due to Windows peculiarities we need to make sure that the
      trustdb stale check is done before we open another file
      (i.e. by searching for a key).  In theory we could make sure
      that the files are closed after use but the open/close caches
      inhibits that and flushing the cache right before the stale
      check is not easy to implement.  Thus we take the easy way out
      and run the stale check as early as possible.  Note, that for
      non- W32 platforms it is run indirectly trough a call to
      get_validity ().  */
   check_trustdb_stale (ctrl);
 #endif
 
   /* Get the public key */
   err = get_pubkey_byname (ctrl, GET_PUBKEY_NO_AKL,
                            NULL, NULL, username, &keyblock, &kdbhd, 1);
   if (err)
     {
       log_error (_("key \"%s\" not found: %s\n"), username, gpg_strerror (err));
       goto leave;
     }
 
   if (fix_keyblock (ctrl, &keyblock))
     modified++;
 
   /* See whether we have a matching secret key.  */
   if (seckey_check)
     {
       have_anyseckey = !agent_probe_any_secret_key (ctrl, keyblock);
       if (have_anyseckey
           && agent_probe_secret_key (ctrl, keyblock->pkt->pkt.public_key))
         {
           /* The primary key is also available.   */
           have_seckey = 1;
         }
 
       if (have_seckey && !quiet)
         tty_printf (_("Secret key is available.\n"));
       else if (have_anyseckey && !quiet)
         tty_printf (_("Secret subkeys are available.\n"));
     }
 
   /* Main command loop.  */
   for (;;)
     {
       int i, arg_number, photo;
       const char *arg_string = "";
       char *p;
       PKT_public_key *pk = keyblock->pkt->pkt.public_key;
 
       tty_printf ("\n");
 
       if (redisplay && !quiet)
 	{
           /* Show using flags: with_revoker, with_subkeys.  */
 	  show_key_with_all_names (ctrl, NULL, keyblock, 0, 1, 0, 1, 0, 0);
 	  tty_printf ("\n");
 	  redisplay = 0;
 	}
 
       if (run_subkey_warnings)
         {
           run_subkey_warnings = 0;
           if (!count_selected_keys (keyblock))
             subkey_expire_warning (keyblock);
         }
 
       do
 	{
 	  xfree (answer);
 	  if (have_commands)
 	    {
 	      if (commands)
 		{
 		  answer = xstrdup (commands->d);
 		  commands = commands->next;
 		}
 	      else if (opt.batch)
 		{
 		  answer = xstrdup ("quit");
 		}
 	      else
 		have_commands = 0;
 	    }
 	  if (!have_commands)
 	    {
 #ifdef HAVE_LIBREADLINE
 	      tty_enable_completion (keyedit_completion);
 #endif
 	      answer = cpr_get_no_help ("keyedit.prompt", GPG_NAME "> ");
 	      cpr_kill_prompt ();
 	      tty_disable_completion ();
 	    }
 	  trim_spaces (answer);
 	}
       while (*answer == '#');
 
       arg_number = 0; /* Here is the init which egcc complains about.  */
       photo = 0;      /* Same here. */
       if (!*answer)
 	cmd = cmdLIST;
       else if (*answer == CONTROL_D)
 	cmd = cmdQUIT;
       else if (digitp (answer))
 	{
 	  cmd = cmdSELUID;
 	  arg_number = atoi (answer);
 	}
       else
 	{
 	  if ((p = strchr (answer, ' ')))
 	    {
 	      *p++ = 0;
 	      trim_spaces (answer);
 	      trim_spaces (p);
 	      arg_number = atoi (p);
 	      arg_string = p;
 	    }
 
 	  for (i = 0; cmds[i].name; i++)
 	    {
 	      if (cmds[i].flags & KEYEDIT_TAIL_MATCH)
 		{
 		  size_t l = strlen (cmds[i].name);
 		  size_t a = strlen (answer);
 		  if (a >= l)
 		    {
 		      if (!ascii_strcasecmp (&answer[a - l], cmds[i].name))
 			{
 			  answer[a - l] = '\0';
 			  break;
 			}
 		    }
 		}
 	      else if (!ascii_strcasecmp (answer, cmds[i].name))
 		break;
 	    }
 	  if ((cmds[i].flags & (KEYEDIT_NEED_SK|KEYEDIT_NEED_SUBSK))
               && !(((cmds[i].flags & KEYEDIT_NEED_SK) && have_seckey)
                    || ((cmds[i].flags & KEYEDIT_NEED_SUBSK) && have_anyseckey)))
 	    {
 	      tty_printf (_("Need the secret key to do this.\n"));
 	      cmd = cmdNOP;
 	    }
           else
 	    cmd = cmds[i].id;
 	}
 
       /* Dispatch the command.  */
       switch (cmd)
 	{
 	case cmdHELP:
 	  for (i = 0; cmds[i].name; i++)
 	    {
               if ((cmds[i].flags & (KEYEDIT_NEED_SK|KEYEDIT_NEED_SUBSK))
                   && !(((cmds[i].flags & KEYEDIT_NEED_SK) && have_seckey)
                        ||((cmds[i].flags&KEYEDIT_NEED_SUBSK)&&have_anyseckey)))
 		; /* Skip those item if we do not have the secret key.  */
 	      else if (cmds[i].desc)
 		tty_printf ("%-11s %s\n", cmds[i].name, _(cmds[i].desc));
 	    }
 
 	  tty_printf ("\n");
 	  tty_printf
             (_("* The 'sign' command may be prefixed with an 'l' for local "
                "signatures (lsign),\n"
                "  a 't' for trust signatures (tsign), an 'nr' for "
                "non-revocable signatures\n"
                "  (nrsign), or any combination thereof (ltsign, "
                "tnrsign, etc.).\n"));
 	  break;
 
 	case cmdLIST:
 	  redisplay = 1;
 	  break;
 
 	case cmdFPR:
 	  show_key_and_fingerprint
             (ctrl,
              keyblock, (*arg_string == '*'
                         && (!arg_string[1] || spacep (arg_string + 1))));
 	  break;
 
 	case cmdGRIP:
 	  show_key_and_grip (keyblock);
 	  break;
 
 	case cmdSELUID:
 	  if (strlen (arg_string) == NAMEHASH_LEN * 2)
 	    redisplay = menu_select_uid_namehash (keyblock, arg_string);
 	  else
 	    {
 	      if (*arg_string == '*'
 		  && (!arg_string[1] || spacep (arg_string + 1)))
 		arg_number = -1;	/* Select all. */
 	      redisplay = menu_select_uid (keyblock, arg_number);
 	    }
 	  break;
 
 	case cmdSELKEY:
 	  {
 	    if (*arg_string == '*'
 		&& (!arg_string[1] || spacep (arg_string + 1)))
 	      arg_number = -1;	/* Select all. */
 	    if (menu_select_key (keyblock, arg_number, p))
 	      redisplay = 1;
 	  }
 	  break;
 
 	case cmdCHECK:
 	  if (key_check_all_keysigs (ctrl, -1, keyblock,
 				     count_selected_uids (keyblock),
 				     !strcmp (arg_string, "selfsig")))
             modified = 1;
 	  break;
 
 	case cmdSIGN:
 	  {
 	    int localsig = 0, nonrevokesig = 0, trustsig = 0, interactive = 0;
 
 	    if (pk->flags.revoked)
 	      {
 		tty_printf (_("Key is revoked."));
 
 		if (opt.expert)
 		  {
 		    tty_printf ("  ");
 		    if (!cpr_get_answer_is_yes
                         ("keyedit.sign_revoked.okay",
                          _("Are you sure you still want to sign it? (y/N) ")))
 		      break;
 		  }
 		else
 		  {
 		    tty_printf (_("  Unable to sign.\n"));
 		    break;
 		  }
 	      }
 
 	    if (count_uids (keyblock) > 1 && !count_selected_uids (keyblock))
               {
                 int result;
                 if (opt.only_sign_text_ids)
                   result = cpr_get_answer_is_yes
                     ("keyedit.sign_all.okay",
                      _("Really sign all text user IDs? (y/N) "));
                 else
                   result = cpr_get_answer_is_yes
                     ("keyedit.sign_all.okay",
                      _("Really sign all user IDs? (y/N) "));
 
                 if (! result)
                   {
                     if (opt.interactive)
                       interactive = 1;
                     else
                       {
                         tty_printf (_("Hint: Select the user IDs to sign\n"));
                         have_commands = 0;
                         break;
                       }
 
                   }
               }
 	    /* What sort of signing are we doing? */
 	    if (!parse_sign_type
 		(answer, &localsig, &nonrevokesig, &trustsig))
 	      {
 		tty_printf (_("Unknown signature type '%s'\n"), answer);
 		break;
 	      }
 
 	    sign_uids (ctrl, NULL, keyblock, locusr, &modified,
 		       localsig, nonrevokesig, trustsig, interactive, 0);
 	  }
 	  break;
 
 	case cmdDEBUG:
 	  dump_kbnode (keyblock);
 	  break;
 
 	case cmdTOGGLE:
           /* The toggle command is a leftover from old gpg versions
              where we worked with a secret and a public keyring.  It
              is not necessary anymore but we keep this command for the
              sake of scripts using it.  */
 	  redisplay = 1;
 	  break;
 
 	case cmdADDPHOTO:
 	  if (RFC2440)
 	    {
 	      tty_printf (_("This command is not allowed while in %s mode.\n"),
 			  gnupg_compliance_option_string (opt.compliance));
 	      break;
 	    }
 	  photo = 1;
 	  /* fall through */
 	case cmdADDUID:
 	  if (menu_adduid (ctrl, keyblock, photo, arg_string, NULL))
 	    {
 	      update_trust = 1;
 	      redisplay = 1;
 	      modified = 1;
 	      merge_keys_and_selfsig (ctrl, keyblock);
 	    }
 	  break;
 
 	case cmdDELUID:
 	  {
 	    int n1;
 
 	    if (!(n1 = count_selected_uids (keyblock)))
               {
                 tty_printf (_("You must select at least one user ID.\n"));
                 if (!opt.expert)
                   tty_printf (_("(Use the '%s' command.)\n"), "uid");
               }
 	    else if (real_uids_left (keyblock) < 1)
 	      tty_printf (_("You can't delete the last user ID!\n"));
 	    else if (cpr_get_answer_is_yes
                      ("keyedit.remove.uid.okay",
                       n1 > 1 ? _("Really remove all selected user IDs? (y/N) ")
                       :        _("Really remove this user ID? (y/N) ")))
 	      {
 		menu_deluid (keyblock);
 		redisplay = 1;
 		modified = 1;
 	      }
 	  }
 	  break;
 
 	case cmdDELSIG:
 	  {
 	    int n1;
 
 	    if (!(n1 = count_selected_uids (keyblock)))
               {
                 tty_printf (_("You must select at least one user ID.\n"));
                 if (!opt.expert)
                   tty_printf (_("(Use the '%s' command.)\n"), "uid");
               }
 	    else if (menu_delsig (ctrl, keyblock))
 	      {
 		/* No redisplay here, because it may scroll away some
 		 * of the status output of this command.  */
 		modified = 1;
 	      }
 	  }
 	  break;
 
 	case cmdADDKEY:
 	  if (!generate_subkeypair (ctrl, keyblock, NULL, NULL, NULL))
 	    {
 	      redisplay = 1;
 	      modified = 1;
 	      merge_keys_and_selfsig (ctrl, keyblock);
 	    }
 	  break;
 
 #ifdef ENABLE_CARD_SUPPORT
 	case cmdADDCARDKEY:
 	  if (!card_generate_subkey (ctrl, keyblock))
 	    {
 	      redisplay = 1;
 	      modified = 1;
 	      merge_keys_and_selfsig (ctrl, keyblock);
 	    }
 	  break;
 
 	case cmdKEYTOTPM:
 	  /* FIXME need to store the key and not commit until later */
 	  {
 	    kbnode_t node = NULL;
 	    switch (count_selected_keys (keyblock))
 	      {
 	      case 0:
 		if (cpr_get_answer_is_yes
                     ("keyedit.keytocard.use_primary",
                      /* TRANSLATORS: Please take care: This is about
                         moving the key and not about removing it.  */
                      _("Really move the primary key? (y/N) ")))
 		  node = keyblock;
 		break;
 	      case 1:
 		for (node = keyblock; node; node = node->next)
 		  {
 		    if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
 			&& node->flag & NODFLG_SELKEY)
 		      break;
 		  }
 		break;
 	      default:
 		tty_printf (_("You must select exactly one key.\n"));
 		break;
 	      }
 	    if (node)
 	      {
 		PKT_public_key *xxpk = node->pkt->pkt.public_key;
 		char *hexgrip;
 
 		hexkeygrip_from_pk (xxpk, &hexgrip);
 		if (!agent_keytotpm (ctrl, hexgrip))
 		  {
 		    redisplay = 1;
 		  }
 		xfree (hexgrip);
 	      }
 	  }
 	  break;
 
 	case cmdKEYTOCARD:
 	  {
 	    KBNODE node = NULL;
 	    switch (count_selected_keys (keyblock))
 	      {
 	      case 0:
 		if (cpr_get_answer_is_yes
                     ("keyedit.keytocard.use_primary",
                      /* TRANSLATORS: Please take care: This is about
                         moving the key and not about removing it.  */
                      _("Really move the primary key? (y/N) ")))
 		  node = keyblock;
 		break;
 	      case 1:
 		for (node = keyblock; node; node = node->next)
 		  {
 		    if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
 			&& node->flag & NODFLG_SELKEY)
 		      break;
 		  }
 		break;
 	      default:
 		tty_printf (_("You must select exactly one key.\n"));
 		break;
 	      }
 	    if (node)
 	      {
 		PKT_public_key *xxpk = node->pkt->pkt.public_key;
 		if (card_store_subkey (node, xxpk ? xxpk->pubkey_usage : 0))
 		  {
 		    redisplay = 1;
 		    sec_shadowing = 1;
 		  }
 	      }
 	  }
 	  break;
 
 	case cmdBKUPTOCARD:
 	  {
 	    /* Ask for a filename, check whether this is really a
 	       backup key as generated by the card generation, parse
 	       that key and store it on card. */
 	    KBNODE node;
 	    char *fname;
 	    PACKET *pkt;
 	    IOBUF a;
             struct parse_packet_ctx_s parsectx;
 
             if (!*arg_string)
 	      {
 		tty_printf (_("Command expects a filename argument\n"));
 		break;
 	      }
 
             if (*arg_string == DIRSEP_C)
               fname = xstrdup (arg_string);
             else if (*arg_string == '~')
               fname = make_filename (arg_string, NULL);
             else
               fname = make_filename (gnupg_homedir (), arg_string, NULL);
 
 	    /* Open that file.  */
 	    a = iobuf_open (fname);
 	    if (a && is_secured_file (iobuf_get_fd (a)))
 	      {
 		iobuf_close (a);
 		a = NULL;
 		gpg_err_set_errno (EPERM);
 	      }
             if (!a)
               {
                 tty_printf (_("Can't open '%s': %s\n"),
                             fname, strerror (errno));
                 xfree (fname);
                 break;
               }
 
 	    /* Parse and check that file.  */
 	    pkt = xmalloc (sizeof *pkt);
 	    init_packet (pkt);
             init_parse_packet (&parsectx, a);
 	    err = parse_packet (&parsectx, pkt);
 	    deinit_parse_packet (&parsectx);
             iobuf_close (a);
 	    iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char *) fname);
 	    if (!err && pkt->pkttype != PKT_SECRET_KEY
 		&& pkt->pkttype != PKT_SECRET_SUBKEY)
 	      err = GPG_ERR_NO_SECKEY;
             if (err)
               {
                 tty_printf (_("Error reading backup key from '%s': %s\n"),
                             fname, gpg_strerror (err));
                 xfree (fname);
                 free_packet (pkt, NULL);
                 xfree (pkt);
                 break;
               }
 
 	    xfree (fname);
 	    node = new_kbnode (pkt);
 
             /* Transfer it to gpg-agent which handles secret keys.  */
             err = transfer_secret_keys (ctrl, NULL, node, 1, 1, 0);
 
             /* Treat the pkt as a public key.  */
             pkt->pkttype = PKT_PUBLIC_KEY;
 
             /* Ask gpg-agent to store the secret key to card.  */
             if (card_store_subkey (node, 0))
               {
                 redisplay = 1;
                 sec_shadowing = 1;
               }
             release_kbnode (node);
           }
           break;
 
 #endif /* ENABLE_CARD_SUPPORT */
 
 	case cmdDELKEY:
 	  {
 	    int n1;
 
 	    if (!(n1 = count_selected_keys (keyblock)))
               {
                 tty_printf (_("You must select at least one key.\n"));
                 if (!opt.expert)
                   tty_printf (_("(Use the '%s' command.)\n"), "key");
               }
 	    else if (!cpr_get_answer_is_yes
                      ("keyedit.remove.subkey.okay",
                       n1 > 1 ? _("Do you really want to delete the "
                                  "selected keys? (y/N) ")
                       :  _("Do you really want to delete this key? (y/N) ")))
 	      ;
 	    else
 	      {
 		menu_delkey (keyblock);
 		redisplay = 1;
 		modified = 1;
 	      }
 	  }
 	  break;
 
 	case cmdADDREVOKER:
 	  {
 	    int sensitive = 0;
 
 	    if (ascii_strcasecmp (arg_string, "sensitive") == 0)
 	      sensitive = 1;
 	    if (menu_addrevoker (ctrl, keyblock, sensitive))
 	      {
 		redisplay = 1;
 		modified = 1;
 		merge_keys_and_selfsig (ctrl, keyblock);
 	      }
 	  }
 	  break;
 
 	case cmdREVUID:
 	  {
 	    int n1;
 
 	    if (!(n1 = count_selected_uids (keyblock)))
               {
                 tty_printf (_("You must select at least one user ID.\n"));
                 if (!opt.expert)
                   tty_printf (_("(Use the '%s' command.)\n"), "uid");
               }
 	    else if (cpr_get_answer_is_yes
                      ("keyedit.revoke.uid.okay",
                       n1 > 1 ? _("Really revoke all selected user IDs? (y/N) ")
 		      :        _("Really revoke this user ID? (y/N) ")))
 	      {
 		if (menu_revuid (ctrl, keyblock))
 		  {
 		    modified = 1;
 		    redisplay = 1;
 		  }
 	      }
 	  }
 	  break;
 
 	case cmdREVKEY:
 	  {
 	    int n1;
 
 	    if (!(n1 = count_selected_keys (keyblock)))
 	      {
 		if (cpr_get_answer_is_yes ("keyedit.revoke.subkey.okay",
 					   _("Do you really want to revoke"
 					     " the entire key? (y/N) ")))
 		  {
 		    if (menu_revkey (ctrl, keyblock))
 		      modified = 1;
 
 		    redisplay = 1;
 		  }
 	      }
 	    else if (cpr_get_answer_is_yes ("keyedit.revoke.subkey.okay",
 					    n1 > 1 ?
 					    _("Do you really want to revoke"
 					      " the selected subkeys? (y/N) ")
 					    : _("Do you really want to revoke"
 						" this subkey? (y/N) ")))
 	      {
 		if (menu_revsubkey (ctrl, keyblock))
 		  modified = 1;
 
 		redisplay = 1;
 	      }
 
 	    if (modified)
 	      merge_keys_and_selfsig (ctrl, keyblock);
 	  }
 	  break;
 
 	case cmdEXPIRE:
 	  if (gpg_err_code (menu_expire (ctrl, keyblock, 0, 0)) == GPG_ERR_TRUE)
 	    {
 	      merge_keys_and_selfsig (ctrl, keyblock);
               run_subkey_warnings = 1;
 	      modified = 1;
 	      redisplay = 1;
 	    }
 	  break;
 
 	case cmdCHANGEUSAGE:
 	  if (menu_changeusage (ctrl, keyblock))
 	    {
 	      merge_keys_and_selfsig (ctrl, keyblock);
 	      modified = 1;
 	      redisplay = 1;
 	    }
 	  break;
 
 	case cmdBACKSIGN:
 	  if (menu_backsign (ctrl, keyblock))
 	    {
 	      modified = 1;
 	      redisplay = 1;
 	    }
 	  break;
 
 	case cmdPRIMARY:
 	  if (menu_set_primary_uid (ctrl, keyblock))
 	    {
 	      merge_keys_and_selfsig (ctrl, keyblock);
 	      modified = 1;
 	      redisplay = 1;
 	    }
 	  break;
 
 	case cmdPASSWD:
 	  change_passphrase (ctrl, keyblock);
 	  break;
 
 #ifndef NO_TRUST_MODELS
 	case cmdTRUST:
 	  if (opt.trust_model == TM_EXTERNAL)
 	    {
 	      tty_printf (_("Owner trust may not be set while "
 			    "using a user provided trust database\n"));
 	      break;
 	    }
 
 	  show_key_with_all_names (ctrl, NULL, keyblock, 0, 0, 0, 1, 0, 0);
 	  tty_printf ("\n");
 	  if (edit_ownertrust (ctrl, find_kbnode (keyblock,
 					    PKT_PUBLIC_KEY)->pkt->pkt.
 			       public_key, 1))
 	    {
 	      redisplay = 1;
 	      /* No real need to set update_trust here as
 	         edit_ownertrust() calls revalidation_mark()
 	         anyway. */
 	      update_trust = 1;
 	    }
 	  break;
 #endif /*!NO_TRUST_MODELS*/
 
 	case cmdPREF:
 	  {
 	    int count = count_selected_uids (keyblock);
 	    log_assert (keyblock->pkt->pkttype == PKT_PUBLIC_KEY);
 	    show_names (ctrl, NULL, keyblock, keyblock->pkt->pkt.public_key,
 			count ? NODFLG_SELUID : 0, 1);
 	  }
 	  break;
 
 	case cmdSHOWPREF:
 	  {
 	    int count = count_selected_uids (keyblock);
 	    log_assert (keyblock->pkt->pkttype == PKT_PUBLIC_KEY);
 	    show_names (ctrl, NULL, keyblock, keyblock->pkt->pkt.public_key,
 			count ? NODFLG_SELUID : 0, 2);
 	  }
 	  break;
 
 	case cmdSETPREF:
 	  {
 	    PKT_user_id *tempuid;
 
 	    keygen_set_std_prefs (!*arg_string ? "default" : arg_string, 0);
 
 	    tempuid = keygen_get_std_prefs ();
 	    tty_printf (_("Set preference list to:\n"));
 	    show_prefs (tempuid, NULL, 1);
 	    free_user_id (tempuid);
 
 	    if (cpr_get_answer_is_yes
                 ("keyedit.setpref.okay",
                  count_selected_uids (keyblock) ?
                  _("Really update the preferences"
                    " for the selected user IDs? (y/N) ")
                  : _("Really update the preferences? (y/N) ")))
 	      {
 		if (menu_set_preferences (ctrl, keyblock))
 		  {
 		    merge_keys_and_selfsig (ctrl, keyblock);
 		    modified = 1;
 		    redisplay = 1;
 		  }
 	      }
 	  }
 	  break;
 
 	case cmdPREFKS:
 	  if (menu_set_keyserver_url (ctrl, *arg_string ? arg_string : NULL,
 				      keyblock))
 	    {
 	      merge_keys_and_selfsig (ctrl, keyblock);
 	      modified = 1;
 	      redisplay = 1;
 	    }
 	  break;
 
 	case cmdNOTATION:
 	  if (menu_set_notation (ctrl, *arg_string ? arg_string : NULL,
 				 keyblock))
 	    {
 	      merge_keys_and_selfsig (ctrl, keyblock);
 	      modified = 1;
 	      redisplay = 1;
 	    }
 	  break;
 
 	case cmdNOP:
 	  break;
 
 	case cmdREVSIG:
 	  if (menu_revsig (ctrl, keyblock))
 	    {
 	      redisplay = 1;
 	      modified = 1;
 	    }
 	  break;
 
 #ifndef NO_TRUST_MODELS
 	case cmdENABLEKEY:
 	case cmdDISABLEKEY:
 	  if (enable_disable_key (ctrl, keyblock, cmd == cmdDISABLEKEY))
 	    {
 	      redisplay = 1;
 	      modified = 1;
 	    }
 	  break;
 #endif /*!NO_TRUST_MODELS*/
 
 	case cmdSHOWPHOTO:
 	  menu_showphoto (ctrl, keyblock);
 	  break;
 
 	case cmdCLEAN:
 	  if (menu_clean (ctrl, keyblock, 0))
 	    redisplay = modified = 1;
 	  break;
 
 	case cmdMINIMIZE:
 	  if (menu_clean (ctrl, keyblock, 1))
 	    redisplay = modified = 1;
 	  break;
 
 	case cmdQUIT:
 	  if (have_commands)
 	    goto leave;
 	  if (!modified && !sec_shadowing)
 	    goto leave;
 	  if (!cpr_get_answer_is_yes ("keyedit.save.okay",
 				      _("Save changes? (y/N) ")))
 	    {
 	      if (cpr_enabled ()
 		  || cpr_get_answer_is_yes ("keyedit.cancel.okay",
 					    _("Quit without saving? (y/N) ")))
 		goto leave;
 	      break;
 	    }
 	  /* fall through */
 	case cmdSAVE:
 	  if (modified)
 	    {
               err = keydb_update_keyblock (ctrl, kdbhd, keyblock);
               if (err)
                 {
                   log_error (_("update failed: %s\n"), gpg_strerror (err));
                   break;
                 }
 	    }
 
 	  if (sec_shadowing)
 	    {
 	      err = agent_scd_learn (NULL, 1);
 	      if (err)
                 {
                   log_error (_("update failed: %s\n"), gpg_strerror (err));
                   break;
                 }
 	    }
 
 	  if (!modified && !sec_shadowing)
 	    tty_printf (_("Key not changed so no update needed.\n"));
 
 	  if (update_trust)
 	    {
 	      revalidation_mark (ctrl);
 	      update_trust = 0;
 	    }
 	  goto leave;
 
 	case cmdINVCMD:
 	default:
 	  tty_printf ("\n");
 	  tty_printf (_("Invalid command  (try \"help\")\n"));
 	  break;
 	}
     } /* End of the main command loop.  */
 
  leave:
   release_kbnode (keyblock);
   keydb_release (kdbhd);
   xfree (answer);
 }
 
 
 /* Change the passphrase of the secret key identified by USERNAME.  */
 void
 keyedit_passwd (ctrl_t ctrl, const char *username)
 {
   gpg_error_t err;
   PKT_public_key *pk;
   kbnode_t keyblock = NULL;
 
   pk = xtrycalloc (1, sizeof *pk);
   if (!pk)
     {
       err = gpg_error_from_syserror ();
       goto leave;
     }
   err = getkey_byname (ctrl, NULL, pk, username, 1, &keyblock);
   if (err)
     goto leave;
 
   err = change_passphrase (ctrl, keyblock);
 
 leave:
   release_kbnode (keyblock);
   free_public_key (pk);
   if (err)
     {
       log_info ("error changing the passphrase for '%s': %s\n",
 		username, gpg_strerror (err));
       write_status_error ("keyedit.passwd", err);
     }
   else
     write_status_text (STATUS_SUCCESS, "keyedit.passwd");
 }
 
 
 /* Helper for quick commands to find the keyblock for USERNAME.
  * Returns on success the key database handle at R_KDBHD and the
  * keyblock at R_KEYBLOCK.  */
 static gpg_error_t
 quick_find_keyblock (ctrl_t ctrl, const char *username, int want_secret,
                      KEYDB_HANDLE *r_kdbhd, kbnode_t *r_keyblock)
 {
   gpg_error_t err;
   KEYDB_HANDLE kdbhd = NULL;
   kbnode_t keyblock = NULL;
   KEYDB_SEARCH_DESC desc;
   kbnode_t node;
 
   *r_kdbhd = NULL;
   *r_keyblock = NULL;
 
   /* Search the key; we don't want the whole getkey stuff here.  */
   kdbhd = keydb_new (ctrl);
   if (!kdbhd)
     {
       /* Note that keydb_new has already used log_error.  */
       err = gpg_error_from_syserror ();
       goto leave;
     }
 
   err = classify_user_id (username, &desc, 1);
   if (!err)
     err = keydb_search (kdbhd, &desc, 1, NULL);
   if (!err)
     {
       err = keydb_get_keyblock (kdbhd, &keyblock);
       if (err)
         {
           log_error (_("error reading keyblock: %s\n"), gpg_strerror (err));
           goto leave;
         }
       /* Now with the keyblock retrieved, search again to detect an
          ambiguous specification.  We need to save the found state so
          that we can do an update later.  */
       keydb_push_found_state (kdbhd);
       err = keydb_search (kdbhd, &desc, 1, NULL);
       if (!err)
         err = gpg_error (GPG_ERR_AMBIGUOUS_NAME);
       else if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
         err = 0;
       keydb_pop_found_state (kdbhd);
 
       if (!err && want_secret)
         {
           /* We require the secret primary key to set the primary UID.  */
           node = find_kbnode (keyblock, PKT_PUBLIC_KEY);
           log_assert (node);
           if (!agent_probe_secret_key (ctrl, node->pkt->pkt.public_key))
             err = gpg_error (GPG_ERR_NO_SECKEY);
         }
     }
   else if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
     err = gpg_error (GPG_ERR_NO_PUBKEY);
 
   if (err)
     {
       log_error (_("key \"%s\" not found: %s\n"),
                  username, gpg_strerror (err));
       goto leave;
     }
 
   fix_keyblock (ctrl, &keyblock);
   merge_keys_and_selfsig (ctrl, keyblock);
 
   *r_keyblock = keyblock;
   keyblock = NULL;
   *r_kdbhd = kdbhd;
   kdbhd = NULL;
 
  leave:
   release_kbnode (keyblock);
   keydb_release (kdbhd);
   return err;
 }
 
 
 /* Unattended adding of a new keyid.  USERNAME specifies the
    key. NEWUID is the new user id to add to the key.  */
 void
 keyedit_quick_adduid (ctrl_t ctrl, const char *username, const char *newuid)
 {
   gpg_error_t err;
   KEYDB_HANDLE kdbhd = NULL;
   kbnode_t keyblock = NULL;
   char *uidstring = NULL;
 
   uidstring = xstrdup (newuid);
   trim_spaces (uidstring);
   if (!*uidstring)
     {
       log_error ("%s\n", gpg_strerror (GPG_ERR_INV_USER_ID));
       goto leave;
     }
 
 #ifdef HAVE_W32_SYSTEM
   /* See keyedit_menu for why we need this.  */
   check_trustdb_stale (ctrl);
 #endif
 
   /* Search the key; we don't want the whole getkey stuff here.  */
   err = quick_find_keyblock (ctrl, username, 1, &kdbhd, &keyblock);
   if (err)
     goto leave;
 
   if (menu_adduid (ctrl, keyblock, 0, NULL, uidstring))
     {
       err = keydb_update_keyblock (ctrl, kdbhd, keyblock);
       if (err)
         {
           log_error (_("update failed: %s\n"), gpg_strerror (err));
           goto leave;
         }
 
       if (update_trust)
         revalidation_mark (ctrl);
     }
 
  leave:
   xfree (uidstring);
   release_kbnode (keyblock);
   keydb_release (kdbhd);
 }
 
 
 /* Unattended revocation of a keyid.  USERNAME specifies the
    key. UIDTOREV is the user id revoke from the key.  */
 void
 keyedit_quick_revuid (ctrl_t ctrl, const char *username, const char *uidtorev)
 {
   gpg_error_t err;
   KEYDB_HANDLE kdbhd = NULL;
   kbnode_t keyblock = NULL;
   kbnode_t node;
   int modified = 0;
   size_t revlen;
   size_t valid_uids;
 
 #ifdef HAVE_W32_SYSTEM
   /* See keyedit_menu for why we need this.  */
   check_trustdb_stale (ctrl);
 #endif
 
   /* Search the key; we don't want the whole getkey stuff here.  */
   err = quick_find_keyblock (ctrl, username, 1, &kdbhd, &keyblock);
   if (err)
     goto leave;
 
   /* Too make sure that we do not revoke the last valid UID, we first
      count how many valid UIDs there are.  */
   valid_uids = 0;
   for (node = keyblock; node; node = node->next)
     valid_uids += (node->pkt->pkttype == PKT_USER_ID
                    && !node->pkt->pkt.user_id->flags.revoked
                    && !node->pkt->pkt.user_id->flags.expired);
 
   /* Find the right UID. */
   revlen = strlen (uidtorev);
   for (node = keyblock; node; node = node->next)
     {
       if (node->pkt->pkttype == PKT_USER_ID
           && revlen == node->pkt->pkt.user_id->len
           && !memcmp (node->pkt->pkt.user_id->name, uidtorev, revlen))
         {
           struct revocation_reason_info *reason;
 
           /* Make sure that we do not revoke the last valid UID.  */
           if (valid_uids == 1
               && ! node->pkt->pkt.user_id->flags.revoked
               && ! node->pkt->pkt.user_id->flags.expired)
             {
               log_error (_("cannot revoke the last valid user ID.\n"));
               err = gpg_error (GPG_ERR_INV_USER_ID);
               goto leave;
             }
 
           reason = get_default_uid_revocation_reason ();
           err = core_revuid (ctrl, keyblock, node, reason, &modified);
           release_revocation_reason_info (reason);
           if (err)
             goto leave;
           err = keydb_update_keyblock (ctrl, kdbhd, keyblock);
           if (err)
             {
               log_error (_("update failed: %s\n"), gpg_strerror (err));
               goto leave;
             }
 
           revalidation_mark (ctrl);
           goto leave;
         }
     }
   err = gpg_error (GPG_ERR_NO_USER_ID);
 
 
  leave:
   if (err)
     {
       log_error (_("revoking the user ID failed: %s\n"), gpg_strerror (err));
       write_status_error ("keyedit.revoke.uid", err);
     }
   release_kbnode (keyblock);
   keydb_release (kdbhd);
 }
 
 
 /* Unattended setting of the primary uid.  USERNAME specifies the key.
    PRIMARYUID is the user id which shall be primary.  */
 void
 keyedit_quick_set_primary (ctrl_t ctrl, const char *username,
                            const char *primaryuid)
 {
   gpg_error_t err;
   KEYDB_HANDLE kdbhd = NULL;
   kbnode_t keyblock = NULL;
   kbnode_t node;
   size_t primaryuidlen;
   int any;
 
 #ifdef HAVE_W32_SYSTEM
   /* See keyedit_menu for why we need this.  */
   check_trustdb_stale (ctrl);
 #endif
 
   err = quick_find_keyblock (ctrl, username, 1, &kdbhd, &keyblock);
   if (err)
     goto leave;
 
   /* Find and mark the UID - we mark only the first valid one. */
   primaryuidlen = strlen (primaryuid);
   any = 0;
   for (node = keyblock; node; node = node->next)
     {
       if (node->pkt->pkttype == PKT_USER_ID
           && !any
           && !node->pkt->pkt.user_id->flags.revoked
           && !node->pkt->pkt.user_id->flags.expired
           && primaryuidlen == node->pkt->pkt.user_id->len
           && !memcmp (node->pkt->pkt.user_id->name, primaryuid, primaryuidlen))
         {
           node->flag |= NODFLG_SELUID;
           any = 1;
         }
       else
         node->flag &= ~NODFLG_SELUID;
     }
 
   if (!any)
     err = gpg_error (GPG_ERR_NO_USER_ID);
   else if (menu_set_primary_uid (ctrl, keyblock))
     {
       merge_keys_and_selfsig (ctrl, keyblock);
       err = keydb_update_keyblock (ctrl, kdbhd, keyblock);
       if (err)
         {
           log_error (_("update failed: %s\n"), gpg_strerror (err));
           goto leave;
         }
       revalidation_mark (ctrl);
     }
   else
     err = gpg_error (GPG_ERR_GENERAL);
 
   if (err)
     log_error (_("setting the primary user ID failed: %s\n"),
                gpg_strerror (err));
 
  leave:
   release_kbnode (keyblock);
   keydb_release (kdbhd);
 }
 
 
 /* Find a keyblock by fingerprint because only this uniquely
  * identifies a key and may thus be used to select a key for
  * unattended subkey creation os key signing.  */
 static gpg_error_t
 find_by_primary_fpr (ctrl_t ctrl, const char *fpr,
                      kbnode_t *r_keyblock, KEYDB_HANDLE *r_kdbhd)
 {
   gpg_error_t err;
   kbnode_t keyblock = NULL;
   KEYDB_HANDLE kdbhd = NULL;
   KEYDB_SEARCH_DESC desc;
   byte fprbin[MAX_FINGERPRINT_LEN];
   size_t fprlen;
 
   *r_keyblock = NULL;
   *r_kdbhd = NULL;
 
   if (classify_user_id (fpr, &desc, 1)
       || desc.mode != KEYDB_SEARCH_MODE_FPR)
     {
       log_error (_("\"%s\" is not a fingerprint\n"), fpr);
       err = gpg_error (GPG_ERR_INV_NAME);
       goto leave;
     }
   err = get_pubkey_byname (ctrl, GET_PUBKEY_NO_AKL,
                            NULL, NULL, fpr, &keyblock, &kdbhd, 1);
   if (err)
     {
       log_error (_("key \"%s\" not found: %s\n"), fpr, gpg_strerror (err));
       goto leave;
     }
 
   /* Check that the primary fingerprint has been given. */
   fingerprint_from_pk (keyblock->pkt->pkt.public_key, fprbin, &fprlen);
   if (desc.mode == KEYDB_SEARCH_MODE_FPR
       && fprlen == desc.fprlen
       && !memcmp (fprbin, desc.u.fpr, fprlen))
     ;
   else
     {
       log_error (_("\"%s\" is not the primary fingerprint\n"), fpr);
       err = gpg_error (GPG_ERR_INV_NAME);
       goto leave;
     }
 
   *r_keyblock = keyblock;
   keyblock = NULL;
   *r_kdbhd = kdbhd;
   kdbhd = NULL;
   err = 0;
 
  leave:
   release_kbnode (keyblock);
   keydb_release (kdbhd);
   return err;
 }
 
 
 /* Unattended key signing function.  If the key specifified by FPR is
    available and FPR is the primary fingerprint all user ids of the
    key are signed using the default signing key.  If UIDS is an empty
    list all usable UIDs are signed, if it is not empty, only those
    user ids matching one of the entries of the list are signed.  With
    LOCAL being true the signatures are marked as non-exportable.  */
 void
 keyedit_quick_sign (ctrl_t ctrl, const char *fpr, strlist_t uids,
                     strlist_t locusr, int local)
 {
   gpg_error_t err;
   kbnode_t keyblock = NULL;
   KEYDB_HANDLE kdbhd = NULL;
   int modified = 0;
   PKT_public_key *pk;
   kbnode_t node;
   strlist_t sl;
   int any;
 
 #ifdef HAVE_W32_SYSTEM
   /* See keyedit_menu for why we need this.  */
   check_trustdb_stale (ctrl);
 #endif
 
   /* We require a fingerprint because only this uniquely identifies a
      key and may thus be used to select a key for unattended key
      signing.  */
   if (find_by_primary_fpr (ctrl, fpr, &keyblock, &kdbhd))
     goto leave;
 
   if (fix_keyblock (ctrl, &keyblock))
     modified++;
 
   /* Give some info in verbose.  */
   if (opt.verbose)
     {
       show_key_with_all_names (ctrl, es_stdout, keyblock, 0,
                                1/*with_revoker*/, 1/*with_fingerprint*/,
                                0, 0, 1);
       es_fflush (es_stdout);
     }
 
   pk = keyblock->pkt->pkt.public_key;
   if (pk->flags.revoked)
     {
       if (!opt.verbose)
         show_key_with_all_names (ctrl, es_stdout, keyblock, 0, 0, 0, 0, 0, 1);
       log_error ("%s%s", _("Key is revoked."), _("  Unable to sign.\n"));
       goto leave;
     }
 
   /* Set the flags according to the UIDS list.  Fixme: We may want to
      use classify_user_id along with dedicated compare functions so
      that we match the same way as in the key lookup. */
   any = 0;
   menu_select_uid (keyblock, 0);   /* Better clear the flags first. */
   for (sl=uids; sl; sl = sl->next)
     {
       const char *name = sl->d;
       int count = 0;
 
       sl->flags &= ~(1|2);  /* Clear flags used for error reporting.  */
 
       for (node = keyblock; node; node = node->next)
         {
           if (node->pkt->pkttype == PKT_USER_ID)
             {
               PKT_user_id *uid = node->pkt->pkt.user_id;
 
               if (uid->attrib_data)
                 ;
               else if (*name == '='
                        && strlen (name+1) == uid->len
                        && !memcmp (uid->name, name + 1, uid->len))
                 { /* Exact match - we don't do a check for ambiguity
                    * in this case.  */
                   node->flag |= NODFLG_SELUID;
                   if (any != -1)
                     {
                       sl->flags |= 1;  /* Report as found.  */
                       any = 1;
                     }
                 }
               else if (ascii_memistr (uid->name, uid->len,
                                       *name == '*'? name+1:name))
                 {
                   node->flag |= NODFLG_SELUID;
                   if (any != -1)
                     {
                       sl->flags |= 1;  /* Report as found.  */
                       any = 1;
                     }
                   count++;
                 }
             }
         }
 
       if (count > 1)
         {
           any = -1;        /* Force failure at end.  */
           sl->flags |= 2;  /* Report as ambiguous.  */
         }
     }
 
   /* Check whether all given user ids were found.  */
   for (sl=uids; sl; sl = sl->next)
     if (!(sl->flags & 1))
       any = -1;  /* That user id was not found.  */
 
   /* Print an error if there was a problem with the user ids.  */
   if (uids && any < 1)
     {
       if (!opt.verbose)
         show_key_with_all_names (ctrl, es_stdout, keyblock, 0, 0, 0, 0, 0, 1);
       es_fflush (es_stdout);
       for (sl=uids; sl; sl = sl->next)
         {
           if ((sl->flags & 2))
             log_info (_("Invalid user ID '%s': %s\n"),
                       sl->d, gpg_strerror (GPG_ERR_AMBIGUOUS_NAME));
           else if (!(sl->flags & 1))
             log_info (_("Invalid user ID '%s': %s\n"),
                       sl->d, gpg_strerror (GPG_ERR_NOT_FOUND));
         }
       log_error ("%s  %s", _("No matching user IDs."), _("Nothing to sign.\n"));
       goto leave;
     }
 
   /* Sign. */
   sign_uids (ctrl, es_stdout, keyblock, locusr, &modified, local, 0, 0, 0, 1);
   es_fflush (es_stdout);
 
   if (modified)
     {
       err = keydb_update_keyblock (ctrl, kdbhd, keyblock);
       if (err)
         {
           log_error (_("update failed: %s\n"), gpg_strerror (err));
           goto leave;
         }
     }
   else
     log_info (_("Key not changed so no update needed.\n"));
 
   if (update_trust)
     revalidation_mark (ctrl);
 
 
  leave:
   release_kbnode (keyblock);
   keydb_release (kdbhd);
 }
 
 
 /* Unattended revocation of a key signatures.  USERNAME specifies the
  * key; this should best be a fingerprint. SIGTOREV is the user-id of
  * the key for which the key signature shall be removed.  Only
  * non-self-signatures can be removed with this functions.  If
  * AFFECTED_UIDS is not NULL only the key signatures on these user-ids
  * are revoked. */
 void
 keyedit_quick_revsig (ctrl_t ctrl, const char *username, const char *sigtorev,
                       strlist_t affected_uids)
 {
   gpg_error_t err;
   int no_signing_key = 0;
   KEYDB_HANDLE kdbhd = NULL;
   kbnode_t keyblock = NULL;
   PKT_public_key *primarypk;  /* Points into KEYBLOCK.  */
   u32 *primarykid;
   PKT_public_key *pksigtorev = NULL;
   u32 *pksigtorevkid;
   kbnode_t node, n;
   int skip_remaining;
   int consider_sig;
   strlist_t sl;
   struct sign_attrib attrib = { 0 };
 
 #ifdef HAVE_W32_SYSTEM
   /* See keyedit_menu for why we need this.  */
   check_trustdb_stale (ctrl);
 #endif
 
   /* Search the key; we don't want the whole getkey stuff here.  Noet
    * that we are looking for the public key here.  */
   err = quick_find_keyblock (ctrl, username, 0, &kdbhd, &keyblock);
   if (err)
     goto leave;
   log_assert (keyblock->pkt->pkttype == PKT_PUBLIC_KEY
               || keyblock->pkt->pkttype == PKT_SECRET_KEY);
   primarypk = keyblock->pkt->pkt.public_key;
   primarykid = pk_keyid (primarypk);
 
   /* Get the signing key we want to revoke.  This must be one of our
    * signing keys.  We will compare only the keyid because we don't
    * assume that we have duplicated keyids on our own secret keys.  If
    * a there is a duplicated one we will notice this when creating the
    * revocation.  */
   pksigtorev = xtrycalloc (1, sizeof *pksigtorev);
   if (!pksigtorev)
     {
       err = gpg_error_from_syserror ();
       goto leave;
     }
   pksigtorev->req_usage = PUBKEY_USAGE_CERT;
   err = getkey_byname (ctrl, NULL, pksigtorev, sigtorev, 1, NULL);
   if (err)
     {
       no_signing_key = 1;
       goto leave;
     }
   pksigtorevkid = pk_keyid (pksigtorev);
 
   /* Find the signatures we want to revoke and set a mark.  */
   skip_remaining = consider_sig = 0;
   for (node = keyblock; node; node = node->next)
     {
       node->flag &= ~NODFLG_MARK_A;
       if (skip_remaining)
         ;
       else if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
         skip_remaining = 1;
       else if (node->pkt->pkttype == PKT_USER_ID)
 	{
           PKT_user_id *uid = node->pkt->pkt.user_id;
 
           consider_sig = !affected_uids;
           for (sl = affected_uids; !consider_sig && sl; sl = sl->next)
             {
               const char *name = sl->d;
 
               if (uid->attrib_data)
                 ;
               else if (*name == '='
                        && strlen (name+1) == uid->len
                        && !memcmp (uid->name, name + 1, uid->len))
                 { /* Exact match.  */
                   consider_sig = 1;
                 }
               else if (ascii_memistr (uid->name, uid->len,
                                       *name == '*'? name+1:name))
                 { /* Case-insensitive substring match.  */
                   consider_sig = 1;
                 }
             }
 	}
       else if (node->pkt->pkttype == PKT_SIGNATURE)
 	{
           /* We need to sort the signatures so that we can figure out
            * whether the key signature has been revoked or the
            * revocation has been superseded by a new key
            * signature.  */
           PKT_signature *sig;
           unsigned int sigcount = 0;
           kbnode_t *sigarray;
 
           /* Allocate an array large enogh for all signatures.  */
           for (n=node; n && n->pkt->pkttype == PKT_SIGNATURE; n = n->next)
             sigcount++;
           sigarray = xtrycalloc (sigcount, sizeof *sigarray);
           if (!sigarray)
             {
               err = gpg_error_from_syserror ();
               goto leave;
             }
 
           /* Now fill the array with signatures we are interested in.
            * We also move NODE forward to the end.  */
           sigcount = 0;
           for (n=node; n && n->pkt->pkttype == PKT_SIGNATURE; node=n, n=n->next)
             {
               sig = n->pkt->pkt.signature;
               if (!keyid_cmp (primarykid, sig->keyid))
                 continue;  /* Ignore self-signatures.  */
 
               if (keyid_cmp (pksigtorevkid, sig->keyid))
                 continue; /* Ignore non-matching signatures.  */
 
               n->flag &= ~NODFLG_MARK_B; /* Clear flag used by cm_signode. */
               sigarray[sigcount++] = n;
             }
 
           if (sigcount)
             {
               qsort (sigarray, sigcount, sizeof *sigarray, cmp_signodes);
 
               /* log_debug ("Sorted signatures:\n"); */
               /* for (idx=0; idx < sigcount; idx++) */
               /*   { */
               /*     sig = sigarray[idx]->pkt->pkt.signature; */
               /*     log_debug ("%s 0x%02x %s\n", keystr (sig->keyid), */
               /*                sig->sig_class, datestr_from_sig (sig)); */
               /*   } */
               sig = sigarray[sigcount-1]->pkt->pkt.signature;
               if ((consider_sig || !affected_uids) && IS_UID_REV (sig))
                 {
                   if (!opt.quiet)
                     log_info ("sig by %s already revoked at %s\n",
                               keystr (sig->keyid), datestr_from_sig (sig));
                 }
               else if ((consider_sig && IS_UID_SIG (sig))
                        || (!affected_uids && IS_KEY_SIG (sig)))
                 node->flag |= NODFLG_MARK_A;  /* Select signature.  */
             }
 
           xfree (sigarray);
 	}
     }
 
   /* Check whether any signatures were done by the given key.  We do
    * not return an error if none were found.  */
   for (node = keyblock; node; node = node->next)
     if ((node->flag & NODFLG_MARK_A))
       break;
   if (!node)
     {
       if (opt.verbose)
         log_info (_("Not signed by you.\n"));
       err = 0;
       goto leave;
     }
 
   /* Revoke all marked signatures.  */
   attrib.reason = get_default_sig_revocation_reason ();
 
  reloop: /* (we must repeat because we are modifying the list) */
   for (node = keyblock; node; node = node->next)
     {
       kbnode_t unode;
       PKT_signature *sig;
       PACKET *pkt;
 
       if (!(node->flag & NODFLG_MARK_A))
 	continue;
       node->flag &= ~NODFLG_MARK_A;
 
       if (IS_KEY_SIG (node->pkt->pkt.signature))
         unode = NULL;
       else
         {
           unode = find_prev_kbnode (keyblock, node, PKT_USER_ID);
           log_assert (unode);
         }
 
       attrib.non_exportable = !node->pkt->pkt.signature->flags.exportable;
 
       err = make_keysig_packet (ctrl, &sig, primarypk,
                                 unode? unode->pkt->pkt.user_id : NULL,
                                 NULL, pksigtorev, 0x30, 0, 0,
                                 sign_mk_attrib, &attrib, NULL);
       if (err)
         {
           log_error ("signing failed: %s\n", gpg_strerror (err));
           goto leave;
         }
 
       pkt = xmalloc_clear (sizeof *pkt);
       pkt->pkttype = PKT_SIGNATURE;
       pkt->pkt.signature = sig;
       if (unode)
         insert_kbnode (unode, new_kbnode (pkt), 0);
       goto reloop;
     }
 
   err = keydb_update_keyblock (ctrl, kdbhd, keyblock);
   if (err)
     {
       log_error (_("update failed: %s\n"), gpg_strerror (err));
       goto leave;
     }
   revalidation_mark (ctrl);
 
  leave:
   if (err)
     {
       log_error (_("revoking the key signature failed: %s\n"),
                  gpg_strerror (err));
       if (no_signing_key)
         print_further_info ("error getting key used to make the key signature");
       write_status_error ("keyedit.revoke.sig", err);
     }
   release_revocation_reason_info (attrib.reason);
   free_public_key (pksigtorev);
   release_kbnode (keyblock);
   keydb_release (kdbhd);
 }
 
 
 /* Unattended subkey creation function.
  *
  */
 void
 keyedit_quick_addkey (ctrl_t ctrl, const char *fpr, const char *algostr,
                       const char *usagestr, const char *expirestr)
 {
   gpg_error_t err;
   kbnode_t keyblock;
   KEYDB_HANDLE kdbhd;
   int modified = 0;
   PKT_public_key *pk;
 
 #ifdef HAVE_W32_SYSTEM
   /* See keyedit_menu for why we need this.  */
   check_trustdb_stale (ctrl);
 #endif
 
   /* We require a fingerprint because only this uniquely identifies a
    * key and may thus be used to select a key for unattended subkey
    * creation.  */
   if (find_by_primary_fpr (ctrl, fpr, &keyblock, &kdbhd))
     goto leave;
 
   if (fix_keyblock (ctrl, &keyblock))
     modified++;
 
   pk = keyblock->pkt->pkt.public_key;
   if (pk->flags.revoked)
     {
       if (!opt.verbose)
         show_key_with_all_names (ctrl, es_stdout, keyblock, 0, 0, 0, 0, 0, 1);
       log_error ("%s%s", _("Key is revoked."), "\n");
       goto leave;
     }
 
   /* Create the subkey.  Note that the called function already prints
    * an error message. */
   if (!generate_subkeypair (ctrl, keyblock, algostr, usagestr, expirestr))
     modified = 1;
   es_fflush (es_stdout);
 
   /* Store.  */
   if (modified)
     {
       err = keydb_update_keyblock (ctrl, kdbhd, keyblock);
       if (err)
         {
           log_error (_("update failed: %s\n"), gpg_strerror (err));
           goto leave;
         }
     }
   else
     log_info (_("Key not changed so no update needed.\n"));
 
  leave:
   release_kbnode (keyblock);
   keydb_release (kdbhd);
 }
 
 
 /* Unattended expiration setting function for the main key.  If
  * SUBKEYFPRS is not NULL and SUBKEYSFPRS[0] is neither NULL, it is
  * expected to be an array of fingerprints for subkeys to change. It
  * may also be an array which just one item "*" to indicate that all
  * keys shall be set to that expiration date.
  */
 void
 keyedit_quick_set_expire (ctrl_t ctrl, const char *fpr, const char *expirestr,
                           char **subkeyfprs)
 {
   gpg_error_t err;
   kbnode_t keyblock, node;
   KEYDB_HANDLE kdbhd;
   int modified = 0;
   PKT_public_key *pk;
   u32 expire;
   int primary_only = 0;
   int idx;
 
 #ifdef HAVE_W32_SYSTEM
   /* See keyedit_menu for why we need this.  */
   check_trustdb_stale (ctrl);
 #endif
 
   /* We require a fingerprint because only this uniquely identifies a
    * key and may thus be used to select a key for unattended
    * expiration setting.  */
   err = find_by_primary_fpr (ctrl, fpr, &keyblock, &kdbhd);
   if (err)
     goto leave;
 
   if (fix_keyblock (ctrl, &keyblock))
     modified++;
 
   pk = keyblock->pkt->pkt.public_key;
   if (pk->flags.revoked)
     {
       if (!opt.verbose)
         show_key_with_all_names (ctrl, es_stdout, keyblock, 0, 0, 0, 0, 0, 1);
       log_error ("%s%s", _("Key is revoked."), "\n");
       err = gpg_error (GPG_ERR_CERT_REVOKED);
       goto leave;
     }
 
   expire = parse_expire_string (expirestr);
   if (expire == (u32)-1 )
     {
       log_error (_("'%s' is not a valid expiration time\n"), expirestr);
       err = gpg_error (GPG_ERR_INV_VALUE);
       goto leave;
     }
   if (expire)
     expire += make_timestamp ();
 
   /* Check whether a subkey's expiration time shall be changed or the
    * expiration time of all keys.  */
   if (!subkeyfprs || !subkeyfprs[0])
     primary_only = 1;
   else if ( !strcmp (subkeyfprs[0], "*") && !subkeyfprs[1])
     {
       /* Change all subkeys keys which have not been revoked and are
        * not yet expired.  */
       merge_keys_and_selfsig (ctrl, keyblock);
       for (node = keyblock; node; node = node->next)
         {
           if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
               && (pk = node->pkt->pkt.public_key)
               && !pk->flags.revoked
               && !pk->has_expired)
             node->flag |= NODFLG_SELKEY;
         }
     }
   else
     {
       /* Change specified subkeys.  */
       KEYDB_SEARCH_DESC desc;
       byte fprbin[MAX_FINGERPRINT_LEN];
       size_t fprlen;
 
       err = 0;
       merge_keys_and_selfsig (ctrl, keyblock);
       for (idx=0; subkeyfprs[idx]; idx++)
         {
           int any = 0;
 
           /* Parse the fingerprint.  */
           if (classify_user_id (subkeyfprs[idx], &desc, 1)
               || desc.mode != KEYDB_SEARCH_MODE_FPR)
             {
               log_error (_("\"%s\" is not a proper fingerprint\n"),
                          subkeyfprs[idx] );
               if (!err)
                 err = gpg_error (GPG_ERR_INV_NAME);
               continue;
             }
 
           /* Set the flag for the matching non revoked subkey.  */
           for (node = keyblock; node; node = node->next)
             {
               if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
                   && (pk = node->pkt->pkt.public_key)
                   && !pk->flags.revoked )
                 {
                   fingerprint_from_pk (pk, fprbin, &fprlen);
                   if (fprlen == 20 && !memcmp (fprbin, desc.u.fpr, 20))
                     {
                       node->flag |= NODFLG_SELKEY;
                       any = 1;
                     }
                 }
             }
           if (!any)
             {
               log_error (_("subkey \"%s\" not found\n"), subkeyfprs[idx]);
               if (!err)
                 err = gpg_error (GPG_ERR_NOT_FOUND);
             }
         }
 
       if (err)
         goto leave;
     }
 
   /* Set the new expiration date.  */
   err = menu_expire (ctrl, keyblock, primary_only? 1 : 2, expire);
   if (gpg_err_code (err) == GPG_ERR_TRUE)
     modified = 1;
   else if (err)
     goto leave;
   es_fflush (es_stdout);
 
   /* Store.  */
   if (modified)
     {
       err = keydb_update_keyblock (ctrl, kdbhd, keyblock);
       if (err)
         {
           log_error (_("update failed: %s\n"), gpg_strerror (err));
           goto leave;
         }
       if (update_trust)
         revalidation_mark (ctrl);
     }
   else
     log_info (_("Key not changed so no update needed.\n"));
 
  leave:
   release_kbnode (keyblock);
   keydb_release (kdbhd);
   if (err)
     write_status_error ("set_expire", err);
 }
 
 
 
 static void
 tty_print_notations (int indent, PKT_signature * sig)
 {
   int first = 1;
   struct notation *notation, *nd;
 
   if (indent < 0)
     {
       first = 0;
       indent = -indent;
     }
 
   notation = sig_to_notation (sig);
 
   for (nd = notation; nd; nd = nd->next)
     {
       if (!first)
 	tty_printf ("%*s", indent, "");
       else
 	first = 0;
 
       tty_print_utf8_string (nd->name, strlen (nd->name));
       tty_printf ("=");
       tty_print_utf8_string (nd->value, strlen (nd->value));
       tty_printf ("\n");
     }
 
   free_notation (notation);
 }
 
 
 /*
  * Show preferences of a public keyblock.
  */
 static void
 show_prefs (PKT_user_id * uid, PKT_signature * selfsig, int verbose)
 {
   const prefitem_t fake = { 0, 0 };
   const prefitem_t *prefs;
   int i;
 
   if (!uid)
     return;
 
   if (uid->prefs)
     prefs = uid->prefs;
   else if (verbose)
     prefs = &fake;
   else
     return;
 
   if (verbose)
     {
       int any, des_seen = 0, sha1_seen = 0, uncomp_seen = 0;
 
       tty_printf ("     ");
       tty_printf (_("Cipher: "));
       for (i = any = 0; prefs[i].type; i++)
 	{
 	  if (prefs[i].type == PREFTYPE_SYM)
 	    {
 	      if (any)
 		tty_printf (", ");
 	      any = 1;
 	      /* We don't want to display strings for experimental algos */
 	      if (!openpgp_cipher_test_algo (prefs[i].value)
 		  && prefs[i].value < 100)
 		tty_printf ("%s", openpgp_cipher_algo_name (prefs[i].value));
 	      else
 		tty_printf ("[%d]", prefs[i].value);
 	      if (prefs[i].value == CIPHER_ALGO_3DES)
 		des_seen = 1;
 	    }
 	}
       if (!des_seen)
 	{
 	  if (any)
 	    tty_printf (", ");
 	  tty_printf ("%s", openpgp_cipher_algo_name (CIPHER_ALGO_3DES));
 	}
       tty_printf ("\n     ");
       tty_printf (_("AEAD: "));
       for (i = any = 0; prefs[i].type; i++)
 	{
 	  if (prefs[i].type == PREFTYPE_AEAD)
 	    {
 	      if (any)
 		tty_printf (", ");
 	      any = 1;
 	      /* We don't want to display strings for experimental algos */
 	      if (!openpgp_aead_test_algo (prefs[i].value)
 		  && prefs[i].value < 100)
 		tty_printf ("%s", openpgp_aead_algo_name (prefs[i].value));
 	      else
 		tty_printf ("[%d]", prefs[i].value);
 	    }
 	}
       tty_printf ("\n     ");
       tty_printf (_("Digest: "));
       for (i = any = 0; prefs[i].type; i++)
 	{
 	  if (prefs[i].type == PREFTYPE_HASH)
 	    {
 	      if (any)
 		tty_printf (", ");
 	      any = 1;
 	      /* We don't want to display strings for experimental algos */
 	      if (!gcry_md_test_algo (prefs[i].value) && prefs[i].value < 100)
 		tty_printf ("%s", gcry_md_algo_name (prefs[i].value));
 	      else
 		tty_printf ("[%d]", prefs[i].value);
 	      if (prefs[i].value == DIGEST_ALGO_SHA1)
 		sha1_seen = 1;
 	    }
 	}
       if (!sha1_seen)
 	{
 	  if (any)
 	    tty_printf (", ");
 	  tty_printf ("%s", gcry_md_algo_name (DIGEST_ALGO_SHA1));
 	}
       tty_printf ("\n     ");
       tty_printf (_("Compression: "));
       for (i = any = 0; prefs[i].type; i++)
 	{
 	  if (prefs[i].type == PREFTYPE_ZIP)
 	    {
 	      const char *s = compress_algo_to_string (prefs[i].value);
 
 	      if (any)
 		tty_printf (", ");
 	      any = 1;
 	      /* We don't want to display strings for experimental algos */
 	      if (s && prefs[i].value < 100)
 		tty_printf ("%s", s);
 	      else
 		tty_printf ("[%d]", prefs[i].value);
 	      if (prefs[i].value == COMPRESS_ALGO_NONE)
 		uncomp_seen = 1;
 	    }
 	}
       if (!uncomp_seen)
 	{
 	  if (any)
 	    tty_printf (", ");
 	  else
 	    {
 	      tty_printf ("%s", compress_algo_to_string (COMPRESS_ALGO_ZIP));
 	      tty_printf (", ");
 	    }
 	  tty_printf ("%s", compress_algo_to_string (COMPRESS_ALGO_NONE));
 	}
       if (uid->flags.mdc || uid->flags.aead || !uid->flags.ks_modify)
 	{
 	  tty_printf ("\n     ");
 	  tty_printf (_("Features: "));
 	  any = 0;
 	  if (uid->flags.mdc)
 	    {
 	      tty_printf ("MDC");
 	      any = 1;
 	    }
 	  if (uid->flags.aead)
 	    {
 	      if (any)
 		tty_printf (", ");
 	      tty_printf ("AEAD");
 	    }
 	  if (!uid->flags.ks_modify)
 	    {
 	      if (any)
 		tty_printf (", ");
 	      tty_printf (_("Keyserver no-modify"));
 	    }
 	}
       tty_printf ("\n");
 
       if (selfsig)
 	{
 	  const byte *pref_ks;
 	  size_t pref_ks_len;
 
 	  pref_ks = parse_sig_subpkt (selfsig, 1,
                                       SIGSUBPKT_PREF_KS, &pref_ks_len);
 	  if (pref_ks && pref_ks_len)
 	    {
 	      tty_printf ("     ");
 	      tty_printf (_("Preferred keyserver: "));
 	      tty_print_utf8_string (pref_ks, pref_ks_len);
 	      tty_printf ("\n");
 	    }
 
 	  if (selfsig->flags.notation)
 	    {
 	      tty_printf ("     ");
 	      tty_printf (_("Notations: "));
 	      tty_print_notations (5 + strlen (_("Notations: ")), selfsig);
 	    }
 	}
     }
   else
     {
       tty_printf ("    ");
       for (i = 0; prefs[i].type; i++)
 	{
 	  tty_printf (" %c%d", prefs[i].type == PREFTYPE_SYM ? 'S' :
 		      prefs[i].type == PREFTYPE_AEAD ? 'A' :
 		      prefs[i].type == PREFTYPE_HASH ? 'H' :
 		      prefs[i].type == PREFTYPE_ZIP ? 'Z' : '?',
 		      prefs[i].value);
 	}
       if (uid->flags.mdc)
 	tty_printf (" [mdc]");
       if (uid->flags.aead)
 	tty_printf (" [aead]");
       if (!uid->flags.ks_modify)
 	tty_printf (" [no-ks-modify]");
       tty_printf ("\n");
     }
 }
 
 
 /* This is the version of show_key_with_all_names used when
    opt.with_colons is used.  It prints all available data in a easy to
    parse format and does not translate utf8 */
 static void
 show_key_with_all_names_colon (ctrl_t ctrl, estream_t fp, kbnode_t keyblock)
 {
   KBNODE node;
   int i, j, ulti_hack = 0;
   byte pk_version = 0;
   PKT_public_key *primary = NULL;
   int have_seckey;
 
   if (!fp)
     fp = es_stdout;
 
   /* the keys */
   for (node = keyblock; node; node = node->next)
     {
       if (node->pkt->pkttype == PKT_PUBLIC_KEY
 	  || (node->pkt->pkttype == PKT_PUBLIC_SUBKEY))
 	{
 	  PKT_public_key *pk = node->pkt->pkt.public_key;
 	  u32 keyid[2];
 
 	  if (node->pkt->pkttype == PKT_PUBLIC_KEY)
 	    {
 	      pk_version = pk->version;
 	      primary = pk;
 	    }
 
 	  keyid_from_pk (pk, keyid);
           have_seckey = agent_probe_secret_key (ctrl, pk);
 
           if (node->pkt->pkttype == PKT_PUBLIC_KEY)
             es_fputs (have_seckey? "sec:" : "pub:", fp);
           else
             es_fputs (have_seckey? "ssb:" : "sub:", fp);
 
 	  if (!pk->flags.valid)
 	    es_putc ('i', fp);
 	  else if (pk->flags.revoked)
 	    es_putc ('r', fp);
 	  else if (pk->has_expired)
 	    es_putc ('e', fp);
 	  else if (!(opt.fast_list_mode || opt.no_expensive_trust_checks))
 	    {
 	      int trust = get_validity_info (ctrl, keyblock, pk, NULL);
 	      if (trust == 'u')
 		ulti_hack = 1;
 	      es_putc (trust, fp);
 	    }
 
 	  es_fprintf (fp, ":%u:%d:%08lX%08lX:%lu:%lu::",
                       nbits_from_pk (pk),
                       pk->pubkey_algo,
                       (ulong) keyid[0], (ulong) keyid[1],
                       (ulong) pk->timestamp, (ulong) pk->expiredate);
 	  if (node->pkt->pkttype == PKT_PUBLIC_KEY
 	      && !(opt.fast_list_mode || opt.no_expensive_trust_checks))
 	    es_putc (get_ownertrust_info (ctrl, pk, 0), fp);
 	  es_putc (':', fp);
 	  es_putc (':', fp);
 	  es_putc (':', fp);
 	  /* Print capabilities.  */
 	  if ((pk->pubkey_usage & PUBKEY_USAGE_ENC))
 	    es_putc ('e', fp);
 	  if ((pk->pubkey_usage & PUBKEY_USAGE_SIG))
 	    es_putc ('s', fp);
 	  if ((pk->pubkey_usage & PUBKEY_USAGE_CERT))
 	    es_putc ('c', fp);
 	  if ((pk->pubkey_usage & PUBKEY_USAGE_AUTH))
 	    es_putc ('a', fp);
 	  es_putc ('\n', fp);
 
 	  print_fingerprint (ctrl, fp, pk, 0);
 	  print_revokers (fp, pk);
 	}
     }
 
   /* the user ids */
   i = 0;
   for (node = keyblock; node; node = node->next)
     {
       if (node->pkt->pkttype == PKT_USER_ID)
 	{
 	  PKT_user_id *uid = node->pkt->pkt.user_id;
 
 	  ++i;
 
 	  if (uid->attrib_data)
 	    es_fputs ("uat:", fp);
 	  else
 	    es_fputs ("uid:", fp);
 
 	  if (uid->flags.revoked)
 	    es_fputs ("r::::::::", fp);
 	  else if (uid->flags.expired)
 	    es_fputs ("e::::::::", fp);
 	  else if (opt.fast_list_mode || opt.no_expensive_trust_checks)
 	    es_fputs ("::::::::", fp);
 	  else
 	    {
 	      int uid_validity;
 
 	      if (primary && !ulti_hack)
 		uid_validity = get_validity_info (ctrl, keyblock, primary, uid);
 	      else
 		uid_validity = 'u';
 	      es_fprintf (fp, "%c::::::::", uid_validity);
 	    }
 
 	  if (uid->attrib_data)
 	    es_fprintf (fp, "%u %lu", uid->numattribs, uid->attrib_len);
 	  else
 	    es_write_sanitized (fp, uid->name, uid->len, ":", NULL);
 
 	  es_putc (':', fp);
 	  /* signature class */
 	  es_putc (':', fp);
 	  /* capabilities */
 	  es_putc (':', fp);
 	  /* preferences */
 	  if (pk_version > 3 || uid->selfsigversion > 3)
 	    {
 	      const prefitem_t *prefs = uid->prefs;
 
 	      for (j = 0; prefs && prefs[j].type; j++)
 		{
 		  if (j)
 		    es_putc (' ', fp);
 		  es_fprintf (fp,
                               "%c%d", prefs[j].type == PREFTYPE_SYM ? 'S' :
                               prefs[j].type == PREFTYPE_HASH ? 'H' :
                               prefs[j].type == PREFTYPE_ZIP ? 'Z' : '?',
                               prefs[j].value);
 		}
 	      if (uid->flags.mdc)
 		es_fputs (",mdc", fp);
 	      if (uid->flags.aead)
 		es_fputs (",aead", fp);
 	      if (!uid->flags.ks_modify)
 		es_fputs (",no-ks-modify", fp);
 	    }
 	  es_putc (':', fp);
 	  /* flags */
 	  es_fprintf (fp, "%d,", i);
 	  if (uid->flags.primary)
 	    es_putc ('p', fp);
 	  if (uid->flags.revoked)
 	    es_putc ('r', fp);
 	  if (uid->flags.expired)
 	    es_putc ('e', fp);
 	  if ((node->flag & NODFLG_SELUID))
 	    es_putc ('s', fp);
 	  if ((node->flag & NODFLG_MARK_A))
 	    es_putc ('m', fp);
 	  es_putc (':', fp);
 	  if (opt.trust_model == TM_TOFU || opt.trust_model == TM_TOFU_PGP)
 	    {
 #ifdef USE_TOFU
 	      enum tofu_policy policy;
 	      if (! tofu_get_policy (ctrl, primary, uid, &policy)
 		  && policy != TOFU_POLICY_NONE)
 		es_fprintf (fp, "%s", tofu_policy_str (policy));
 #endif /*USE_TOFU*/
 	    }
 	  es_putc (':', fp);
 	  es_putc ('\n', fp);
 	}
     }
 }
 
 
 static void
 show_names (ctrl_t ctrl, estream_t fp,
             kbnode_t keyblock, PKT_public_key * pk, unsigned int flag,
 	    int with_prefs)
 {
   KBNODE node;
   int i = 0;
 
   for (node = keyblock; node; node = node->next)
     {
       if (node->pkt->pkttype == PKT_USER_ID && !is_deleted_kbnode (node))
 	{
 	  PKT_user_id *uid = node->pkt->pkt.user_id;
 	  ++i;
 	  if (!flag || (flag && (node->flag & flag)))
 	    {
 	      if (!(flag & NODFLG_MARK_A) && pk)
 		tty_fprintf (fp, "%s ", uid_trust_string_fixed (ctrl, pk, uid));
 
 	      if (flag & NODFLG_MARK_A)
 		tty_fprintf (fp, "     ");
 	      else if (node->flag & NODFLG_SELUID)
 		tty_fprintf (fp, "(%d)* ", i);
 	      else if (uid->flags.primary)
 		tty_fprintf (fp, "(%d). ", i);
 	      else
 		tty_fprintf (fp, "(%d)  ", i);
 	      tty_print_utf8_string2 (fp, uid->name, uid->len, 0);
 	      tty_fprintf (fp, "\n");
 	      if (with_prefs && pk)
 		{
 		  if (pk->version > 3 || uid->selfsigversion > 3)
 		    {
 		      PKT_signature *selfsig = NULL;
 		      KBNODE signode;
 
 		      for (signode = node->next;
 			   signode && signode->pkt->pkttype == PKT_SIGNATURE;
 			   signode = signode->next)
 			{
 			  if (signode->pkt->pkt.signature->
 			      flags.chosen_selfsig)
 			    {
 			      selfsig = signode->pkt->pkt.signature;
 			      break;
 			    }
 			}
 
 		      show_prefs (uid, selfsig, with_prefs == 2);
 		    }
 		  else
 		    tty_fprintf (fp, _("There are no preferences on a"
                                        " PGP 2.x-style user ID.\n"));
 		}
 	    }
 	}
     }
 }
 
 
 /*
  * Display the key a the user ids, if only_marked is true, do only so
  * for user ids with mark A flag set and do not display the index
  * number.  If FP is not NULL print to the given stream and not to the
  * tty (ignored in with-colons mode).
  */
 static void
 show_key_with_all_names (ctrl_t ctrl, estream_t fp,
                          KBNODE keyblock, int only_marked, int with_revoker,
 			 int with_fpr, int with_subkeys, int with_prefs,
                          int nowarn)
 {
   gpg_error_t err;
   kbnode_t node;
   int i;
   int do_warn = 0;
   int have_seckey = 0;
   char *serialno = NULL;
   PKT_public_key *primary = NULL;
   char pkstrbuf[PUBKEY_STRING_SIZE];
 
   if (opt.with_colons)
     {
       show_key_with_all_names_colon (ctrl, fp, keyblock);
       return;
     }
 
   /* the keys */
   for (node = keyblock; node; node = node->next)
     {
       if (node->pkt->pkttype == PKT_PUBLIC_KEY
 	  || (with_subkeys && node->pkt->pkttype == PKT_PUBLIC_SUBKEY
 	      && !is_deleted_kbnode (node)))
 	{
 	  PKT_public_key *pk = node->pkt->pkt.public_key;
 	  const char *otrust = "err";
 	  const char *trust = "err";
 
 	  if (node->pkt->pkttype == PKT_PUBLIC_KEY)
 	    {
 	      /* do it here, so that debug messages don't clutter the
 	       * output */
 	      static int did_warn = 0;
 
 	      trust = get_validity_string (ctrl, pk, NULL);
 	      otrust = get_ownertrust_string (ctrl, pk, 0);
 
 	      /* Show a warning once */
 	      if (!did_warn
 		  && (get_validity (ctrl, keyblock, pk, NULL, NULL, 0)
 		      & TRUST_FLAG_PENDING_CHECK))
 		{
 		  did_warn = 1;
 		  do_warn = 1;
 		}
 
 	      primary = pk;
 	    }
 
 	  if (pk->flags.revoked)
 	    {
 	      char *user = get_user_id_string_native (ctrl, pk->revoked.keyid);
               tty_fprintf (fp,
                            _("The following key was revoked on"
                             " %s by %s key %s\n"),
 			  revokestr_from_pk (pk),
                           gcry_pk_algo_name (pk->revoked.algo), user);
 	      xfree (user);
 	    }
 
 	  if (with_revoker)
 	    {
 	      if (!pk->revkey && pk->numrevkeys)
 		BUG ();
 	      else
 		for (i = 0; i < pk->numrevkeys; i++)
 		  {
 		    u32 r_keyid[2];
 		    char *user;
 		    const char *algo;
 
 		    algo = gcry_pk_algo_name (pk->revkey[i].algid);
 		    keyid_from_fingerprint (ctrl, pk->revkey[i].fpr,
 					    pk->revkey[i].fprlen, r_keyid);
 
 		    user = get_user_id_string_native (ctrl, r_keyid);
 		    tty_fprintf (fp,
                                  _("This key may be revoked by %s key %s"),
                                  algo ? algo : "?", user);
 
 		    if (pk->revkey[i].class & 0x40)
 		      {
 			tty_fprintf (fp, " ");
 			tty_fprintf (fp, _("(sensitive)"));
 		      }
 
 		    tty_fprintf (fp, "\n");
 		    xfree (user);
 		  }
 	    }
 
 	  keyid_from_pk (pk, NULL);
 
           xfree (serialno);
           serialno = NULL;
           {
             char *hexgrip;
 
             err = hexkeygrip_from_pk (pk, &hexgrip);
             if (err)
               {
                 log_error ("error computing a keygrip: %s\n",
                            gpg_strerror (err));
                 have_seckey = 0;
               }
             else
               have_seckey = !agent_get_keyinfo (ctrl, hexgrip, &serialno, NULL);
             xfree (hexgrip);
           }
 
 	  tty_fprintf
             (fp, "%s%c %s/%s",
              node->pkt->pkttype == PKT_PUBLIC_KEY && have_seckey? "sec" :
              node->pkt->pkttype == PKT_PUBLIC_KEY ?               "pub" :
              have_seckey ?                                        "ssb" :
                                                                   "sub",
              (node->flag & NODFLG_SELKEY) ? '*' : ' ',
              pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
              keystr (pk->keyid));
 
           if (opt.legacy_list_mode)
             tty_fprintf (fp, "  ");
           else
             tty_fprintf (fp, "\n     ");
 
           tty_fprintf (fp, _("created: %s"), datestr_from_pk (pk));
 	  tty_fprintf (fp, "  ");
 	  if (pk->flags.revoked)
 	    tty_fprintf (fp, _("revoked: %s"), revokestr_from_pk (pk));
 	  else if (pk->has_expired)
 	    tty_fprintf (fp, _("expired: %s"), expirestr_from_pk (pk));
 	  else
 	    tty_fprintf (fp, _("expires: %s"), expirestr_from_pk (pk));
 	  tty_fprintf (fp, "  ");
 	  tty_fprintf (fp, _("usage: %s"), usagestr_from_pk (pk, 1));
 	  tty_fprintf (fp, "\n");
 
           if (serialno)
             {
               /* The agent told us that a secret key is available and
                  that it has been stored on a card.  */
 	      tty_fprintf (fp, "%*s%s", opt.legacy_list_mode? 21:5, "",
                            _("card-no: "));
               if (strlen (serialno) == 32
                   && !strncmp (serialno, "D27600012401", 12))
                 {
                   /* This is an OpenPGP card.  Print the relevant part.  */
                   /* Example: D2760001240101010001000003470000 */
                   /*                          xxxxyyyyyyyy     */
                   tty_fprintf (fp, "%.*s %.*s\n",
                                4, serialno+16, 8, serialno+20);
                 }
               else
                 tty_fprintf (fp, "%s\n", serialno);
 
             }
 	  else if (pk->seckey_info
               && pk->seckey_info->is_protected
               && pk->seckey_info->s2k.mode == 1002)
 	    {
               /* FIXME: Check whether this code path is still used.  */
 	      tty_fprintf (fp, "%*s%s", opt.legacy_list_mode? 21:5, "",
                            _("card-no: "));
 	      if (pk->seckey_info->ivlen == 16
 		  && !memcmp (pk->seckey_info->iv,
                               "\xD2\x76\x00\x01\x24\x01", 6))
 		{
                   /* This is an OpenPGP card. */
 		  for (i = 8; i < 14; i++)
 		    {
 		      if (i == 10)
 			tty_fprintf (fp, " ");
 		      tty_fprintf (fp, "%02X", pk->seckey_info->iv[i]);
 		    }
 		}
 	      else
 		{
                   /* Unknown card: Print all. */
 		  for (i = 0; i < pk->seckey_info->ivlen; i++)
 		    tty_fprintf (fp, "%02X", pk->seckey_info->iv[i]);
 		}
 	      tty_fprintf (fp, "\n");
 	    }
 
 	  if (node->pkt->pkttype == PKT_PUBLIC_KEY
               || node->pkt->pkttype == PKT_SECRET_KEY)
 	    {
 	      if (opt.trust_model != TM_ALWAYS)
 		{
 		  tty_fprintf (fp, "%*s",
                                opt.legacy_list_mode?
                                ((int) keystrlen () + 13):5, "");
 		  /* Ownertrust is only meaningful for the PGP or
 		     classic trust models, or PGP combined with TOFU */
 		  if (opt.trust_model == TM_PGP
 		      || opt.trust_model == TM_CLASSIC
 		      || opt.trust_model == TM_TOFU_PGP)
 		    {
 		      int width = 14 - strlen (otrust);
 		      if (width <= 0)
 			width = 1;
 		      tty_fprintf (fp, _("trust: %s"), otrust);
 		      tty_fprintf (fp, "%*s", width, "");
 		    }
 
 		  tty_fprintf (fp, _("validity: %s"), trust);
 		  tty_fprintf (fp, "\n");
 		}
 	      if (node->pkt->pkttype == PKT_PUBLIC_KEY
 		  && (get_ownertrust (ctrl, pk) & TRUST_FLAG_DISABLED))
 		{
 		  tty_fprintf (fp, "*** ");
 		  tty_fprintf (fp, _("This key has been disabled"));
 		  tty_fprintf (fp, "\n");
 		}
 	    }
 
 	  if ((node->pkt->pkttype == PKT_PUBLIC_KEY
                || node->pkt->pkttype == PKT_SECRET_KEY) && with_fpr)
 	    {
               print_fingerprint (ctrl, fp, pk, 2);
 	      tty_fprintf (fp, "\n");
 	    }
 	}
     }
 
   show_names (ctrl, fp,
               keyblock, primary, only_marked ? NODFLG_MARK_A : 0, with_prefs);
 
   if (do_warn && !nowarn)
     tty_fprintf (fp, _("Please note that the shown key validity"
                        " is not necessarily correct\n"
                        "unless you restart the program.\n"));
 
   xfree (serialno);
 }
 
 
 /* Display basic key information.  This function is suitable to show
  * information on the key without any dependencies on the trustdb or
  * any other internal GnuPG stuff.  KEYBLOCK may either be a public or
  * a secret key.  This function may be called with KEYBLOCK containing
  * secret keys and thus the printing of "pub" vs. "sec" does only
  * depend on the packet type and not by checking with gpg-agent.  If
  * PRINT_SEC is set "sec" is printed instead of "pub".  */
 void
 show_basic_key_info (ctrl_t ctrl, kbnode_t keyblock, int print_sec)
 {
   KBNODE node;
   int i;
   char pkstrbuf[PUBKEY_STRING_SIZE];
 
   /* The primary key */
   for (node = keyblock; node; node = node->next)
     {
       if (node->pkt->pkttype == PKT_PUBLIC_KEY
           || node->pkt->pkttype == PKT_SECRET_KEY)
 	{
 	  PKT_public_key *pk = node->pkt->pkt.public_key;
           const char *tag;
 
           if (node->pkt->pkttype == PKT_SECRET_KEY || print_sec)
             tag = "sec";
           else
             tag = "pub";
 
 	  /* Note, we use the same format string as in other show
 	     functions to make the translation job easier. */
 	  tty_printf ("%s  %s/%s  ",
                       tag,
                       pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
 		      keystr_from_pk (pk));
 	  tty_printf (_("created: %s"), datestr_from_pk (pk));
 	  tty_printf ("  ");
 	  tty_printf (_("expires: %s"), expirestr_from_pk (pk));
 	  tty_printf ("\n");
 	  print_fingerprint (ctrl, NULL, pk, 3);
 	  tty_printf ("\n");
 	}
     }
 
   /* The user IDs. */
   for (i = 0, node = keyblock; node; node = node->next)
     {
       if (node->pkt->pkttype == PKT_USER_ID)
 	{
 	  PKT_user_id *uid = node->pkt->pkt.user_id;
 	  ++i;
 
 	  tty_printf ("     ");
 	  if (uid->flags.revoked)
 	    tty_printf ("[%s] ", _("revoked"));
 	  else if (uid->flags.expired)
 	    tty_printf ("[%s] ", _("expired"));
 	  tty_print_utf8_string (uid->name, uid->len);
 	  tty_printf ("\n");
 	}
     }
 }
 
 
 static void
 show_key_and_fingerprint (ctrl_t ctrl, kbnode_t keyblock, int with_subkeys)
 {
   kbnode_t node;
   PKT_public_key *pk = NULL;
   char pkstrbuf[PUBKEY_STRING_SIZE];
 
   for (node = keyblock; node; node = node->next)
     {
       if (node->pkt->pkttype == PKT_PUBLIC_KEY)
 	{
 	  pk = node->pkt->pkt.public_key;
 	  tty_printf ("pub   %s/%s %s ",
                       pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
                       keystr_from_pk(pk),
                       datestr_from_pk (pk));
 	}
       else if (node->pkt->pkttype == PKT_USER_ID)
 	{
 	  PKT_user_id *uid = node->pkt->pkt.user_id;
 	  tty_print_utf8_string (uid->name, uid->len);
 	  break;
 	}
     }
   tty_printf ("\n");
   if (pk)
     print_fingerprint (ctrl, NULL, pk, 2);
   if (with_subkeys)
     {
       for (node = keyblock; node; node = node->next)
         {
           if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
             {
               pk = node->pkt->pkt.public_key;
               tty_printf ("sub   %s/%s %s [%s]\n",
                           pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
                           keystr_from_pk(pk),
                           datestr_from_pk (pk),
                           usagestr_from_pk (pk, 0));
 
               print_fingerprint (ctrl, NULL, pk, 4);
             }
         }
     }
 }
 
 
 /* Show a listing of the primary and its subkeys along with their
    keygrips.  */
 static void
 show_key_and_grip (kbnode_t keyblock)
 {
   kbnode_t node;
   PKT_public_key *pk = NULL;
   char pkstrbuf[PUBKEY_STRING_SIZE];
   char *hexgrip;
 
   for (node = keyblock; node; node = node->next)
     {
       if (node->pkt->pkttype == PKT_PUBLIC_KEY
           || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
         {
           pk = node->pkt->pkt.public_key;
           tty_printf ("%s   %s/%s %s [%s]\n",
                       node->pkt->pkttype == PKT_PUBLIC_KEY? "pub":"sub",
                       pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
                       keystr_from_pk(pk),
                       datestr_from_pk (pk),
                       usagestr_from_pk (pk, 0));
 
           if (!hexkeygrip_from_pk (pk, &hexgrip))
             {
               tty_printf ("      Keygrip: %s\n", hexgrip);
               xfree (hexgrip);
             }
         }
     }
 }
 
 
 /* Show a warning if no uids on the key have the primary uid flag
    set. */
 static void
 no_primary_warning (KBNODE keyblock)
 {
   KBNODE node;
   int have_primary = 0, uid_count = 0;
 
   /* TODO: if we ever start behaving differently with a primary or
      non-primary attribute ID, we will need to check for attributes
      here as well. */
 
   for (node = keyblock; node; node = node->next)
     {
       if (node->pkt->pkttype == PKT_USER_ID
 	  && node->pkt->pkt.user_id->attrib_data == NULL)
 	{
 	  uid_count++;
 
 	  if (node->pkt->pkt.user_id->flags.primary == 2)
 	    {
 	      have_primary = 1;
 	      break;
 	    }
 	}
     }
 
   if (uid_count > 1 && !have_primary)
     log_info (_
 	      ("WARNING: no user ID has been marked as primary.  This command"
 	       " may\n              cause a different user ID to become"
 	       " the assumed primary.\n"));
 }
 
 
 /* Print a warning if the latest encryption subkey expires soon.  This
    function is called after the expire data of the primary key has
    been changed.  */
 static void
 subkey_expire_warning (kbnode_t keyblock)
 {
   u32 curtime = make_timestamp ();
   kbnode_t node;
   PKT_public_key *pk;
   /* u32 mainexpire = 0; */
   u32 subexpire = 0;
   u32 latest_date = 0;
 
   for (node = keyblock; node; node = node->next)
     {
       /* if (node->pkt->pkttype == PKT_PUBLIC_KEY) */
       /*   { */
       /*     pk = node->pkt->pkt.public_key; */
       /*     mainexpire = pk->expiredate; */
       /*   } */
 
       if (node->pkt->pkttype != PKT_PUBLIC_SUBKEY)
         continue;
       pk = node->pkt->pkt.public_key;
 
       if (!pk->flags.valid)
         continue;
       if (pk->flags.revoked)
         continue;
       if (pk->timestamp > curtime)
         continue; /* Ignore future keys.  */
       if (!(pk->pubkey_usage & PUBKEY_USAGE_ENC))
         continue; /* Not an encryption key.  */
 
       if (pk->timestamp > latest_date || (!pk->timestamp && !latest_date))
         {
           latest_date = pk->timestamp;
           subexpire = pk->expiredate;
         }
     }
 
   if (!subexpire)
     return;  /* No valid subkey with an expiration time.  */
 
   if (curtime + (10*86400) > subexpire)
     {
       log_info (_("WARNING: Your encryption subkey expires soon.\n"));
       log_info (_("You may want to change its expiration date too.\n"));
     }
 }
 
 
 /*
  * Ask for a new user id, add the self-signature, and update the
  * keyblock.  If UIDSTRING is not NULL the user ID is generated
  * unattended using that string.  UIDSTRING is expected to be utf-8
  * encoded and white space trimmed.  Returns true if there is a new
  * user id.
  */
 static int
 menu_adduid (ctrl_t ctrl, kbnode_t pub_keyblock,
              int photo, const char *photo_name, const char *uidstring)
 {
   PKT_user_id *uid;
   PKT_public_key *pk = NULL;
   PKT_signature *sig = NULL;
   PACKET *pkt;
   KBNODE node;
   KBNODE pub_where = NULL;
   gpg_error_t err;
 
   if (photo && uidstring)
     return 0;  /* Not allowed.  */
 
   for (node = pub_keyblock; node; pub_where = node, node = node->next)
     {
       if (node->pkt->pkttype == PKT_PUBLIC_KEY)
 	pk = node->pkt->pkt.public_key;
       else if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
 	break;
     }
   if (!node) /* No subkey.  */
     pub_where = NULL;
   log_assert (pk);
 
   if (photo)
     {
       int hasattrib = 0;
 
       for (node = pub_keyblock; node; node = node->next)
 	if (node->pkt->pkttype == PKT_USER_ID &&
 	    node->pkt->pkt.user_id->attrib_data != NULL)
 	  {
 	    hasattrib = 1;
 	    break;
 	  }
 
       /* It is legal but bad for compatibility to add a photo ID to a
          v3 key as it means that PGP2 will not be able to use that key
          anymore.  Also, PGP may not expect a photo on a v3 key.
          Don't bother to ask this if the key already has a photo - any
          damage has already been done at that point. -dms */
       if (pk->version == 3 && !hasattrib)
 	{
 	  if (opt.expert)
 	    {
 	      tty_printf (_("WARNING: This is a PGP2-style key.  "
 			    "Adding a photo ID may cause some versions\n"
 			    "         of PGP to reject this key.\n"));
 
 	      if (!cpr_get_answer_is_yes ("keyedit.v3_photo.okay",
 					  _("Are you sure you still want "
 					    "to add it? (y/N) ")))
 		return 0;
 	    }
 	  else
 	    {
 	      tty_printf (_("You may not add a photo ID to "
 			    "a PGP2-style key.\n"));
 	      return 0;
 	    }
 	}
 
       uid = generate_photo_id (ctrl, pk, photo_name);
     }
   else
     uid = generate_user_id (pub_keyblock, uidstring);
   if (!uid)
     {
       if (uidstring)
         {
           write_status_error ("adduid", gpg_error (304));
           log_error ("%s", _("Such a user ID already exists on this key!\n"));
         }
       return 0;
     }
 
   err = make_keysig_packet (ctrl, &sig, pk, uid, NULL, pk, 0x13, 0, 0,
                             keygen_add_std_prefs, pk, NULL);
   if (err)
     {
       write_status_error ("keysig", err);
       log_error ("signing failed: %s\n", gpg_strerror (err));
       free_user_id (uid);
       return 0;
     }
 
   /* Insert/append to public keyblock */
   pkt = xmalloc_clear (sizeof *pkt);
   pkt->pkttype = PKT_USER_ID;
   pkt->pkt.user_id = uid;
   node = new_kbnode (pkt);
   if (pub_where)
     insert_kbnode (pub_where, node, 0);
   else
     add_kbnode (pub_keyblock, node);
   pkt = xmalloc_clear (sizeof *pkt);
   pkt->pkttype = PKT_SIGNATURE;
   pkt->pkt.signature = sig;
   if (pub_where)
     insert_kbnode (node, new_kbnode (pkt), 0);
   else
     add_kbnode (pub_keyblock, new_kbnode (pkt));
   return 1;
 }
 
 
 /*
  * Remove all selected userids from the keyring
  */
 static void
 menu_deluid (KBNODE pub_keyblock)
 {
   KBNODE node;
   int selected = 0;
 
   for (node = pub_keyblock; node; node = node->next)
     {
       if (node->pkt->pkttype == PKT_USER_ID)
 	{
 	  selected = node->flag & NODFLG_SELUID;
 	  if (selected)
 	    {
 	      /* Only cause a trust update if we delete a
 	         non-revoked user id */
 	      if (!node->pkt->pkt.user_id->flags.revoked)
 		update_trust = 1;
 	      delete_kbnode (node);
 	    }
 	}
       else if (selected && node->pkt->pkttype == PKT_SIGNATURE)
 	delete_kbnode (node);
       else if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
 	selected = 0;
     }
   commit_kbnode (&pub_keyblock);
 }
 
 
 static int
 menu_delsig (ctrl_t ctrl, kbnode_t pub_keyblock)
 {
   KBNODE node;
   PKT_user_id *uid = NULL;
   int changed = 0;
 
   for (node = pub_keyblock; node; node = node->next)
     {
       if (node->pkt->pkttype == PKT_USER_ID)
 	{
 	  uid = (node->flag & NODFLG_SELUID) ? node->pkt->pkt.user_id : NULL;
 	}
       else if (uid && node->pkt->pkttype == PKT_SIGNATURE)
 	{
 	  int okay, valid, selfsig, inv_sig, no_key, other_err;
 
 	  tty_printf ("uid  ");
 	  tty_print_utf8_string (uid->name, uid->len);
 	  tty_printf ("\n");
 
 	  okay = inv_sig = no_key = other_err = 0;
 	  if (opt.with_colons)
 	    valid = print_and_check_one_sig_colon (ctrl, pub_keyblock, node,
 						   &inv_sig, &no_key,
 						   &other_err, &selfsig, 1);
 	  else
 	    valid = print_and_check_one_sig (ctrl, pub_keyblock, node,
 					     &inv_sig, &no_key, &other_err,
 					     &selfsig, 1, 0);
 
 	  if (valid)
 	    {
 	      okay = cpr_get_answer_yes_no_quit
                 ("keyedit.delsig.valid",
                  _("Delete this good signature? (y/N/q)"));
 
 	      /* Only update trust if we delete a good signature.
 	         The other two cases do not affect trust. */
 	      if (okay)
 		update_trust = 1;
 	    }
 	  else if (inv_sig || other_err)
 	    okay = cpr_get_answer_yes_no_quit
               ("keyedit.delsig.invalid",
                _("Delete this invalid signature? (y/N/q)"));
 	  else if (no_key)
 	    okay = cpr_get_answer_yes_no_quit
               ("keyedit.delsig.unknown",
                _("Delete this unknown signature? (y/N/q)"));
 
 	  if (okay == -1)
 	    break;
 	  if (okay && selfsig
 	      && !cpr_get_answer_is_yes
               ("keyedit.delsig.selfsig",
                _("Really delete this self-signature? (y/N)")))
 	    okay = 0;
 	  if (okay)
 	    {
 	      delete_kbnode (node);
 	      changed++;
 	    }
 
 	}
       else if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
 	uid = NULL;
     }
 
   if (changed)
     {
       commit_kbnode (&pub_keyblock);
       tty_printf (ngettext("Deleted %d signature.\n",
                            "Deleted %d signatures.\n", changed), changed);
     }
   else
     tty_printf (_("Nothing deleted.\n"));
 
   return changed;
 }
 
 
 static int
 menu_clean (ctrl_t ctrl, kbnode_t keyblock, int self_only)
 {
   KBNODE uidnode;
   int modified = 0, select_all = !count_selected_uids (keyblock);
 
   for (uidnode = keyblock->next;
        uidnode && uidnode->pkt->pkttype != PKT_PUBLIC_SUBKEY;
        uidnode = uidnode->next)
     {
       if (uidnode->pkt->pkttype == PKT_USER_ID
 	  && (uidnode->flag & NODFLG_SELUID || select_all))
 	{
 	  int uids = 0, sigs = 0;
 	  char *user = utf8_to_native (uidnode->pkt->pkt.user_id->name,
 				       uidnode->pkt->pkt.user_id->len,
 				       0);
 
 	  clean_one_uid (ctrl, keyblock, uidnode, opt.verbose, self_only, &uids,
 			 &sigs);
 	  if (uids)
 	    {
 	      const char *reason;
 
 	      if (uidnode->pkt->pkt.user_id->flags.revoked)
 		reason = _("revoked");
 	      else if (uidnode->pkt->pkt.user_id->flags.expired)
 		reason = _("expired");
 	      else
 		reason = _("invalid");
 
 	      tty_printf (_("User ID \"%s\" compacted: %s\n"), user, reason);
 
 	      modified = 1;
 	    }
 	  else if (sigs)
 	    {
 	      tty_printf (ngettext("User ID \"%s\": %d signature removed\n",
                                    "User ID \"%s\": %d signatures removed\n",
                                    sigs), user, sigs);
 	      modified = 1;
 	    }
 	  else
 	    {
 	      tty_printf (self_only == 1 ?
 			  _("User ID \"%s\": already minimized\n") :
 			  _("User ID \"%s\": already clean\n"), user);
 	    }
 
 	  xfree (user);
 	}
     }
 
   return modified;
 }
 
 
 /*
  * Remove some of the secondary keys
  */
 static void
 menu_delkey (KBNODE pub_keyblock)
 {
   KBNODE node;
   int selected = 0;
 
   for (node = pub_keyblock; node; node = node->next)
     {
       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
 	{
 	  selected = node->flag & NODFLG_SELKEY;
 	  if (selected)
             delete_kbnode (node);
 	}
       else if (selected && node->pkt->pkttype == PKT_SIGNATURE)
 	delete_kbnode (node);
       else
 	selected = 0;
     }
   commit_kbnode (&pub_keyblock);
 
   /* No need to set update_trust here since signing keys are no
      longer used to certify other keys, so there is no change in
      trust when revoking/removing them.   */
 }
 
 
 /*
  * Ask for a new revoker, create the self-signature and put it into
  * the keyblock.  Returns true if there is a new revoker.
  */
 static int
 menu_addrevoker (ctrl_t ctrl, kbnode_t pub_keyblock, int sensitive)
 {
   PKT_public_key *pk = NULL;
   PKT_public_key *revoker_pk = NULL;
   PKT_signature *sig = NULL;
   PACKET *pkt;
   struct revocation_key revkey;
   size_t fprlen;
   int rc;
 
   log_assert (pub_keyblock->pkt->pkttype == PKT_PUBLIC_KEY);
 
   pk = pub_keyblock->pkt->pkt.public_key;
 
   if (pk->numrevkeys == 0 && pk->version == 3)
     {
       /* It is legal but bad for compatibility to add a revoker to a
          v3 key as it means that PGP2 will not be able to use that key
          anymore.  Also, PGP may not expect a revoker on a v3 key.
          Don't bother to ask this if the key already has a revoker -
          any damage has already been done at that point. -dms */
       if (opt.expert)
 	{
 	  tty_printf (_("WARNING: This is a PGP 2.x-style key.  "
 			"Adding a designated revoker may cause\n"
 			"         some versions of PGP to reject this key.\n"));
 
 	  if (!cpr_get_answer_is_yes ("keyedit.v3_revoker.okay",
 				      _("Are you sure you still want "
 					"to add it? (y/N) ")))
 	    return 0;
 	}
       else
 	{
 	  tty_printf (_("You may not add a designated revoker to "
 			"a PGP 2.x-style key.\n"));
 	  return 0;
 	}
     }
 
   for (;;)
     {
       char *answer;
 
       free_public_key (revoker_pk);
       revoker_pk = xmalloc_clear (sizeof (*revoker_pk));
 
       tty_printf ("\n");
 
       answer = cpr_get_utf8
         ("keyedit.add_revoker",
          _("Enter the user ID of the designated revoker: "));
       if (answer[0] == '\0' || answer[0] == CONTROL_D)
 	{
 	  xfree (answer);
 	  goto fail;
 	}
 
       /* Note that I'm requesting CERT here, which usually implies
          primary keys only, but some casual testing shows that PGP and
          GnuPG both can handle a designated revocation from a subkey. */
       revoker_pk->req_usage = PUBKEY_USAGE_CERT;
       rc = get_pubkey_byname (ctrl, GET_PUBKEY_NO_AKL,
                               NULL, revoker_pk, answer, NULL, NULL, 1);
       if (rc)
 	{
 	  log_error (_("key \"%s\" not found: %s\n"), answer,
 		     gpg_strerror (rc));
 	  xfree (answer);
 	  continue;
 	}
 
       xfree (answer);
 
       fingerprint_from_pk (revoker_pk, revkey.fpr, &fprlen);
       if (fprlen != 20 && fprlen != 32)
 	{
 	  log_error (_("cannot appoint a PGP 2.x style key as a "
 		       "designated revoker\n"));
 	  continue;
 	}
 
       revkey.fprlen = fprlen;
       revkey.class = 0x80;
       if (sensitive)
 	revkey.class |= 0x40;
       revkey.algid = revoker_pk->pubkey_algo;
 
       if (cmp_public_keys (revoker_pk, pk) == 0)
 	{
 	  /* This actually causes no harm (after all, a key that
 	     designates itself as a revoker is the same as a
 	     regular key), but it's easy enough to check. */
 	  log_error (_("you cannot appoint a key as its own "
 		       "designated revoker\n"));
 
 	  continue;
 	}
 
       keyid_from_pk (pk, NULL);
 
       /* Does this revkey already exist? */
       if (!pk->revkey && pk->numrevkeys)
 	BUG ();
       else
 	{
 	  int i;
 
 	  for (i = 0; i < pk->numrevkeys; i++)
 	    {
 	      if (memcmp (&pk->revkey[i], &revkey,
 			  sizeof (struct revocation_key)) == 0)
 		{
 		  char buf[50];
 
 		  log_error (_("this key has already been designated "
 			       "as a revoker\n"));
 
                   format_keyid (pk_keyid (pk), KF_LONG, buf, sizeof (buf));
 		  write_status_text (STATUS_ALREADY_SIGNED, buf);
 
 		  break;
 		}
 	    }
 
 	  if (i < pk->numrevkeys)
 	    continue;
 	}
 
       print_key_info (ctrl, NULL, 0, revoker_pk, 0);
       print_fingerprint (ctrl, NULL, revoker_pk, 2);
       tty_printf ("\n");
 
       tty_printf (_("WARNING: appointing a key as a designated revoker "
 		    "cannot be undone!\n"));
 
       tty_printf ("\n");
 
       if (!cpr_get_answer_is_yes ("keyedit.add_revoker.okay",
 				  _("Are you sure you want to appoint this "
 				    "key as a designated revoker? (y/N) ")))
 	continue;
 
       free_public_key (revoker_pk);
       revoker_pk = NULL;
       break;
     }
 
   rc = make_keysig_packet (ctrl, &sig, pk, NULL, NULL, pk, 0x1F, 0, 0,
 			   keygen_add_revkey, &revkey, NULL);
   if (rc)
     {
       write_status_error ("keysig", rc);
       log_error ("signing failed: %s\n", gpg_strerror (rc));
       goto fail;
     }
 
   /* Insert into public keyblock.  */
   pkt = xmalloc_clear (sizeof *pkt);
   pkt->pkttype = PKT_SIGNATURE;
   pkt->pkt.signature = sig;
   insert_kbnode (pub_keyblock, new_kbnode (pkt), PKT_SIGNATURE);
 
   return 1;
 
 fail:
   if (sig)
     free_seckey_enc (sig);
   free_public_key (revoker_pk);
 
   return 0;
 }
 
 
 /* With FORCE_MAINKEY cleared this function handles the interactive
  * menu option "expire".  With UNATTENDED set to 1 this function only
  * sets the expiration date of the primary key to NEWEXPIRATION and
  * avoid all interactivity; with a value of 2 only the flagged subkeys
  * are set to NEWEXPIRATION.  Returns 0 if nothing was done,
  * GPG_ERR_TRUE if the key was modified, or any other error code. */
 static gpg_error_t
 menu_expire (ctrl_t ctrl, kbnode_t pub_keyblock,
              int unattended, u32 newexpiration)
 {
   int signumber, rc;
   u32 expiredate;
   int only_mainkey;  /* Set if only the mainkey is to be updated.  */
   PKT_public_key *main_pk, *sub_pk;
   PKT_user_id *uid;
   kbnode_t node;
   u32 keyid[2];
 
   if (unattended)
     {
       only_mainkey = (unattended == 1);
       expiredate = newexpiration;
     }
   else
     {
       int n1;
 
       only_mainkey = 0;
       n1 = count_selected_keys (pub_keyblock);
       if (n1 > 1)
         {
           if (!cpr_get_answer_is_yes
               ("keyedit.expire_multiple_subkeys.okay",
                _("Are you sure you want to change the"
                  " expiration time for multiple subkeys? (y/N) ")))
             return gpg_error (GPG_ERR_CANCELED);;
         }
       else if (n1)
         tty_printf (_("Changing expiration time for a subkey.\n"));
       else
         {
           tty_printf (_("Changing expiration time for the primary key.\n"));
           only_mainkey = 1;
           no_primary_warning (pub_keyblock);
         }
 
       expiredate = ask_expiredate ();
     }
 
 
   /* Now we can actually change the self-signature(s) */
   main_pk = sub_pk = NULL;
   uid = NULL;
   signumber = 0;
   for (node = pub_keyblock; node; node = node->next)
     {
       if (node->pkt->pkttype == PKT_PUBLIC_KEY)
 	{
 	  main_pk = node->pkt->pkt.public_key;
 	  keyid_from_pk (main_pk, keyid);
 	  main_pk->expiredate = expiredate;
 	}
       else if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
 	{
           if ((node->flag & NODFLG_SELKEY) && unattended != 1)
             {
               /* The flag is set and we do not want to set the
                * expiration date only for the main key.  */
               sub_pk = node->pkt->pkt.public_key;
               sub_pk->expiredate = expiredate;
             }
           else
             sub_pk = NULL;
 	}
       else if (node->pkt->pkttype == PKT_USER_ID)
 	uid = node->pkt->pkt.user_id;
       else if (main_pk && node->pkt->pkttype == PKT_SIGNATURE
 	       && (only_mainkey || sub_pk))
 	{
 	  PKT_signature *sig = node->pkt->pkt.signature;
 
 	  if (keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1]
 	      && ((only_mainkey && uid
 		   && uid->created && (sig->sig_class & ~3) == 0x10)
 		  || (!only_mainkey && sig->sig_class == 0x18))
 	      && sig->flags.chosen_selfsig)
 	    {
 	      /* This is a self-signature which is to be replaced.  */
 	      PKT_signature *newsig;
 	      PACKET *newpkt;
 
 	      signumber++;
 
 	      if ((only_mainkey && main_pk->version < 4)
 		  || (!only_mainkey && sub_pk->version < 4))
 		{
 		  log_info
                     (_("You can't change the expiration date of a v3 key\n"));
 		  return gpg_error (GPG_ERR_LEGACY_KEY);
 		}
 
 	      if (only_mainkey)
 		rc = update_keysig_packet (ctrl,
                                            &newsig, sig, main_pk, uid, NULL,
 					   main_pk, keygen_add_key_expire,
 					   main_pk);
 	      else
 		rc =
 		  update_keysig_packet (ctrl,
                                         &newsig, sig, main_pk, NULL, sub_pk,
 					main_pk, keygen_add_key_expire, sub_pk);
 	      if (rc)
 		{
 		  log_error ("make_keysig_packet failed: %s\n",
 			     gpg_strerror (rc));
                   if (gpg_err_code (rc) == GPG_ERR_TRUE)
                     rc = GPG_ERR_GENERAL;
 		  return rc;
 		}
 
 	      /* Replace the packet.  */
 	      newpkt = xmalloc_clear (sizeof *newpkt);
 	      newpkt->pkttype = PKT_SIGNATURE;
 	      newpkt->pkt.signature = newsig;
 	      free_packet (node->pkt, NULL);
 	      xfree (node->pkt);
 	      node->pkt = newpkt;
 	      sub_pk = NULL;
 	    }
 	}
     }
 
   update_trust = 1;
   return gpg_error (GPG_ERR_TRUE);
 }
 
 
 /* Change the capability of a selected key.  This command should only
  * be used to rectify badly created keys and as such is not suggested
  * for general use.  */
 static int
 menu_changeusage (ctrl_t ctrl, kbnode_t keyblock)
 {
   int n1, rc;
   int mainkey = 0;
   PKT_public_key *main_pk, *sub_pk;
   PKT_user_id *uid;
   kbnode_t node;
   u32 keyid[2];
 
   n1 = count_selected_keys (keyblock);
   if (n1 > 1)
     {
       tty_printf (_("You must select exactly one key.\n"));
       return 0;
     }
   else if (n1)
     tty_printf (_("Changing usage of a subkey.\n"));
   else
     {
       tty_printf (_("Changing usage of the primary key.\n"));
       mainkey = 1;
     }
 
   /* Now we can actually change the self-signature(s) */
   main_pk = sub_pk = NULL;
   uid = NULL;
   for (node = keyblock; node; node = node->next)
     {
       if (node->pkt->pkttype == PKT_PUBLIC_KEY)
 	{
 	  main_pk = node->pkt->pkt.public_key;
 	  keyid_from_pk (main_pk, keyid);
 	}
       else if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
 	{
           if (node->flag & NODFLG_SELKEY)
             sub_pk = node->pkt->pkt.public_key;
           else
             sub_pk = NULL;
 	}
       else if (node->pkt->pkttype == PKT_USER_ID)
 	uid = node->pkt->pkt.user_id;
       else if (main_pk && node->pkt->pkttype == PKT_SIGNATURE
 	       && (mainkey || sub_pk))
 	{
 	  PKT_signature *sig = node->pkt->pkt.signature;
 	  if (keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1]
 	      && ((mainkey && uid
 		   && uid->created && (sig->sig_class & ~3) == 0x10)
 		  || (!mainkey && sig->sig_class == 0x18))
 	      && sig->flags.chosen_selfsig)
 	    {
 	      /* This is the self-signature which is to be replaced.  */
 	      PKT_signature *newsig;
 	      PACKET *newpkt;
 
 	      if ((mainkey && main_pk->version < 4)
 		  || (!mainkey && sub_pk->version < 4))
 		{
                   /* Note: This won't happen because we don't support
                    * v3 keys anymore.  */
 		  log_info ("You can't change the capabilities of a v3 key\n");
 		  return 0;
 		}
 
               if (mainkey)
                 main_pk->pubkey_usage = ask_key_flags (main_pk->pubkey_algo, 0,
                                                        main_pk->pubkey_usage);
               else
                 sub_pk->pubkey_usage  = ask_key_flags (sub_pk->pubkey_algo, 1,
                                                        sub_pk->pubkey_usage);
 
 	      if (mainkey)
 		rc = update_keysig_packet (ctrl,
                                            &newsig, sig, main_pk, uid, NULL,
 					   main_pk, keygen_add_key_flags,
 					   main_pk);
 	      else
 		rc =
 		  update_keysig_packet (ctrl,
                                         &newsig, sig, main_pk, NULL, sub_pk,
 					main_pk, keygen_add_key_flags, sub_pk);
 	      if (rc)
 		{
 		  log_error ("make_keysig_packet failed: %s\n",
                              gpg_strerror (rc));
 		  return 0;
 		}
 
 	      /* Replace the packet.  */
 	      newpkt = xmalloc_clear (sizeof *newpkt);
 	      newpkt->pkttype = PKT_SIGNATURE;
 	      newpkt->pkt.signature = newsig;
 	      free_packet (node->pkt, NULL);
 	      xfree (node->pkt);
 	      node->pkt = newpkt;
 	      sub_pk = NULL;
               break;
 	    }
 	}
     }
 
   return 1;
 }
 
 
 static int
 menu_backsign (ctrl_t ctrl, kbnode_t pub_keyblock)
 {
   int rc, modified = 0;
   PKT_public_key *main_pk;
   KBNODE node;
   u32 timestamp;
 
   log_assert (pub_keyblock->pkt->pkttype == PKT_PUBLIC_KEY);
 
   merge_keys_and_selfsig (ctrl, pub_keyblock);
   main_pk = pub_keyblock->pkt->pkt.public_key;
   keyid_from_pk (main_pk, NULL);
 
   /* We use the same timestamp for all backsigs so that we don't
      reveal information about the used machine.  */
   timestamp = make_timestamp ();
 
   for (node = pub_keyblock; node; node = node->next)
     {
       PKT_public_key *sub_pk = NULL;
       KBNODE node2, sig_pk = NULL /*,sig_sk = NULL*/;
       /* char *passphrase; */
 
       /* Find a signing subkey with no backsig */
       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
 	{
 	  if (node->pkt->pkt.public_key->pubkey_usage & PUBKEY_USAGE_SIG)
 	    {
 	      if (node->pkt->pkt.public_key->flags.backsig)
 		tty_printf (_
 			    ("signing subkey %s is already cross-certified\n"),
 			    keystr_from_pk (node->pkt->pkt.public_key));
 	      else
 		sub_pk = node->pkt->pkt.public_key;
 	    }
 	  else
 	    tty_printf (_("subkey %s does not sign and so does"
 			  " not need to be cross-certified\n"),
 			keystr_from_pk (node->pkt->pkt.public_key));
 	}
 
       if (!sub_pk)
 	continue;
 
       /* Find the selected selfsig on this subkey */
       for (node2 = node->next;
 	   node2 && node2->pkt->pkttype == PKT_SIGNATURE; node2 = node2->next)
 	if (node2->pkt->pkt.signature->version >= 4
 	    && node2->pkt->pkt.signature->flags.chosen_selfsig)
 	  {
 	    sig_pk = node2;
 	    break;
 	  }
 
       if (!sig_pk)
 	continue;
 
       /* Find the secret subkey that matches the public subkey */
       log_debug ("FIXME: Check whether a secret subkey is available.\n");
       /* if (!sub_sk) */
       /*   { */
       /*     tty_printf (_("no secret subkey for public subkey %s - ignoring\n"), */
       /*   	      keystr_from_pk (sub_pk)); */
       /*     continue; */
       /*   } */
 
 
       /* Now we can get to work.  */
 
       rc = make_backsig (ctrl,
                          sig_pk->pkt->pkt.signature, main_pk, sub_pk, sub_pk,
 			 timestamp, NULL);
       if (!rc)
 	{
 	  PKT_signature *newsig;
 	  PACKET *newpkt;
 
 	  rc = update_keysig_packet (ctrl,
                                      &newsig, sig_pk->pkt->pkt.signature,
                                      main_pk, NULL, sub_pk, main_pk,
                                      NULL, NULL);
 	  if (!rc)
 	    {
 	      /* Put the new sig into place on the pubkey */
 	      newpkt = xmalloc_clear (sizeof (*newpkt));
 	      newpkt->pkttype = PKT_SIGNATURE;
 	      newpkt->pkt.signature = newsig;
 	      free_packet (sig_pk->pkt, NULL);
 	      xfree (sig_pk->pkt);
 	      sig_pk->pkt = newpkt;
 
 	      modified = 1;
 	    }
 	  else
 	    {
 	      log_error ("update_keysig_packet failed: %s\n",
 			 gpg_strerror (rc));
 	      break;
 	    }
 	}
       else
 	{
 	  log_error ("make_backsig failed: %s\n", gpg_strerror (rc));
 	  break;
 	}
     }
 
   return modified;
 }
 
 
 static int
 change_primary_uid_cb (PKT_signature * sig, void *opaque)
 {
   byte buf[1];
 
   /* first clear all primary uid flags so that we are sure none are
    * lingering around */
   delete_sig_subpkt (sig->hashed, SIGSUBPKT_PRIMARY_UID);
   delete_sig_subpkt (sig->unhashed, SIGSUBPKT_PRIMARY_UID);
 
   /* if opaque is set,we want to set the primary id */
   if (opaque)
     {
       buf[0] = 1;
       build_sig_subpkt (sig, SIGSUBPKT_PRIMARY_UID, buf, 1);
     }
 
   return 0;
 }
 
 
 /*
  * Set the primary uid flag for the selected UID.  We will also reset
  * all other primary uid flags.  For this to work we have to update
  * all the signature timestamps.  If we would do this with the current
  * time, we lose quite a lot of information, so we use a kludge to
  * do this: Just increment the timestamp by one second which is
  * sufficient to updated a signature during import.
  */
 static int
 menu_set_primary_uid (ctrl_t ctrl, kbnode_t pub_keyblock)
 {
   PKT_public_key *main_pk;
   PKT_user_id *uid;
   KBNODE node;
   u32 keyid[2];
   int selected;
   int attribute = 0;
   int modified = 0;
 
   if (count_selected_uids (pub_keyblock) != 1)
     {
       tty_printf (_("Please select exactly one user ID.\n"));
       return 0;
     }
 
   main_pk = NULL;
   uid = NULL;
   selected = 0;
 
   /* Is our selected uid an attribute packet? */
   for (node = pub_keyblock; node; node = node->next)
     if (node->pkt->pkttype == PKT_USER_ID && node->flag & NODFLG_SELUID)
       attribute = (node->pkt->pkt.user_id->attrib_data != NULL);
 
   for (node = pub_keyblock; node; node = node->next)
     {
       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
 	break; /* No more user ids expected - ready.  */
 
       if (node->pkt->pkttype == PKT_PUBLIC_KEY)
 	{
 	  main_pk = node->pkt->pkt.public_key;
 	  keyid_from_pk (main_pk, keyid);
 	}
       else if (node->pkt->pkttype == PKT_USER_ID)
 	{
 	  uid = node->pkt->pkt.user_id;
 	  selected = node->flag & NODFLG_SELUID;
 	}
       else if (main_pk && uid && node->pkt->pkttype == PKT_SIGNATURE)
 	{
 	  PKT_signature *sig = node->pkt->pkt.signature;
 	  if (keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1]
 	      && (uid && (sig->sig_class & ~3) == 0x10)
 	      && attribute == (uid->attrib_data != NULL)
 	      && sig->flags.chosen_selfsig)
 	    {
 	      if (sig->version < 4)
 		{
 		  char *user =
 		    utf8_to_native (uid->name, strlen (uid->name), 0);
 
 		  log_info (_("skipping v3 self-signature on user ID \"%s\"\n"),
                             user);
 		  xfree (user);
 		}
 	      else
 		{
 		  /* This is a selfsignature which is to be replaced.
 		     We can just ignore v3 signatures because they are
 		     not able to carry the primary ID flag.  We also
 		     ignore self-sigs on user IDs that are not of the
 		     same type that we are making primary.  That is, if
 		     we are making a user ID primary, we alter user IDs.
 		     If we are making an attribute packet primary, we
 		     alter attribute packets. */
 
 		  /* FIXME: We must make sure that we only have one
 		     self-signature per user ID here (not counting
 		     revocations) */
 		  PKT_signature *newsig;
 		  PACKET *newpkt;
 		  const byte *p;
 		  int action;
 
 		  /* See whether this signature has the primary UID flag.  */
 		  p = parse_sig_subpkt (sig, 1,
 					SIGSUBPKT_PRIMARY_UID, NULL);
 		  if (!p)
 		    p = parse_sig_subpkt (sig, 0,
 					  SIGSUBPKT_PRIMARY_UID, NULL);
 		  if (p && *p)	/* yes */
 		    action = selected ? 0 : -1;
 		  else		/* no */
 		    action = selected ? 1 : 0;
 
 		  if (action)
 		    {
 		      int rc = update_keysig_packet (ctrl, &newsig, sig,
 						     main_pk, uid, NULL,
 						     main_pk,
 						     change_primary_uid_cb,
 						     action > 0 ? "x" : NULL);
 		      if (rc)
 			{
 			  log_error ("update_keysig_packet failed: %s\n",
 				     gpg_strerror (rc));
 			  return 0;
 			}
 		      /* replace the packet */
 		      newpkt = xmalloc_clear (sizeof *newpkt);
 		      newpkt->pkttype = PKT_SIGNATURE;
 		      newpkt->pkt.signature = newsig;
 		      free_packet (node->pkt, NULL);
 		      xfree (node->pkt);
 		      node->pkt = newpkt;
 		      modified = 1;
 		    }
 		}
 	    }
 	}
     }
 
   return modified;
 }
 
 
 /*
  * Set preferences to new values for the selected user IDs
  */
 static int
 menu_set_preferences (ctrl_t ctrl, kbnode_t pub_keyblock)
 {
   PKT_public_key *main_pk;
   PKT_user_id *uid;
   KBNODE node;
   u32 keyid[2];
   int selected, select_all;
   int modified = 0;
 
   no_primary_warning (pub_keyblock);
 
   select_all = !count_selected_uids (pub_keyblock);
 
   /* Now we can actually change the self signature(s) */
   main_pk = NULL;
   uid = NULL;
   selected = 0;
   for (node = pub_keyblock; node; node = node->next)
     {
       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
 	break; /* No more user-ids expected - ready.  */
 
       if (node->pkt->pkttype == PKT_PUBLIC_KEY)
 	{
 	  main_pk = node->pkt->pkt.public_key;
 	  keyid_from_pk (main_pk, keyid);
 	}
       else if (node->pkt->pkttype == PKT_USER_ID)
 	{
 	  uid = node->pkt->pkt.user_id;
 	  selected = select_all || (node->flag & NODFLG_SELUID);
 	}
       else if (main_pk && uid && selected
 	       && node->pkt->pkttype == PKT_SIGNATURE)
 	{
 	  PKT_signature *sig = node->pkt->pkt.signature;
 	  if (keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1]
 	      && (uid && (sig->sig_class & ~3) == 0x10)
 	      && sig->flags.chosen_selfsig)
 	    {
 	      if (sig->version < 4)
 		{
 		  char *user =
 		    utf8_to_native (uid->name, strlen (uid->name), 0);
 
 		  log_info (_("skipping v3 self-signature on user ID \"%s\"\n"),
 			    user);
 		  xfree (user);
 		}
 	      else
 		{
 		  /* This is a selfsignature which is to be replaced
 		   * We have to ignore v3 signatures because they are
 		   * not able to carry the preferences.  */
 		  PKT_signature *newsig;
 		  PACKET *newpkt;
 		  int rc;
 
 		  rc = update_keysig_packet (ctrl, &newsig, sig,
 					     main_pk, uid, NULL, main_pk,
                                              keygen_upd_std_prefs, NULL);
 		  if (rc)
 		    {
 		      log_error ("update_keysig_packet failed: %s\n",
 				 gpg_strerror (rc));
 		      return 0;
 		    }
 		  /* replace the packet */
 		  newpkt = xmalloc_clear (sizeof *newpkt);
 		  newpkt->pkttype = PKT_SIGNATURE;
 		  newpkt->pkt.signature = newsig;
 		  free_packet (node->pkt, NULL);
 		  xfree (node->pkt);
 		  node->pkt = newpkt;
 		  modified = 1;
 		}
 	    }
 	}
     }
 
   return modified;
 }
 
 
 static int
 menu_set_keyserver_url (ctrl_t ctrl, const char *url, kbnode_t pub_keyblock)
 {
   PKT_public_key *main_pk;
   PKT_user_id *uid;
   KBNODE node;
   u32 keyid[2];
   int selected, select_all;
   int modified = 0;
   char *answer, *uri;
 
   no_primary_warning (pub_keyblock);
 
   if (url)
     answer = xstrdup (url);
   else
     {
       answer = cpr_get_utf8 ("keyedit.add_keyserver",
 			     _("Enter your preferred keyserver URL: "));
       if (answer[0] == '\0' || answer[0] == CONTROL_D)
 	{
 	  xfree (answer);
 	  return 0;
 	}
     }
 
-  if (ascii_strcasecmp (answer, "none") == 0)
-    uri = NULL;
+  if (!ascii_strcasecmp (answer, "none"))
+    {
+      xfree (answer);
+      uri = NULL;
+    }
   else
     {
       struct keyserver_spec *keyserver = NULL;
       /* Sanity check the format */
       keyserver = parse_keyserver_uri (answer, 1);
       xfree (answer);
       if (!keyserver)
 	{
 	  log_info (_("could not parse keyserver URL\n"));
 	  return 0;
 	}
       uri = xstrdup (keyserver->uri);
       free_keyserver_spec (keyserver);
     }
 
   select_all = !count_selected_uids (pub_keyblock);
 
   /* Now we can actually change the self signature(s) */
   main_pk = NULL;
   uid = NULL;
   selected = 0;
   for (node = pub_keyblock; node; node = node->next)
     {
       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
 	break; /* ready */
 
       if (node->pkt->pkttype == PKT_PUBLIC_KEY)
 	{
 	  main_pk = node->pkt->pkt.public_key;
 	  keyid_from_pk (main_pk, keyid);
 	}
       else if (node->pkt->pkttype == PKT_USER_ID)
 	{
 	  uid = node->pkt->pkt.user_id;
 	  selected = select_all || (node->flag & NODFLG_SELUID);
 	}
       else if (main_pk && uid && selected
 	       && node->pkt->pkttype == PKT_SIGNATURE)
 	{
 	  PKT_signature *sig = node->pkt->pkt.signature;
 	  if (keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1]
 	      && (uid && (sig->sig_class & ~3) == 0x10)
 	      && sig->flags.chosen_selfsig)
 	    {
 	      char *user = utf8_to_native (uid->name, strlen (uid->name), 0);
 	      if (sig->version < 4)
 		log_info (_("skipping v3 self-signature on user ID \"%s\"\n"),
 			  user);
 	      else
 		{
 		  /* This is a selfsignature which is to be replaced
 		   * We have to ignore v3 signatures because they are
 		   * not able to carry the subpacket. */
 		  PKT_signature *newsig;
 		  PACKET *newpkt;
 		  int rc;
 		  const byte *p;
 		  size_t plen;
 
 		  p = parse_sig_subpkt (sig, 1, SIGSUBPKT_PREF_KS, &plen);
 		  if (p && plen)
 		    {
 		      tty_printf ("Current preferred keyserver for user"
 				  " ID \"%s\": ", user);
 		      tty_print_utf8_string (p, plen);
 		      tty_printf ("\n");
 		      if (!cpr_get_answer_is_yes
                           ("keyedit.confirm_keyserver",
                            uri
                            ? _("Are you sure you want to replace it? (y/N) ")
                            : _("Are you sure you want to delete it? (y/N) ")))
+	                xfree (user);
 			continue;
 		    }
 		  else if (uri == NULL)
 		    {
 		      /* There is no current keyserver URL, so there
 		         is no point in trying to un-set it. */
+	              xfree (user);
 		      continue;
 		    }
 
 		  rc = update_keysig_packet (ctrl, &newsig, sig,
 					     main_pk, uid, NULL,
 					     main_pk,
 					     keygen_add_keyserver_url, uri);
 		  if (rc)
 		    {
 		      log_error ("update_keysig_packet failed: %s\n",
 				 gpg_strerror (rc));
 		      xfree (uri);
+	              xfree (user);
 		      return 0;
 		    }
 		  /* replace the packet */
 		  newpkt = xmalloc_clear (sizeof *newpkt);
 		  newpkt->pkttype = PKT_SIGNATURE;
 		  newpkt->pkt.signature = newsig;
 		  free_packet (node->pkt, NULL);
 		  xfree (node->pkt);
 		  node->pkt = newpkt;
 		  modified = 1;
 		}
 
 	      xfree (user);
 	    }
 	}
     }
 
   xfree (uri);
   return modified;
 }
 
 
 static int
 menu_set_notation (ctrl_t ctrl, const char *string, KBNODE pub_keyblock)
 {
   PKT_public_key *main_pk;
   PKT_user_id *uid;
   KBNODE node;
   u32 keyid[2];
   int selected, select_all;
   int modified = 0;
   char *answer;
   struct notation *notation;
 
   no_primary_warning (pub_keyblock);
 
   if (string)
     answer = xstrdup (string);
   else
     {
       answer = cpr_get_utf8 ("keyedit.add_notation",
 			     _("Enter the notation: "));
       if (answer[0] == '\0' || answer[0] == CONTROL_D)
 	{
 	  xfree (answer);
 	  return 0;
 	}
     }
 
   if (!ascii_strcasecmp (answer, "none")
       || !ascii_strcasecmp (answer, "-"))
     notation = NULL; /* Delete them all.  */
   else
     {
       notation = string_to_notation (answer, 0);
       if (!notation)
 	{
 	  xfree (answer);
 	  return 0;
 	}
     }
 
   xfree (answer);
 
   select_all = !count_selected_uids (pub_keyblock);
 
   /* Now we can actually change the self signature(s) */
   main_pk = NULL;
   uid = NULL;
   selected = 0;
   for (node = pub_keyblock; node; node = node->next)
     {
       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
 	break; /* ready */
 
       if (node->pkt->pkttype == PKT_PUBLIC_KEY)
 	{
 	  main_pk = node->pkt->pkt.public_key;
 	  keyid_from_pk (main_pk, keyid);
 	}
       else if (node->pkt->pkttype == PKT_USER_ID)
 	{
 	  uid = node->pkt->pkt.user_id;
 	  selected = select_all || (node->flag & NODFLG_SELUID);
 	}
       else if (main_pk && uid && selected
 	       && node->pkt->pkttype == PKT_SIGNATURE)
 	{
 	  PKT_signature *sig = node->pkt->pkt.signature;
 	  if (keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1]
 	      && (uid && (sig->sig_class & ~3) == 0x10)
 	      && sig->flags.chosen_selfsig)
 	    {
 	      char *user = utf8_to_native (uid->name, strlen (uid->name), 0);
 	      if (sig->version < 4)
 		log_info (_("skipping v3 self-signature on user ID \"%s\"\n"),
 			  user);
 	      else
 		{
 		  PKT_signature *newsig;
 		  PACKET *newpkt;
 		  int rc, skip = 0, addonly = 1;
 
 		  if (sig->flags.notation)
 		    {
 		      tty_printf ("Current notations for user ID \"%s\":\n",
 				  user);
 		      tty_print_notations (-9, sig);
 		    }
 		  else
 		    {
 		      tty_printf ("No notations on user ID \"%s\"\n", user);
 		      if (notation == NULL)
 			{
 			  /* There are no current notations, so there
 			     is no point in trying to un-set them. */
 			  continue;
 			}
 		    }
 
 		  if (notation)
 		    {
 		      struct notation *n;
 		      int deleting = 0;
 
 		      notation->next = sig_to_notation (sig);
 
 		      for (n = notation->next; n; n = n->next)
 			if (strcmp (n->name, notation->name) == 0)
 			  {
 			    if (notation->value)
 			      {
 				if (strcmp (n->value, notation->value) == 0)
 				  {
 				    if (notation->flags.ignore)
 				      {
 					/* Value match with a delete
 					   flag. */
 					n->flags.ignore = 1;
 					deleting = 1;
 				      }
 				    else
 				      {
 					/* Adding the same notation
 					   twice, so don't add it at
 					   all. */
 					skip = 1;
 					tty_printf ("Skipping notation:"
 						    " %s=%s\n",
 						    notation->name,
 						    notation->value);
 					break;
 				      }
 				  }
 			      }
 			    else
 			      {
 				/* No value, so it means delete. */
 				n->flags.ignore = 1;
 				deleting = 1;
 			      }
 
 			    if (n->flags.ignore)
 			      {
 				tty_printf ("Removing notation: %s=%s\n",
 					    n->name, n->value);
 				addonly = 0;
 			      }
 			  }
 
 		      if (!notation->flags.ignore && !skip)
 			tty_printf ("Adding notation: %s=%s\n",
 				    notation->name, notation->value);
 
 		      /* We tried to delete, but had no matches.  */
 		      if (notation->flags.ignore && !deleting)
 			continue;
 		    }
 		  else
 		    {
 		      tty_printf ("Removing all notations\n");
 		      addonly = 0;
 		    }
 
 		  if (skip
 		      || (!addonly
 			  &&
 			  !cpr_get_answer_is_yes ("keyedit.confirm_notation",
 						  _("Proceed? (y/N) "))))
 		    continue;
 
 		  rc = update_keysig_packet (ctrl, &newsig, sig,
 					     main_pk, uid, NULL,
 					     main_pk,
 					     keygen_add_notations, notation);
 		  if (rc)
 		    {
 		      log_error ("update_keysig_packet failed: %s\n",
 				 gpg_strerror (rc));
 		      free_notation (notation);
 		      xfree (user);
 		      return 0;
 		    }
 
 		  /* replace the packet */
 		  newpkt = xmalloc_clear (sizeof *newpkt);
 		  newpkt->pkttype = PKT_SIGNATURE;
 		  newpkt->pkt.signature = newsig;
 		  free_packet (node->pkt, NULL);
 		  xfree (node->pkt);
 		  node->pkt = newpkt;
 		  modified = 1;
 
 		  if (notation)
 		    {
 		      /* Snip off the notation list from the sig */
 		      free_notation (notation->next);
 		      notation->next = NULL;
 		    }
 
 		  xfree (user);
 		}
 	    }
 	}
     }
 
   free_notation (notation);
   return modified;
 }
 
 
 /*
  * Select one user id or remove all selection if IDX is 0 or select
  * all if IDX is -1.  Returns: True if the selection changed.
  */
 static int
 menu_select_uid (KBNODE keyblock, int idx)
 {
   KBNODE node;
   int i;
 
   if (idx == -1)		/* Select all. */
     {
       for (node = keyblock; node; node = node->next)
 	if (node->pkt->pkttype == PKT_USER_ID)
 	  node->flag |= NODFLG_SELUID;
       return 1;
     }
   else if (idx)			/* Toggle.  */
     {
       for (i = 0, node = keyblock; node; node = node->next)
 	{
 	  if (node->pkt->pkttype == PKT_USER_ID)
 	    if (++i == idx)
 	      break;
 	}
       if (!node)
 	{
 	  tty_printf (_("No user ID with index %d\n"), idx);
 	  return 0;
 	}
 
       for (i = 0, node = keyblock; node; node = node->next)
 	{
 	  if (node->pkt->pkttype == PKT_USER_ID)
 	    {
 	      if (++i == idx)
 		{
 		  if ((node->flag & NODFLG_SELUID))
 		    node->flag &= ~NODFLG_SELUID;
 		  else
 		    node->flag |= NODFLG_SELUID;
 		}
 	    }
 	}
     }
   else				/* Unselect all */
     {
       for (node = keyblock; node; node = node->next)
 	if (node->pkt->pkttype == PKT_USER_ID)
 	  node->flag &= ~NODFLG_SELUID;
     }
 
   return 1;
 }
 
 
 /* Search in the keyblock for a uid that matches namehash */
 static int
 menu_select_uid_namehash (KBNODE keyblock, const char *namehash)
 {
   byte hash[NAMEHASH_LEN];
   KBNODE node;
   int i;
 
   log_assert (strlen (namehash) == NAMEHASH_LEN * 2);
 
   for (i = 0; i < NAMEHASH_LEN; i++)
     hash[i] = hextobyte (&namehash[i * 2]);
 
   for (node = keyblock->next; node; node = node->next)
     {
       if (node->pkt->pkttype == PKT_USER_ID)
 	{
 	  namehash_from_uid (node->pkt->pkt.user_id);
 	  if (memcmp (node->pkt->pkt.user_id->namehash, hash, NAMEHASH_LEN) ==
 	      0)
 	    {
 	      if (node->flag & NODFLG_SELUID)
 		node->flag &= ~NODFLG_SELUID;
 	      else
 		node->flag |= NODFLG_SELUID;
 
 	      break;
 	    }
 	}
     }
 
   if (!node)
     {
       tty_printf (_("No user ID with hash %s\n"), namehash);
       return 0;
     }
 
   return 1;
 }
 
 
 /*
  * Select secondary keys
  * Returns: True if the selection changed.
  */
 static int
 menu_select_key (KBNODE keyblock, int idx, char *p)
 {
   KBNODE node;
   int i, j;
   int is_hex_digits;
 
   is_hex_digits = p && strlen (p) >= 8;
   if (is_hex_digits)
     {
       /* Skip initial spaces.  */
       while (spacep (p))
         p ++;
       /* If the id starts with 0x accept and ignore it.  */
       if (p[0] == '0' && p[1] == 'x')
         p += 2;
 
       for (i = 0, j = 0; p[i]; i ++)
         if (hexdigitp (&p[i]))
           {
             p[j] = toupper (p[i]);
             j ++;
           }
         else if (spacep (&p[i]))
           /* Skip spaces.  */
           {
           }
         else
           {
             is_hex_digits = 0;
             break;
           }
       if (is_hex_digits)
         /* In case we skipped some spaces, add a new NUL terminator.  */
         {
           p[j] = 0;
           /* If we skipped some spaces, make sure that we still have
              at least 8 characters.  */
           is_hex_digits = (/* Short keyid.  */
                            strlen (p) == 8
                            /* Long keyid.  */
                            || strlen (p) == 16
                            /* Fingerprints are (currently) 32 or 40
                               characters.  */
                            || strlen (p) >= 32);
         }
     }
 
   if (is_hex_digits)
     {
       int found_one = 0;
       for (node = keyblock; node; node = node->next)
 	if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
 	    || node->pkt->pkttype == PKT_SECRET_SUBKEY)
           {
             int match = 0;
             if (strlen (p) == 8 || strlen (p) == 16)
               {
                 u32 kid[2];
                 char kid_str[17];
                 keyid_from_pk (node->pkt->pkt.public_key, kid);
                 format_keyid (kid, strlen (p) == 8 ? KF_SHORT : KF_LONG,
                               kid_str, sizeof (kid_str));
 
                 if (strcmp (p, kid_str) == 0)
                   match = 1;
               }
             else
               {
                 char fp[2*MAX_FINGERPRINT_LEN + 1];
                 hexfingerprint (node->pkt->pkt.public_key, fp, sizeof (fp));
                 if (strcmp (fp, p) == 0)
                   match = 1;
               }
 
             if (match)
               {
                 if ((node->flag & NODFLG_SELKEY))
                   node->flag &= ~NODFLG_SELKEY;
                 else
                   node->flag |= NODFLG_SELKEY;
 
                 found_one = 1;
               }
           }
 
       if (found_one)
         return 1;
 
       tty_printf (_("No subkey with key ID '%s'.\n"), p);
       return 0;
     }
 
   if (idx == -1)		/* Select all.  */
     {
       for (node = keyblock; node; node = node->next)
 	if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
 	    || node->pkt->pkttype == PKT_SECRET_SUBKEY)
 	  node->flag |= NODFLG_SELKEY;
     }
   else if (idx)			/* Toggle selection.  */
     {
       for (i = 0, node = keyblock; node; node = node->next)
 	{
 	  if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
 	      || node->pkt->pkttype == PKT_SECRET_SUBKEY)
 	    if (++i == idx)
 	      break;
 	}
       if (!node)
 	{
 	  tty_printf (_("No subkey with index %d\n"), idx);
 	  return 0;
 	}
 
       for (i = 0, node = keyblock; node; node = node->next)
 	{
 	  if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
 	      || node->pkt->pkttype == PKT_SECRET_SUBKEY)
 	    if (++i == idx)
 	      {
 		if ((node->flag & NODFLG_SELKEY))
 		  node->flag &= ~NODFLG_SELKEY;
 		else
 		  node->flag |= NODFLG_SELKEY;
 	      }
 	}
     }
   else				/* Unselect all. */
     {
       for (node = keyblock; node; node = node->next)
 	if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
 	    || node->pkt->pkttype == PKT_SECRET_SUBKEY)
 	  node->flag &= ~NODFLG_SELKEY;
     }
 
   return 1;
 }
 
 
 static int
 count_uids_with_flag (KBNODE keyblock, unsigned flag)
 {
   KBNODE node;
   int i = 0;
 
   for (node = keyblock; node; node = node->next)
     if (node->pkt->pkttype == PKT_USER_ID && (node->flag & flag))
       i++;
   return i;
 }
 
 
 static int
 count_keys_with_flag (KBNODE keyblock, unsigned flag)
 {
   KBNODE node;
   int i = 0;
 
   for (node = keyblock; node; node = node->next)
     if ((node->pkt->pkttype == PKT_PUBLIC_SUBKEY
 	 || node->pkt->pkttype == PKT_SECRET_SUBKEY) && (node->flag & flag))
       i++;
   return i;
 }
 
 
 static int
 count_uids (KBNODE keyblock)
 {
   KBNODE node;
   int i = 0;
 
   for (node = keyblock; node; node = node->next)
     if (node->pkt->pkttype == PKT_USER_ID)
       i++;
   return i;
 }
 
 
 /*
  * Returns true if there is at least one selected user id
  */
 static int
 count_selected_uids (KBNODE keyblock)
 {
   return count_uids_with_flag (keyblock, NODFLG_SELUID);
 }
 
 
 static int
 count_selected_keys (KBNODE keyblock)
 {
   return count_keys_with_flag (keyblock, NODFLG_SELKEY);
 }
 
 
 /* Returns how many real (i.e. not attribute) uids are unmarked.  */
 static int
 real_uids_left (KBNODE keyblock)
 {
   KBNODE node;
   int real = 0;
 
   for (node = keyblock; node; node = node->next)
     if (node->pkt->pkttype == PKT_USER_ID && !(node->flag & NODFLG_SELUID) &&
 	!node->pkt->pkt.user_id->attrib_data)
       real++;
 
   return real;
 }
 
 
 /*
  * Ask whether the signature should be revoked.  If the user commits this,
  * flag bit MARK_A is set on the signature and the user ID.
  */
 static void
 ask_revoke_sig (ctrl_t ctrl, kbnode_t keyblock, kbnode_t node)
 {
   int doit = 0;
   PKT_user_id *uid;
   PKT_signature *sig = node->pkt->pkt.signature;
   KBNODE unode = find_prev_kbnode (keyblock, node, PKT_USER_ID);
 
   if (!unode)
     {
       log_error ("Oops: no user ID for signature\n");
       return;
     }
 
   uid = unode->pkt->pkt.user_id;
 
   if (opt.with_colons)
     {
       if (uid->attrib_data)
 	printf ("uat:::::::::%u %lu", uid->numattribs, uid->attrib_len);
       else
 	{
 	  es_printf ("uid:::::::::");
 	  es_write_sanitized (es_stdout, uid->name, uid->len, ":", NULL);
 	}
 
       es_printf ("\n");
 
       print_and_check_one_sig_colon (ctrl, keyblock, node,
                                      NULL, NULL, NULL, NULL, 1);
     }
   else
     {
       char *p = utf8_to_native (unode->pkt->pkt.user_id->name,
 				unode->pkt->pkt.user_id->len, 0);
       tty_printf (_("user ID: \"%s\"\n"), p);
       xfree (p);
 
       tty_printf (_("signed by your key %s on %s%s%s\n"),
 		  keystr (sig->keyid), datestr_from_sig (sig),
 		  sig->flags.exportable ? "" : _(" (non-exportable)"), "");
     }
   if (sig->flags.expired)
     {
       tty_printf (_("This signature expired on %s.\n"),
 		  expirestr_from_sig (sig));
       /* Use a different question so we can have different help text */
       doit = cpr_get_answer_is_yes
         ("ask_revoke_sig.expired",
          _("Are you sure you still want to revoke it? (y/N) "));
     }
   else
     doit = cpr_get_answer_is_yes
       ("ask_revoke_sig.one",
        _("Create a revocation certificate for this signature? (y/N) "));
 
   if (doit)
     {
       node->flag |= NODFLG_MARK_A;
       unode->flag |= NODFLG_MARK_A;
     }
 }
 
 
 /*
  * Display all user ids of the current public key together with signatures
  * done by one of our keys.  Then walk over all this sigs and ask the user
  * whether he wants to revoke this signature.
  * Return: True when the keyblock has changed.
  */
 static int
 menu_revsig (ctrl_t ctrl, kbnode_t keyblock)
 {
   PKT_signature *sig;
   PKT_public_key *primary_pk;
   KBNODE node;
   int changed = 0;
   int rc, any, skip = 1, all = !count_selected_uids (keyblock);
   struct revocation_reason_info *reason = NULL;
 
   log_assert (keyblock->pkt->pkttype == PKT_PUBLIC_KEY);
 
   /* First check whether we have any signatures at all.  */
   any = 0;
   for (node = keyblock; node; node = node->next)
     {
       node->flag &= ~(NODFLG_SELSIG | NODFLG_MARK_A);
       if (node->pkt->pkttype == PKT_USER_ID)
 	{
 	  if (node->flag & NODFLG_SELUID || all)
 	    skip = 0;
 	  else
 	    skip = 1;
 	}
       else if (!skip && node->pkt->pkttype == PKT_SIGNATURE
 	       && ((sig = node->pkt->pkt.signature),
 		   have_secret_key_with_kid (ctrl, sig->keyid)))
 	{
 	  if ((sig->sig_class & ~3) == 0x10)
 	    {
 	      any = 1;
 	      break;
 	    }
 	}
     }
 
   if (!any)
     {
       tty_printf (_("Not signed by you.\n"));
       return 0;
     }
 
 
   /* FIXME: detect duplicates here  */
   tty_printf (_("You have signed these user IDs on key %s:\n"),
 	      keystr_from_pk (keyblock->pkt->pkt.public_key));
   for (node = keyblock; node; node = node->next)
     {
       node->flag &= ~(NODFLG_SELSIG | NODFLG_MARK_A);
       if (node->pkt->pkttype == PKT_USER_ID)
 	{
 	  if (node->flag & NODFLG_SELUID || all)
 	    {
 	      PKT_user_id *uid = node->pkt->pkt.user_id;
 	      /* Hmmm: Should we show only UIDs with a signature? */
 	      tty_printf ("     ");
 	      tty_print_utf8_string (uid->name, uid->len);
 	      tty_printf ("\n");
 	      skip = 0;
 	    }
 	  else
 	    skip = 1;
 	}
       else if (!skip && node->pkt->pkttype == PKT_SIGNATURE
 	       && ((sig = node->pkt->pkt.signature),
 		   have_secret_key_with_kid (ctrl, sig->keyid)))
 	{
 	  if ((sig->sig_class & ~3) == 0x10)
 	    {
 	      tty_printf ("   ");
 	      tty_printf (_("signed by your key %s on %s%s%s\n"),
 			  keystr (sig->keyid), datestr_from_sig (sig),
 			  sig->flags.exportable ? "" : _(" (non-exportable)"),
 			  sig->flags.revocable ? "" : _(" (non-revocable)"));
 	      if (sig->flags.revocable)
 		node->flag |= NODFLG_SELSIG;
 	    }
 	  else if (sig->sig_class == 0x30)
 	    {
 	      tty_printf ("   ");
 	      tty_printf (_("revoked by your key %s on %s\n"),
 			  keystr (sig->keyid), datestr_from_sig (sig));
 	    }
 	}
     }
 
   tty_printf ("\n");
 
   /* ask */
   for (node = keyblock; node; node = node->next)
     {
       if (!(node->flag & NODFLG_SELSIG))
 	continue;
       ask_revoke_sig (ctrl, keyblock, node);
     }
 
   /* present selected */
   any = 0;
   for (node = keyblock; node; node = node->next)
     {
       if (!(node->flag & NODFLG_MARK_A))
 	continue;
       if (!any)
 	{
 	  any = 1;
 	  tty_printf (_("You are about to revoke these signatures:\n"));
 	}
       if (node->pkt->pkttype == PKT_USER_ID)
 	{
 	  PKT_user_id *uid = node->pkt->pkt.user_id;
 	  tty_printf ("     ");
 	  tty_print_utf8_string (uid->name, uid->len);
 	  tty_printf ("\n");
 	}
       else if (node->pkt->pkttype == PKT_SIGNATURE)
 	{
 	  sig = node->pkt->pkt.signature;
 	  tty_printf ("   ");
 	  tty_printf (_("signed by your key %s on %s%s%s\n"),
 		      keystr (sig->keyid), datestr_from_sig (sig), "",
 		      sig->flags.exportable ? "" : _(" (non-exportable)"));
 	}
     }
   if (!any)
     return 0;			/* none selected */
 
   if (!cpr_get_answer_is_yes
       ("ask_revoke_sig.okay",
        _("Really create the revocation certificates? (y/N) ")))
     return 0;			/* forget it */
 
   reason = ask_revocation_reason (0, 1, 0);
   if (!reason)
     {				/* user decided to cancel */
       return 0;
     }
 
   /* now we can sign the user ids */
 reloop:			/* (must use this, because we are modifying the list) */
   primary_pk = keyblock->pkt->pkt.public_key;
   for (node = keyblock; node; node = node->next)
     {
       KBNODE unode;
       PACKET *pkt;
       struct sign_attrib attrib;
       PKT_public_key *signerkey;
 
       if (!(node->flag & NODFLG_MARK_A)
 	  || node->pkt->pkttype != PKT_SIGNATURE)
 	continue;
       unode = find_prev_kbnode (keyblock, node, PKT_USER_ID);
       log_assert (unode); /* we already checked this */
 
       memset (&attrib, 0, sizeof attrib);
       attrib.reason = reason;
       attrib.non_exportable = !node->pkt->pkt.signature->flags.exportable;
 
       node->flag &= ~NODFLG_MARK_A;
       signerkey = xmalloc_secure_clear (sizeof *signerkey);
       if (get_seckey (ctrl, signerkey, node->pkt->pkt.signature->keyid))
 	{
 	  log_info (_("no secret key\n"));
           free_public_key (signerkey);
 	  continue;
 	}
       rc = make_keysig_packet (ctrl, &sig, primary_pk,
 			       unode->pkt->pkt.user_id,
 			       NULL, signerkey, 0x30, 0, 0,
                                sign_mk_attrib, &attrib, NULL);
       free_public_key (signerkey);
       if (rc)
 	{
           write_status_error ("keysig", rc);
 	  log_error (_("signing failed: %s\n"), gpg_strerror (rc));
 	  release_revocation_reason_info (reason);
 	  return changed;
 	}
       changed = 1;		/* we changed the keyblock */
       update_trust = 1;
       /* Are we revoking our own uid? */
       if (primary_pk->keyid[0] == sig->keyid[0] &&
 	  primary_pk->keyid[1] == sig->keyid[1])
 	unode->pkt->pkt.user_id->flags.revoked = 1;
       pkt = xmalloc_clear (sizeof *pkt);
       pkt->pkttype = PKT_SIGNATURE;
       pkt->pkt.signature = sig;
       insert_kbnode (unode, new_kbnode (pkt), 0);
       goto reloop;
     }
 
   release_revocation_reason_info (reason);
   return changed;
 }
 
 
 /* return 0 if revocation of NODE (which must be a User ID) was
    successful, non-zero if there was an error.  *modified will be set
    to 1 if a change was made. */
 static int
 core_revuid (ctrl_t ctrl, kbnode_t keyblock, KBNODE node,
              const struct revocation_reason_info *reason, int *modified)
 {
   PKT_public_key *pk = keyblock->pkt->pkt.public_key;
   gpg_error_t rc;
 
   if (node->pkt->pkttype != PKT_USER_ID)
     {
       rc = gpg_error (GPG_ERR_NO_USER_ID);
       write_status_error ("keysig", rc);
       log_error (_("tried to revoke a non-user ID: %s\n"), gpg_strerror (rc));
       return 1;
     }
   else
     {
       PKT_user_id *uid = node->pkt->pkt.user_id;
 
       if (uid->flags.revoked)
         {
           char *user = utf8_to_native (uid->name, uid->len, 0);
           log_info (_("user ID \"%s\" is already revoked\n"), user);
           xfree (user);
         }
       else
         {
           PACKET *pkt;
           PKT_signature *sig;
           struct sign_attrib attrib;
           u32 timestamp = make_timestamp ();
 
           if (uid->created >= timestamp)
             {
               /* Okay, this is a problem.  The user ID selfsig was
                  created in the future, so we need to warn the user and
                  set our revocation timestamp one second after that so
                  everything comes out clean. */
 
               log_info (_("WARNING: a user ID signature is dated %d"
                           " seconds in the future\n"),
                         uid->created - timestamp);
 
               timestamp = uid->created + 1;
             }
 
           memset (&attrib, 0, sizeof attrib);
           /* should not need to cast away const here; but
              revocation_reason_build_cb needs to take a non-const
              void* in order to meet the function signature for the
              mksubpkt argument to make_keysig_packet */
           attrib.reason = (struct revocation_reason_info *)reason;
 
           rc = make_keysig_packet (ctrl, &sig, pk, uid, NULL, pk, 0x30,
                                    timestamp, 0,
                                    sign_mk_attrib, &attrib, NULL);
           if (rc)
             {
               write_status_error ("keysig", rc);
               log_error (_("signing failed: %s\n"), gpg_strerror (rc));
               return 1;
             }
           else
             {
               pkt = xmalloc_clear (sizeof *pkt);
               pkt->pkttype = PKT_SIGNATURE;
               pkt->pkt.signature = sig;
               insert_kbnode (node, new_kbnode (pkt), 0);
 
 #ifndef NO_TRUST_MODELS
               /* If the trustdb has an entry for this key+uid then the
                  trustdb needs an update. */
               if (!update_trust
                   && ((get_validity (ctrl, keyblock, pk, uid, NULL, 0)
                        & TRUST_MASK)
                       >= TRUST_UNDEFINED))
                 update_trust = 1;
 #endif /*!NO_TRUST_MODELS*/
 
               node->pkt->pkt.user_id->flags.revoked = 1;
               if (modified)
                 *modified = 1;
             }
         }
       return 0;
     }
 }
 
 /* Revoke a user ID (i.e. revoke a user ID selfsig).  Return true if
    keyblock changed.  */
 static int
 menu_revuid (ctrl_t ctrl, kbnode_t pub_keyblock)
 {
   PKT_public_key *pk = pub_keyblock->pkt->pkt.public_key;
   KBNODE node;
   int changed = 0;
   int rc;
   struct revocation_reason_info *reason = NULL;
   size_t valid_uids;
 
   /* Note that this is correct as per the RFCs, but nevertheless
      somewhat meaningless in the real world.  1991 did define the 0x30
      sig class, but PGP 2.x did not actually implement it, so it would
      probably be safe to use v4 revocations everywhere. -ds */
 
   for (node = pub_keyblock; node; node = node->next)
     if (pk->version > 3 || (node->pkt->pkttype == PKT_USER_ID &&
 			    node->pkt->pkt.user_id->selfsigversion > 3))
       {
 	if ((reason = ask_revocation_reason (0, 1, 4)))
 	  break;
 	else
 	  goto leave;
       }
 
   /* Too make sure that we do not revoke the last valid UID, we first
      count how many valid UIDs there are.  */
   valid_uids = 0;
   for (node = pub_keyblock; node; node = node->next)
     valid_uids +=
       node->pkt->pkttype == PKT_USER_ID
       && ! node->pkt->pkt.user_id->flags.revoked
       && ! node->pkt->pkt.user_id->flags.expired;
 
  reloop: /* (better this way because we are modifying the keyring) */
   for (node = pub_keyblock; node; node = node->next)
     if (node->pkt->pkttype == PKT_USER_ID && (node->flag & NODFLG_SELUID))
       {
         int modified = 0;
 
         /* Make sure that we do not revoke the last valid UID.  */
         if (valid_uids == 1
             && ! node->pkt->pkt.user_id->flags.revoked
             && ! node->pkt->pkt.user_id->flags.expired)
           {
             log_error (_("Cannot revoke the last valid user ID.\n"));
             goto leave;
           }
 
         rc = core_revuid (ctrl, pub_keyblock, node, reason, &modified);
         if (rc)
           goto leave;
         if (modified)
           {
 	    node->flag &= ~NODFLG_SELUID;
             changed = 1;
             goto reloop;
           }
       }
 
   if (changed)
     commit_kbnode (&pub_keyblock);
 
 leave:
   release_revocation_reason_info (reason);
   return changed;
 }
 
 
 /*
  * Revoke the whole key.
  */
 static int
 menu_revkey (ctrl_t ctrl, kbnode_t pub_keyblock)
 {
   PKT_public_key *pk = pub_keyblock->pkt->pkt.public_key;
   int rc, changed = 0;
   struct revocation_reason_info *reason;
   PACKET *pkt;
   PKT_signature *sig;
 
   if (pk->flags.revoked)
     {
       tty_printf (_("Key %s is already revoked.\n"), keystr_from_pk (pk));
       return 0;
     }
 
   reason = ask_revocation_reason (1, 0, 0);
   /* user decided to cancel */
   if (!reason)
     return 0;
 
   rc = make_keysig_packet (ctrl, &sig, pk, NULL, NULL, pk,
 			   0x20, 0, 0,
 			   revocation_reason_build_cb, reason, NULL);
   if (rc)
     {
       write_status_error ("keysig", rc);
       log_error (_("signing failed: %s\n"), gpg_strerror (rc));
       goto scram;
     }
 
   changed = 1;			/* we changed the keyblock */
 
   pkt = xmalloc_clear (sizeof *pkt);
   pkt->pkttype = PKT_SIGNATURE;
   pkt->pkt.signature = sig;
   insert_kbnode (pub_keyblock, new_kbnode (pkt), 0);
   commit_kbnode (&pub_keyblock);
 
   update_trust = 1;
 
  scram:
   release_revocation_reason_info (reason);
   return changed;
 }
 
 
 static int
 menu_revsubkey (ctrl_t ctrl, kbnode_t pub_keyblock)
 {
   PKT_public_key *mainpk;
   KBNODE node;
   int changed = 0;
   int rc;
   struct revocation_reason_info *reason = NULL;
 
   reason = ask_revocation_reason (1, 0, 0);
   if (!reason)
       return 0; /* User decided to cancel.  */
 
  reloop: /* (better this way because we are modifying the keyring) */
   mainpk = pub_keyblock->pkt->pkt.public_key;
   for (node = pub_keyblock; node; node = node->next)
     {
       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
 	  && (node->flag & NODFLG_SELKEY))
 	{
 	  PACKET *pkt;
 	  PKT_signature *sig;
 	  PKT_public_key *subpk = node->pkt->pkt.public_key;
 	  struct sign_attrib attrib;
 
 	  if (subpk->flags.revoked)
 	    {
 	      tty_printf (_("Subkey %s is already revoked.\n"),
 			  keystr_from_pk (subpk));
 	      continue;
 	    }
 
 	  memset (&attrib, 0, sizeof attrib);
 	  attrib.reason = reason;
 
 	  node->flag &= ~NODFLG_SELKEY;
 	  rc = make_keysig_packet (ctrl, &sig, mainpk, NULL, subpk, mainpk,
 				   0x28, 0, 0, sign_mk_attrib, &attrib,
                                    NULL);
 	  if (rc)
 	    {
               write_status_error ("keysig", rc);
 	      log_error (_("signing failed: %s\n"), gpg_strerror (rc));
 	      release_revocation_reason_info (reason);
 	      return changed;
 	    }
 	  changed = 1;		/* we changed the keyblock */
 
 	  pkt = xmalloc_clear (sizeof *pkt);
 	  pkt->pkttype = PKT_SIGNATURE;
 	  pkt->pkt.signature = sig;
 	  insert_kbnode (node, new_kbnode (pkt), 0);
 	  goto reloop;
 	}
     }
   commit_kbnode (&pub_keyblock);
 
   /* No need to set update_trust here since signing keys no longer
      are used to certify other keys, so there is no change in trust
      when revoking/removing them */
 
   release_revocation_reason_info (reason);
   return changed;
 }
 
 
 /* Note that update_ownertrust is going to mark the trustdb dirty when
    enabling or disabling a key.  This is arguably sub-optimal as
    disabled keys are still counted in the web of trust, but perhaps
    not worth adding extra complexity to change. -ds */
 #ifndef NO_TRUST_MODELS
 static int
 enable_disable_key (ctrl_t ctrl, kbnode_t keyblock, int disable)
 {
   PKT_public_key *pk =
     find_kbnode (keyblock, PKT_PUBLIC_KEY)->pkt->pkt.public_key;
   unsigned int trust, newtrust;
 
   trust = newtrust = get_ownertrust (ctrl, pk);
   newtrust &= ~TRUST_FLAG_DISABLED;
   if (disable)
     newtrust |= TRUST_FLAG_DISABLED;
   if (trust == newtrust)
     return 0;			/* already in that state */
   update_ownertrust (ctrl, pk, newtrust);
   return 0;
 }
 #endif /*!NO_TRUST_MODELS*/
 
 
 static void
 menu_showphoto (ctrl_t ctrl, kbnode_t keyblock)
 {
   KBNODE node;
   int select_all = !count_selected_uids (keyblock);
   int count = 0;
   PKT_public_key *pk = NULL;
 
   /* Look for the public key first.  We have to be really, really,
      explicit as to which photo this is, and what key it is a UID on
      since people may want to sign it. */
 
   for (node = keyblock; node; node = node->next)
     {
       if (node->pkt->pkttype == PKT_PUBLIC_KEY)
 	pk = node->pkt->pkt.public_key;
       else if (node->pkt->pkttype == PKT_USER_ID)
 	{
 	  PKT_user_id *uid = node->pkt->pkt.user_id;
 	  count++;
 
 	  if ((select_all || (node->flag & NODFLG_SELUID)) &&
 	      uid->attribs != NULL)
 	    {
 	      int i;
 
 	      for (i = 0; i < uid->numattribs; i++)
 		{
 		  byte type;
 		  u32 size;
 
 		  if (uid->attribs[i].type == ATTRIB_IMAGE &&
 		      parse_image_header (&uid->attribs[i], &type, &size))
 		    {
 		      tty_printf (_("Displaying %s photo ID of size %ld for "
 				    "key %s (uid %d)\n"),
 				  image_type_to_string (type, 1),
 				  (ulong) size, keystr_from_pk (pk), count);
 		      show_photos (ctrl, &uid->attribs[i], 1, pk, uid);
 		    }
 		}
 	    }
 	}
     }
 }
diff --git a/g10/keygen.c b/g10/keygen.c
index 5d85c05d4..f1e4d3638 100644
--- a/g10/keygen.c
+++ b/g10/keygen.c
@@ -1,6179 +1,6186 @@
 /* keygen.c - Generate a key pair
  * Copyright (C) 1998-2007, 2009-2011  Free Software Foundation, Inc.
  * Copyright (C) 2014, 2015, 2016, 2017, 2018  Werner Koch
  * Copyright (C) 2020 g10 Code GmbH
  *
  * 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 <ctype.h>
 #include <errno.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <unistd.h>
 
 #include "gpg.h"
 #include "../common/util.h"
 #include "main.h"
 #include "packet.h"
 #include "../common/ttyio.h"
 #include "options.h"
 #include "keydb.h"
 #include "trustdb.h"
 #include "../common/status.h"
 #include "../common/i18n.h"
 #include "keyserver-internal.h"
 #include "call-agent.h"
 #include "pkglue.h"
 #include "../common/shareddefs.h"
 #include "../common/host2net.h"
 #include "../common/mbox-util.h"
 
 
 /* The default algorithms.  If you change them, you should ensure the
    value is inside the bounds enforced by ask_keysize and gen_xxx.
    See also get_keysize_range which encodes the allowed ranges.  The
    default answer in ask_algo also needs to be adjusted.  */
 #define DEFAULT_STD_KEY_PARAM  "ed25519/cert,sign+cv25519/encr"
 #define FUTURE_STD_KEY_PARAM   "ed25519/cert,sign+cv25519/encr"
 
 /* When generating keys using the streamlined key generation dialog,
    use this as a default expiration interval.  */
 const char *default_expiration_interval = "2y";
 
 /* Flag bits used during key generation.  */
 #define KEYGEN_FLAG_NO_PROTECTION 1
 #define KEYGEN_FLAG_TRANSIENT_KEY 2
 #define KEYGEN_FLAG_CREATE_V5_KEY 4
 
 /* Maximum number of supported algorithm preferences.  */
 #define MAX_PREFS 30
 
 enum para_name {
   pKEYTYPE,
   pKEYLENGTH,
   pKEYCURVE,
   pKEYUSAGE,
   pSUBKEYTYPE,
   pSUBKEYLENGTH,
   pSUBKEYCURVE,
   pSUBKEYUSAGE,
   pAUTHKEYTYPE,
   pNAMEREAL,
   pNAMEEMAIL,
   pNAMECOMMENT,
   pPREFERENCES,
   pREVOKER,
   pUSERID,
   pCREATIONDATE,
   pKEYCREATIONDATE, /* Same in seconds since epoch.  */
   pEXPIREDATE,
   pKEYEXPIRE, /* in n seconds */
   pSUBKEYCREATIONDATE,
   pSUBKEYEXPIRE, /* in n seconds */
   pAUTHKEYCREATIONDATE,  /* Not yet used.  */
   pPASSPHRASE,
   pSERIALNO,
   pCARDBACKUPKEY,
   pHANDLE,
   pKEYSERVER,
   pKEYGRIP,
   pSUBKEYGRIP,
   pVERSION,     /* Desired version of the key packet.  */
   pSUBVERSION,  /* Ditto for the subpacket.  */
   pCARDKEY      /* The keygrips have been taken from active card (bool).  */
 };
 
 struct para_data_s {
     struct para_data_s *next;
     int lnr;
     enum para_name key;
     union {
         u32 expire;
         u32 creation;
         int abool;
         unsigned int usage;
         struct revocation_key revkey;
         char value[1];
     } u;
 };
 
 struct output_control_s
 {
   int lnr;
   int dryrun;
   unsigned int keygen_flags;
   int use_files;
   struct {
     char  *fname;
     char  *newfname;
     IOBUF stream;
     armor_filter_context_t *afx;
   } pub;
 };
 
 
 struct opaque_data_usage_and_pk {
     unsigned int usage;
     PKT_public_key *pk;
 };
 
 
 /* FIXME: These globals vars are ugly.  And using MAX_PREFS even for
  * aeads is useless, given that we don't expects more than a very few
  * algorithms.  */
 static int prefs_initialized = 0;
 static byte sym_prefs[MAX_PREFS];
 static int nsym_prefs;
 static byte hash_prefs[MAX_PREFS];
 static int nhash_prefs;
 static byte zip_prefs[MAX_PREFS];
 static int nzip_prefs;
 static byte aead_prefs[MAX_PREFS];
 static int naead_prefs;
 static int mdc_available;
 static int ks_modify;
 static int aead_available;
 
 static gpg_error_t parse_algo_usage_expire (ctrl_t ctrl, int for_subkey,
                                      const char *algostr, const char *usagestr,
                                      const char *expirestr,
                                      int *r_algo, unsigned int *r_usage,
                                      u32 *r_expire, unsigned int *r_nbits,
                                      const char **r_curve, int *r_version,
                                             char **r_keygrip, u32 *r_keytime);
 static void do_generate_keypair (ctrl_t ctrl, struct para_data_s *para,
                                  struct output_control_s *outctrl, int card );
 static int write_keyblock (iobuf_t out, kbnode_t node);
 static gpg_error_t gen_card_key (int keyno, int algo, int is_primary,
                                  kbnode_t pub_root, u32 *timestamp,
                                  u32 expireval, int keygen_flags);
 static unsigned int get_keysize_range (int algo,
                                        unsigned int *min, unsigned int *max);
 
 
 
 /* Return the algo string for a default new key.  */
 const char *
 get_default_pubkey_algo (void)
 {
   if (opt.def_new_key_algo)
     {
       if (*opt.def_new_key_algo && !strchr (opt.def_new_key_algo, ':'))
         return opt.def_new_key_algo;
       /* To avoid checking that option every time we delay that until
        * here.  The only thing we really need to make sure is that
        * there is no colon in the string so that the --gpgconf-list
        * command won't mess up its output.  */
       log_info (_("invalid value for option '%s'\n"), "--default-new-key-algo");
     }
   return DEFAULT_STD_KEY_PARAM;
 }
 
 
 static void
 print_status_key_created (int letter, PKT_public_key *pk, const char *handle)
 {
   byte array[MAX_FINGERPRINT_LEN], *s;
   char *buf, *p;
   size_t i, n;
 
   if (!handle)
     handle = "";
 
   buf = xmalloc (MAX_FINGERPRINT_LEN*2+31 + strlen (handle) + 1);
 
   p = buf;
   if (letter || pk)
     {
       *p++ = letter;
       if (pk)
         {
           *p++ = ' ';
           fingerprint_from_pk (pk, array, &n);
           s = array;
           /* Fixme: Use bin2hex */
           for (i=0; i < n ; i++, s++, p += 2)
             snprintf (p, 3, "%02X", *s);
         }
     }
   if (*handle)
     {
       *p++ = ' ';
       for (i=0; handle[i] && i < 100; i++)
         *p++ = isspace ((unsigned int)handle[i])? '_':handle[i];
     }
   *p = 0;
   write_status_text ((letter || pk)?STATUS_KEY_CREATED:STATUS_KEY_NOT_CREATED,
                      buf);
   xfree (buf);
 }
 
 static void
 print_status_key_not_created (const char *handle)
 {
   print_status_key_created (0, NULL, handle);
 }
 
 
 
 static gpg_error_t
 write_uid (kbnode_t root, const char *s)
 {
-  PACKET *pkt = xmalloc_clear (sizeof *pkt);
+  PACKET *pkt = NULL;
   size_t n = strlen (s);
 
   if (n > MAX_UID_PACKET_LENGTH - 10)
     return gpg_error (GPG_ERR_INV_USER_ID);
 
+  pkt = xmalloc_clear (sizeof *pkt);
   pkt->pkttype = PKT_USER_ID;
   pkt->pkt.user_id = xmalloc_clear (sizeof *pkt->pkt.user_id + n);
   pkt->pkt.user_id->len = n;
   pkt->pkt.user_id->ref = 1;
   strcpy (pkt->pkt.user_id->name, s);
   add_kbnode (root, new_kbnode (pkt));
   return 0;
 }
 
 static void
 do_add_key_flags (PKT_signature *sig, unsigned int use)
 {
     byte buf[1];
 
     buf[0] = 0;
 
     /* The spec says that all primary keys MUST be able to certify. */
     if(sig->sig_class!=0x18)
       buf[0] |= 0x01;
 
     if (use & PUBKEY_USAGE_SIG)
       buf[0] |= 0x02;
     if (use & PUBKEY_USAGE_ENC)
         buf[0] |= 0x04 | 0x08;
     if (use & PUBKEY_USAGE_AUTH)
         buf[0] |= 0x20;
 
     build_sig_subpkt (sig, SIGSUBPKT_KEY_FLAGS, buf, 1);
 }
 
 
 int
 keygen_add_key_expire (PKT_signature *sig, void *opaque)
 {
   PKT_public_key *pk = opaque;
   byte buf[8];
   u32  u;
 
   if (pk->expiredate)
     {
       if (pk->expiredate > pk->timestamp)
         u = pk->expiredate - pk->timestamp;
       else
         u = 1;
 
       buf[0] = (u >> 24) & 0xff;
       buf[1] = (u >> 16) & 0xff;
       buf[2] = (u >>  8) & 0xff;
       buf[3] = u & 0xff;
       build_sig_subpkt (sig, SIGSUBPKT_KEY_EXPIRE, buf, 4);
     }
   else
     {
       /* Make sure we don't leave a key expiration subpacket lying
          around */
       delete_sig_subpkt (sig->hashed, SIGSUBPKT_KEY_EXPIRE);
     }
 
   return 0;
 }
 
 
 /* Add the key usage (i.e. key flags) in SIG from the public keys
  * pubkey_usage field.  OPAQUE has the public key.  */
 int
 keygen_add_key_flags (PKT_signature *sig, void *opaque)
 {
   PKT_public_key *pk = opaque;
 
   do_add_key_flags (sig, pk->pubkey_usage);
   return 0;
 }
 
 
 static int
 keygen_add_key_flags_and_expire (PKT_signature *sig, void *opaque)
 {
   struct opaque_data_usage_and_pk *oduap = opaque;
 
   do_add_key_flags (sig, oduap->usage);
   return keygen_add_key_expire (sig, oduap->pk);
 }
 
 
 static int
 set_one_pref (int val, int type, const char *item, byte *buf, int *nbuf)
 {
     int i;
 
     for (i=0; i < *nbuf; i++ )
       if (buf[i] == val)
 	{
 	  log_info (_("preference '%s' duplicated\n"), item);
 	  return -1;
         }
 
     if (*nbuf >= MAX_PREFS)
       {
 	if(type==1)
 	  log_info(_("too many cipher preferences\n"));
 	else if(type==2)
 	  log_info(_("too many digest preferences\n"));
 	else if(type==3)
 	  log_info(_("too many compression preferences\n"));
 	else if(type==4)
 	  log_info(_("too many AEAD preferences\n"));
 	else
 	  BUG();
 
         return -1;
       }
 
     buf[(*nbuf)++] = val;
     return 0;
 }
 
 /*
  * Parse the supplied string and use it to set the standard
  * preferences.  The string may be in a form like the one printed by
  * "pref" (something like: "S10 S3 H3 H2 Z2 Z1") or the actual
  * cipher/hash/compress names.  Use NULL to set the default
  * preferences.  Returns: 0 = okay
  */
 int
 keygen_set_std_prefs (const char *string,int personal)
 {
     byte sym[MAX_PREFS], hash[MAX_PREFS], zip[MAX_PREFS], aead[MAX_PREFS];
     int nsym=0, nhash=0, nzip=0, naead=0, val, rc=0;
     int mdc=1, modify=0; /* mdc defaults on, modify defaults off. */
     char dummy_string[25*4+1]; /* Enough for 25 items. */
 
     if (!string || !ascii_strcasecmp (string, "default"))
       {
 	if (opt.def_preference_list)
 	  string=opt.def_preference_list;
 	else
 	  {
             int any_compress = 0;
 	    dummy_string[0]='\0';
 
             /* The rationale why we use the order AES256,192,128 is
                for compatibility reasons with PGP.  If gpg would
                define AES128 first, we would get the somewhat
                confusing situation:
 
                  gpg -r pgpkey -r gpgkey  ---gives--> AES256
                  gpg -r gpgkey -r pgpkey  ---gives--> AES
 
                Note that by using --personal-cipher-preferences it is
                possible to prefer AES128.
             */
 
 	    /* Make sure we do not add more than 15 items here, as we
 	       could overflow the size of dummy_string.  We currently
 	       have at most 12. */
 	    if ( !openpgp_cipher_test_algo (CIPHER_ALGO_AES256) )
 	      strcat(dummy_string,"S9 ");
 	    if ( !openpgp_cipher_test_algo (CIPHER_ALGO_AES192) )
 	      strcat(dummy_string,"S8 ");
 	    if ( !openpgp_cipher_test_algo (CIPHER_ALGO_AES) )
 	      strcat(dummy_string,"S7 ");
 	    strcat(dummy_string,"S2 "); /* 3DES */
 
             if (opt.flags.rfc4880bis && !openpgp_aead_test_algo (AEAD_ALGO_OCB))
 	      strcat(dummy_string,"A2 ");
             if (opt.flags.rfc4880bis && !openpgp_aead_test_algo (AEAD_ALGO_EAX))
 	      strcat(dummy_string,"A1 ");
 
             if (personal)
               {
                 /* The default internal hash algo order is:
                  *  SHA-256, SHA-384, SHA-512, SHA-224, SHA-1.
                  */
                 if (!openpgp_md_test_algo (DIGEST_ALGO_SHA256))
                   strcat (dummy_string, "H8 ");
 
                 if (!openpgp_md_test_algo (DIGEST_ALGO_SHA384))
                   strcat (dummy_string, "H9 ");
 
                 if (!openpgp_md_test_algo (DIGEST_ALGO_SHA512))
                   strcat (dummy_string, "H10 ");
               }
             else
               {
                 /* The default advertised hash algo order is:
                  *  SHA-512, SHA-384, SHA-256, SHA-224, SHA-1.
                  */
                 if (!openpgp_md_test_algo (DIGEST_ALGO_SHA512))
                   strcat (dummy_string, "H10 ");
 
                 if (!openpgp_md_test_algo (DIGEST_ALGO_SHA384))
                   strcat (dummy_string, "H9 ");
 
                 if (!openpgp_md_test_algo (DIGEST_ALGO_SHA256))
                   strcat (dummy_string, "H8 ");
               }
 
             if (!openpgp_md_test_algo (DIGEST_ALGO_SHA224))
 	      strcat (dummy_string, "H11 ");
 
 	    strcat (dummy_string, "H2 "); /* SHA-1 */
 
 	    if(!check_compress_algo(COMPRESS_ALGO_ZLIB))
               {
                 strcat(dummy_string,"Z2 ");
                 any_compress = 1;
               }
 
 	    if(!check_compress_algo(COMPRESS_ALGO_BZIP2))
               {
                 strcat(dummy_string,"Z3 ");
                 any_compress = 1;
               }
 
 	    if(!check_compress_algo(COMPRESS_ALGO_ZIP))
               {
                 strcat(dummy_string,"Z1 ");
                 any_compress = 1;
               }
 
             /* In case we have no compress algo at all, declare that
                we prefer no compression.  */
             if (!any_compress)
               strcat(dummy_string,"Z0 ");
 
             /* Remove the trailing space.  */
             if (*dummy_string && dummy_string[strlen (dummy_string)-1] == ' ')
               dummy_string[strlen (dummy_string)-1] = 0;
 
 	    string=dummy_string;
 	  }
       }
     else if (!ascii_strcasecmp (string, "none"))
         string = "";
 
     if(strlen(string))
       {
 	char *prefstringbuf;
         char *tok, *prefstring;
 
         /* We need a writable string. */
 	prefstring = prefstringbuf = xstrdup (string);
 
 	while((tok=strsep(&prefstring," ,")))
 	  {
 	    if((val=string_to_cipher_algo (tok)))
 	      {
 		if(set_one_pref(val,1,tok,sym,&nsym))
 		  rc=-1;
 	      }
 	    else if((val=string_to_digest_algo (tok)))
 	      {
 		if(set_one_pref(val,2,tok,hash,&nhash))
 		  rc=-1;
 	      }
 	    else if((val=string_to_compress_algo(tok))>-1)
 	      {
 		if(set_one_pref(val,3,tok,zip,&nzip))
 		  rc=-1;
 	      }
 	    else if ((val=string_to_aead_algo (tok)))
 	      {
 		if (set_one_pref (val, 4, tok, aead, &naead))
 		  rc = -1;
 	      }
 	    else if (ascii_strcasecmp(tok,"mdc")==0)
 	      mdc=1;
 	    else if (ascii_strcasecmp(tok,"no-mdc")==0)
 	      mdc=0;
 	    else if (ascii_strcasecmp(tok,"ks-modify")==0)
 	      modify=1;
 	    else if (ascii_strcasecmp(tok,"no-ks-modify")==0)
 	      modify=0;
 	    else
 	      {
 		log_info (_("invalid item '%s' in preference string\n"),tok);
 		rc=-1;
 	      }
 	  }
 
 	xfree (prefstringbuf);
       }
 
     if(!rc)
       {
 	if(personal)
 	  {
 	    if(personal==PREFTYPE_SYM)
 	      {
 		xfree(opt.personal_cipher_prefs);
 
 		if(nsym==0)
 		  opt.personal_cipher_prefs=NULL;
 		else
 		  {
 		    int i;
 
 		    opt.personal_cipher_prefs=
 		      xmalloc(sizeof(prefitem_t *)*(nsym+1));
 
 		    for (i=0; i<nsym; i++)
 		      {
 			opt.personal_cipher_prefs[i].type = PREFTYPE_SYM;
 			opt.personal_cipher_prefs[i].value = sym[i];
 		      }
 
 		    opt.personal_cipher_prefs[i].type = PREFTYPE_NONE;
 		    opt.personal_cipher_prefs[i].value = 0;
 		  }
 	      }
 	    else if (personal == PREFTYPE_AEAD)
 	      {
 		xfree(opt.personal_aead_prefs);
 
 		if (!naead)
 		  opt.personal_aead_prefs = NULL;
 		else
 		  {
 		    int i;
 
 		    opt.personal_aead_prefs=
 		      xmalloc(sizeof(prefitem_t *)*(naead+1));
 
 		    for (i=0; i<naead; i++)
 		      {
 			opt.personal_aead_prefs[i].type = PREFTYPE_AEAD;
 			opt.personal_aead_prefs[i].value = sym[i];
 		      }
 
 		    opt.personal_aead_prefs[i].type = PREFTYPE_NONE;
 		    opt.personal_aead_prefs[i].value = 0;
 		  }
 	      }
 	    else if(personal==PREFTYPE_HASH)
 	      {
 		xfree(opt.personal_digest_prefs);
 
 		if(nhash==0)
 		  opt.personal_digest_prefs=NULL;
 		else
 		  {
 		    int i;
 
 		    opt.personal_digest_prefs=
 		      xmalloc(sizeof(prefitem_t *)*(nhash+1));
 
 		    for (i=0; i<nhash; i++)
 		      {
 			opt.personal_digest_prefs[i].type = PREFTYPE_HASH;
 			opt.personal_digest_prefs[i].value = hash[i];
 		      }
 
 		    opt.personal_digest_prefs[i].type = PREFTYPE_NONE;
 		    opt.personal_digest_prefs[i].value = 0;
 		  }
 	      }
 	    else if(personal==PREFTYPE_ZIP)
 	      {
 		xfree(opt.personal_compress_prefs);
 
 		if(nzip==0)
 		  opt.personal_compress_prefs=NULL;
 		else
 		  {
 		    int i;
 
 		    opt.personal_compress_prefs=
 		      xmalloc(sizeof(prefitem_t *)*(nzip+1));
 
 		    for (i=0; i<nzip; i++)
 		      {
 			opt.personal_compress_prefs[i].type = PREFTYPE_ZIP;
 			opt.personal_compress_prefs[i].value = zip[i];
 		      }
 
 		    opt.personal_compress_prefs[i].type = PREFTYPE_NONE;
 		    opt.personal_compress_prefs[i].value = 0;
 		  }
 	      }
 	  }
 	else
 	  {
 	    memcpy (sym_prefs,  sym,  (nsym_prefs=nsym));
 	    memcpy (hash_prefs, hash, (nhash_prefs=nhash));
 	    memcpy (zip_prefs,  zip,  (nzip_prefs=nzip));
 	    memcpy (aead_prefs, aead,  (naead_prefs=naead));
 	    mdc_available = mdc;
             aead_available = !!naead;
 	    ks_modify = modify;
 	    prefs_initialized = 1;
 	  }
       }
 
     return rc;
 }
 
 
 /* Return a fake user ID containing the preferences.  Caller must
    free. */
 PKT_user_id *
 keygen_get_std_prefs(void)
 {
   int i,j=0;
   PKT_user_id *uid=xmalloc_clear(sizeof(PKT_user_id));
 
   if(!prefs_initialized)
     keygen_set_std_prefs(NULL,0);
 
   uid->ref=1;
 
   uid->prefs = xmalloc ((sizeof(prefitem_t *)*
                          (nsym_prefs+naead_prefs+nhash_prefs+nzip_prefs+1)));
 
   for(i=0;i<nsym_prefs;i++,j++)
     {
       uid->prefs[j].type=PREFTYPE_SYM;
       uid->prefs[j].value=sym_prefs[i];
     }
 
   for (i=0; i < naead_prefs; i++, j++)
     {
       uid->prefs[j].type = PREFTYPE_AEAD;
       uid->prefs[j].value = aead_prefs[i];
     }
 
   for(i=0;i<nhash_prefs;i++,j++)
     {
       uid->prefs[j].type=PREFTYPE_HASH;
       uid->prefs[j].value=hash_prefs[i];
     }
 
   for(i=0;i<nzip_prefs;i++,j++)
     {
       uid->prefs[j].type=PREFTYPE_ZIP;
       uid->prefs[j].value=zip_prefs[i];
     }
 
   uid->prefs[j].type=PREFTYPE_NONE;
   uid->prefs[j].value=0;
 
   uid->flags.mdc = mdc_available;
   uid->flags.aead = aead_available;
   uid->flags.ks_modify = ks_modify;
 
   return uid;
 }
 
 static void
 add_feature_mdc (PKT_signature *sig,int enabled)
 {
     const byte *s;
     size_t n;
     int i;
     char *buf;
 
     s = parse_sig_subpkt (sig, 1, SIGSUBPKT_FEATURES, &n );
     /* Already set or cleared */
     if (s && n &&
 	((enabled && (s[0] & 0x01)) || (!enabled && !(s[0] & 0x01))))
       return;
 
     if (!s || !n) { /* create a new one */
         n = 1;
         buf = xmalloc_clear (n);
     }
     else {
         buf = xmalloc (n);
         memcpy (buf, s, n);
     }
 
     if(enabled)
       buf[0] |= 0x01; /* MDC feature */
     else
       buf[0] &= ~0x01;
 
     /* Are there any bits set? */
     for(i=0;i<n;i++)
       if(buf[i]!=0)
 	break;
 
     if(i==n)
       delete_sig_subpkt (sig->hashed, SIGSUBPKT_FEATURES);
     else
       build_sig_subpkt (sig, SIGSUBPKT_FEATURES, buf, n);
 
     xfree (buf);
 }
 
 
 static void
 add_feature_aead (PKT_signature *sig, int enabled)
 {
   const byte *s;
   size_t n;
   int i;
   char *buf;
 
   s = parse_sig_subpkt (sig, 1, SIGSUBPKT_FEATURES, &n );
   if (s && n && ((enabled && (s[0] & 0x02)) || (!enabled && !(s[0] & 0x02))))
     return; /* Already set or cleared */
 
   if (!s || !n)
     { /* Create a new one */
       n = 1;
       buf = xmalloc_clear (n);
     }
   else
     {
       buf = xmalloc (n);
       memcpy (buf, s, n);
     }
 
   if (enabled)
     buf[0] |= 0x02; /* AEAD supported */
   else
     buf[0] &= ~0x02;
 
   /* Are there any bits set? */
   for (i=0; i < n; i++)
     if (buf[i])
       break;
 
   if (i == n)
     delete_sig_subpkt (sig->hashed, SIGSUBPKT_FEATURES);
   else
     build_sig_subpkt (sig, SIGSUBPKT_FEATURES, buf, n);
 
   xfree (buf);
 }
 
 
 static void
 add_feature_v5 (PKT_signature *sig, int enabled)
 {
   const byte *s;
   size_t n;
   int i;
   char *buf;
 
   s = parse_sig_subpkt (sig, 1, SIGSUBPKT_FEATURES, &n );
   if (s && n && ((enabled && (s[0] & 0x04)) || (!enabled && !(s[0] & 0x04))))
     return; /* Already set or cleared */
 
   if (!s || !n)
     { /* Create a new one */
       n = 1;
       buf = xmalloc_clear (n);
     }
   else
     {
       buf = xmalloc (n);
       memcpy (buf, s, n);
     }
 
   if (enabled)
     buf[0] |= 0x04; /* v5 key supported */
   else
     buf[0] &= ~0x04;
 
   /* Are there any bits set? */
   for (i=0; i < n; i++)
     if (buf[i])
       break;
 
   if (i == n)
     delete_sig_subpkt (sig->hashed, SIGSUBPKT_FEATURES);
   else
     build_sig_subpkt (sig, SIGSUBPKT_FEATURES, buf, n);
 
   xfree (buf);
 }
 
 
 static void
 add_keyserver_modify (PKT_signature *sig,int enabled)
 {
   const byte *s;
   size_t n;
   int i;
   char *buf;
 
   /* The keyserver modify flag is a negative flag (i.e. no-modify) */
   enabled=!enabled;
 
   s = parse_sig_subpkt (sig, 1, SIGSUBPKT_KS_FLAGS, &n );
   /* Already set or cleared */
   if (s && n &&
       ((enabled && (s[0] & 0x80)) || (!enabled && !(s[0] & 0x80))))
     return;
 
   if (!s || !n) { /* create a new one */
     n = 1;
     buf = xmalloc_clear (n);
   }
   else {
     buf = xmalloc (n);
     memcpy (buf, s, n);
   }
 
   if(enabled)
     buf[0] |= 0x80; /* no-modify flag */
   else
     buf[0] &= ~0x80;
 
   /* Are there any bits set? */
   for(i=0;i<n;i++)
     if(buf[i]!=0)
       break;
 
   if(i==n)
     delete_sig_subpkt (sig->hashed, SIGSUBPKT_KS_FLAGS);
   else
     build_sig_subpkt (sig, SIGSUBPKT_KS_FLAGS, buf, n);
 
   xfree (buf);
 }
 
 
 int
 keygen_upd_std_prefs (PKT_signature *sig, void *opaque)
 {
   (void)opaque;
 
   if (!prefs_initialized)
     keygen_set_std_prefs (NULL, 0);
 
   if (nsym_prefs)
     build_sig_subpkt (sig, SIGSUBPKT_PREF_SYM, sym_prefs, nsym_prefs);
   else
     {
       delete_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_SYM);
       delete_sig_subpkt (sig->unhashed, SIGSUBPKT_PREF_SYM);
     }
 
   if (naead_prefs)
     build_sig_subpkt (sig, SIGSUBPKT_PREF_AEAD, aead_prefs, naead_prefs);
   else
     {
       delete_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_AEAD);
       delete_sig_subpkt (sig->unhashed, SIGSUBPKT_PREF_AEAD);
     }
 
   if (nhash_prefs)
     build_sig_subpkt (sig, SIGSUBPKT_PREF_HASH, hash_prefs, nhash_prefs);
   else
     {
       delete_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_HASH);
       delete_sig_subpkt (sig->unhashed, SIGSUBPKT_PREF_HASH);
     }
 
   if (nzip_prefs)
     build_sig_subpkt (sig, SIGSUBPKT_PREF_COMPR, zip_prefs, nzip_prefs);
   else
     {
       delete_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_COMPR);
       delete_sig_subpkt (sig->unhashed, SIGSUBPKT_PREF_COMPR);
     }
 
   /* Make sure that the MDC feature flag is set if needed.  */
   add_feature_mdc (sig,mdc_available);
   add_feature_aead (sig, aead_available);
   add_feature_v5 (sig, opt.flags.rfc4880bis);
   add_keyserver_modify (sig,ks_modify);
   keygen_add_keyserver_url(sig,NULL);
 
   return 0;
 }
 
 
 /****************
  * Add preference to the self signature packet.
  * This is only called for packets with version > 3.
  */
 int
 keygen_add_std_prefs (PKT_signature *sig, void *opaque)
 {
   PKT_public_key *pk = opaque;
 
   do_add_key_flags (sig, pk->pubkey_usage);
   keygen_add_key_expire (sig, opaque );
   keygen_upd_std_prefs (sig, opaque);
   keygen_add_keyserver_url (sig,NULL);
 
   return 0;
 }
 
 int
 keygen_add_keyserver_url(PKT_signature *sig, void *opaque)
 {
   const char *url=opaque;
 
   if(!url)
     url=opt.def_keyserver_url;
 
   if(url)
     build_sig_subpkt(sig,SIGSUBPKT_PREF_KS,url,strlen(url));
   else
     delete_sig_subpkt (sig->hashed,SIGSUBPKT_PREF_KS);
 
   return 0;
 }
 
 int
 keygen_add_notations(PKT_signature *sig,void *opaque)
 {
   struct notation *notation;
 
   /* We always start clean */
   delete_sig_subpkt(sig->hashed,SIGSUBPKT_NOTATION);
   delete_sig_subpkt(sig->unhashed,SIGSUBPKT_NOTATION);
   sig->flags.notation=0;
 
   for(notation=opaque;notation;notation=notation->next)
     if(!notation->flags.ignore)
       {
 	unsigned char *buf;
 	unsigned int n1,n2;
 
 	n1=strlen(notation->name);
 	if(notation->altvalue)
 	  n2=strlen(notation->altvalue);
 	else if(notation->bdat)
 	  n2=notation->blen;
 	else
 	  n2=strlen(notation->value);
 
 	buf = xmalloc( 8 + n1 + n2 );
 
 	/* human readable or not */
 	buf[0] = notation->bdat?0:0x80;
 	buf[1] = buf[2] = buf[3] = 0;
 	buf[4] = n1 >> 8;
 	buf[5] = n1;
 	buf[6] = n2 >> 8;
 	buf[7] = n2;
 	memcpy(buf+8, notation->name, n1 );
 	if(notation->altvalue)
 	  memcpy(buf+8+n1, notation->altvalue, n2 );
 	else if(notation->bdat)
 	  memcpy(buf+8+n1, notation->bdat, n2 );
 	else
 	  memcpy(buf+8+n1, notation->value, n2 );
 	build_sig_subpkt( sig, SIGSUBPKT_NOTATION |
 			  (notation->flags.critical?SIGSUBPKT_FLAG_CRITICAL:0),
 			  buf, 8+n1+n2 );
 	xfree(buf);
       }
 
   return 0;
 }
 
 int
 keygen_add_revkey (PKT_signature *sig, void *opaque)
 {
   struct revocation_key *revkey = opaque;
   byte buf[2+MAX_FINGERPRINT_LEN];
 
   log_assert (revkey->fprlen <= MAX_FINGERPRINT_LEN);
   buf[0] = revkey->class;
   buf[1] = revkey->algid;
   memcpy (buf + 2, revkey->fpr, revkey->fprlen);
   memset (buf + 2 + revkey->fprlen, 0, sizeof (revkey->fpr) - revkey->fprlen);
 
   build_sig_subpkt (sig, SIGSUBPKT_REV_KEY, buf, 2+revkey->fprlen);
 
   /* All sigs with revocation keys set are nonrevocable.  */
   sig->flags.revocable = 0;
   buf[0] = 0;
   build_sig_subpkt (sig, SIGSUBPKT_REVOCABLE, buf, 1);
 
   parse_revkeys (sig);
 
   return 0;
 }
 
 
 
 /* Create a back-signature.  If TIMESTAMP is not NULL, use it for the
    signature creation time.  */
 gpg_error_t
 make_backsig (ctrl_t ctrl, PKT_signature *sig, PKT_public_key *pk,
               PKT_public_key *sub_pk, PKT_public_key *sub_psk,
               u32 timestamp, const char *cache_nonce)
 {
   gpg_error_t err;
   PKT_signature *backsig;
 
   cache_public_key (sub_pk);
 
   err = make_keysig_packet (ctrl, &backsig, pk, NULL, sub_pk, sub_psk, 0x19,
                             timestamp, 0, NULL, NULL, cache_nonce);
   if (err)
     log_error ("make_keysig_packet failed for backsig: %s\n",
                gpg_strerror (err));
   else
     {
       /* Get it into a binary packed form. */
       IOBUF backsig_out = iobuf_temp();
       PACKET backsig_pkt;
 
       init_packet (&backsig_pkt);
       backsig_pkt.pkttype = PKT_SIGNATURE;
       backsig_pkt.pkt.signature = backsig;
       err = build_packet (backsig_out, &backsig_pkt);
       free_packet (&backsig_pkt, NULL);
       if (err)
 	log_error ("build_packet failed for backsig: %s\n", gpg_strerror (err));
       else
 	{
 	  size_t pktlen = 0;
 	  byte *buf = iobuf_get_temp_buffer (backsig_out);
 
 	  /* Remove the packet header. */
 	  if(buf[0]&0x40)
 	    {
 	      if (buf[1] < 192)
 		{
 		  pktlen = buf[1];
 		  buf += 2;
 		}
 	      else if(buf[1] < 224)
 		{
 		  pktlen = (buf[1]-192)*256;
 		  pktlen += buf[2]+192;
 		  buf += 3;
 		}
 	      else if (buf[1] == 255)
 		{
                   pktlen = buf32_to_size_t (buf+2);
 		  buf += 6;
 		}
 	      else
 		BUG ();
 	    }
 	  else
 	    {
 	      int mark = 1;
 
 	      switch (buf[0]&3)
 		{
 		case 3:
 		  BUG ();
 		  break;
 
 		case 2:
 		  pktlen  = (size_t)buf[mark++] << 24;
 		  pktlen |= buf[mark++] << 16;
 		  /* fall through */
 		case 1:
 		  pktlen |= buf[mark++] << 8;
 		  /* fall through */
 		case 0:
 		  pktlen |= buf[mark++];
 		}
 
 	      buf += mark;
 	    }
 
 	  /* Now make the binary blob into a subpacket.  */
 	  build_sig_subpkt (sig, SIGSUBPKT_SIGNATURE, buf, pktlen);
 
 	  iobuf_close (backsig_out);
 	}
     }
 
   return err;
 }
 
 
 /* Write a direct key signature to the first key in ROOT using the key
    PSK.  REVKEY is describes the direct key signature and TIMESTAMP is
    the timestamp to set on the signature.  */
 static gpg_error_t
 write_direct_sig (ctrl_t ctrl, kbnode_t root, PKT_public_key *psk,
                   struct revocation_key *revkey, u32 timestamp,
                   const char *cache_nonce)
 {
   gpg_error_t err;
   PACKET *pkt;
   PKT_signature *sig;
   KBNODE node;
   PKT_public_key *pk;
 
   if (opt.verbose)
     log_info (_("writing direct signature\n"));
 
   /* Get the pk packet from the pub_tree. */
   node = find_kbnode (root, PKT_PUBLIC_KEY);
   if (!node)
     BUG ();
   pk = node->pkt->pkt.public_key;
 
   /* We have to cache the key, so that the verification of the
      signature creation is able to retrieve the public key.  */
   cache_public_key (pk);
 
   /* Make the signature.  */
   err = make_keysig_packet (ctrl, &sig, pk, NULL,NULL, psk, 0x1F,
                             timestamp, 0,
                             keygen_add_revkey, revkey, cache_nonce);
   if (err)
     {
       log_error ("make_keysig_packet failed: %s\n", gpg_strerror (err) );
       return err;
     }
 
   pkt = xmalloc_clear (sizeof *pkt);
   pkt->pkttype = PKT_SIGNATURE;
   pkt->pkt.signature = sig;
   add_kbnode (root, new_kbnode (pkt));
   return err;
 }
 
 
 
 /* Write a self-signature to the first user id in ROOT using the key
    PSK.  USE and TIMESTAMP give the extra data we need for the
    signature.  */
 static gpg_error_t
 write_selfsigs (ctrl_t ctrl, kbnode_t root, PKT_public_key *psk,
 		unsigned int use, u32 timestamp, const char *cache_nonce)
 {
   gpg_error_t err;
   PACKET *pkt;
   PKT_signature *sig;
   PKT_user_id *uid;
   KBNODE node;
   PKT_public_key *pk;
 
   if (opt.verbose)
     log_info (_("writing self signature\n"));
 
   /* Get the uid packet from the list. */
   node = find_kbnode (root, PKT_USER_ID);
   if (!node)
     BUG(); /* No user id packet in tree.  */
   uid = node->pkt->pkt.user_id;
 
   /* Get the pk packet from the pub_tree. */
   node = find_kbnode (root, PKT_PUBLIC_KEY);
   if (!node)
     BUG();
   pk = node->pkt->pkt.public_key;
 
   /* The usage has not yet been set - do it now. */
   pk->pubkey_usage = use;
 
   /* We have to cache the key, so that the verification of the
      signature creation is able to retrieve the public key.  */
   cache_public_key (pk);
 
   /* Make the signature.  */
   err = make_keysig_packet (ctrl, &sig, pk, uid, NULL, psk, 0x13,
                             timestamp, 0,
                             keygen_add_std_prefs, pk, cache_nonce);
   if (err)
     {
       log_error ("make_keysig_packet failed: %s\n", gpg_strerror (err));
       return err;
     }
 
   pkt = xmalloc_clear (sizeof *pkt);
   pkt->pkttype = PKT_SIGNATURE;
   pkt->pkt.signature = sig;
   add_kbnode (root, new_kbnode (pkt));
 
   return err;
 }
 
 
 /* Write the key binding signature.  If TIMESTAMP is not NULL use the
    signature creation time.  PRI_PSK is the key use for signing.
    SUB_PSK is a key used to create a back-signature; that one is only
    used if USE has the PUBKEY_USAGE_SIG capability.  */
 static int
 write_keybinding (ctrl_t ctrl, kbnode_t root,
                   PKT_public_key *pri_psk, PKT_public_key *sub_psk,
                   unsigned int use, u32 timestamp, const char *cache_nonce)
 {
   gpg_error_t err;
   PACKET *pkt;
   PKT_signature *sig;
   KBNODE node;
   PKT_public_key *pri_pk, *sub_pk;
   struct opaque_data_usage_and_pk oduap;
 
   if (opt.verbose)
     log_info(_("writing key binding signature\n"));
 
   /* Get the primary pk packet from the tree.  */
   node = find_kbnode (root, PKT_PUBLIC_KEY);
   if (!node)
     BUG();
   pri_pk = node->pkt->pkt.public_key;
 
   /* We have to cache the key, so that the verification of the
    * signature creation is able to retrieve the public key.  */
   cache_public_key (pri_pk);
 
   /* Find the last subkey. */
   sub_pk = NULL;
   for (node = root; node; node = node->next )
     {
       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
         sub_pk = node->pkt->pkt.public_key;
     }
   if (!sub_pk)
     BUG();
 
   /* Make the signature.  */
   oduap.usage = use;
   oduap.pk = sub_pk;
   err = make_keysig_packet (ctrl, &sig, pri_pk, NULL, sub_pk, pri_psk, 0x18,
                             timestamp, 0,
                             keygen_add_key_flags_and_expire, &oduap,
                             cache_nonce);
   if (err)
     {
       log_error ("make_keysig_packeto failed: %s\n", gpg_strerror (err));
       return err;
     }
 
   /* Make a backsig.  */
   if (use & PUBKEY_USAGE_SIG)
     {
       err = make_backsig (ctrl,
                           sig, pri_pk, sub_pk, sub_psk, timestamp, cache_nonce);
       if (err)
         return err;
     }
 
   pkt = xmalloc_clear ( sizeof *pkt );
   pkt->pkttype = PKT_SIGNATURE;
   pkt->pkt.signature = sig;
   add_kbnode (root, new_kbnode (pkt) );
   return err;
 }
 
 
 static gpg_error_t
 ecckey_from_sexp (gcry_mpi_t *array, gcry_sexp_t sexp, int algo)
 {
   gpg_error_t err;
   gcry_sexp_t list, l2;
   char *curve = NULL;
   int i;
   const char *oidstr;
   unsigned int nbits;
 
   array[0] = NULL;
   array[1] = NULL;
   array[2] = NULL;
 
   list = gcry_sexp_find_token (sexp, "public-key", 0);
   if (!list)
     return gpg_error (GPG_ERR_INV_OBJ);
   l2 = gcry_sexp_cadr (list);
   gcry_sexp_release (list);
   list = l2;
   if (!list)
     return gpg_error (GPG_ERR_NO_OBJ);
 
   l2 = gcry_sexp_find_token (list, "curve", 0);
   if (!l2)
     {
       err = gpg_error (GPG_ERR_NO_OBJ);
       goto leave;
     }
   curve = gcry_sexp_nth_string (l2, 1);
   if (!curve)
     {
       err = gpg_error (GPG_ERR_NO_OBJ);
       goto leave;
     }
   gcry_sexp_release (l2);
   oidstr = openpgp_curve_to_oid (curve, &nbits, NULL);
   if (!oidstr)
     {
       /* That can't happen because we used one of the curves
          gpg_curve_to_oid knows about.  */
       err = gpg_error (GPG_ERR_INV_OBJ);
       goto leave;
     }
   err = openpgp_oid_from_str (oidstr, &array[0]);
   if (err)
     goto leave;
 
   err = sexp_extract_param_sos (list, "q", &array[1]);
   if (err)
     goto leave;
 
   gcry_sexp_release (list);
 
   if (algo == PUBKEY_ALGO_ECDH)
     {
       array[2] = pk_ecdh_default_params (nbits);
       if (!array[2])
         {
           err = gpg_error_from_syserror ();
           goto leave;
         }
     }
 
  leave:
   xfree (curve);
   if (err)
     {
       for (i=0; i < 3; i++)
         {
           gcry_mpi_release (array[i]);
           array[i] = NULL;
         }
     }
   return err;
 }
 
 
 /* Extract key parameters from SEXP and store them in ARRAY.  ELEMS is
    a string where each character denotes a parameter name.  TOPNAME is
    the name of the top element above the elements.  */
 static int
 key_from_sexp (gcry_mpi_t *array, gcry_sexp_t sexp,
                const char *topname, const char *elems)
 {
   gcry_sexp_t list, l2;
   const char *s;
   int i, idx;
   int rc = 0;
 
   list = gcry_sexp_find_token (sexp, topname, 0);
   if (!list)
     return gpg_error (GPG_ERR_INV_OBJ);
   l2 = gcry_sexp_cadr (list);
   gcry_sexp_release (list);
   list = l2;
   if (!list)
     return gpg_error (GPG_ERR_NO_OBJ);
 
   for (idx=0,s=elems; *s; s++, idx++)
     {
       l2 = gcry_sexp_find_token (list, s, 1);
       if (!l2)
         {
           rc = gpg_error (GPG_ERR_NO_OBJ); /* required parameter not found */
           goto leave;
         }
       array[idx] = gcry_sexp_nth_mpi (l2, 1, GCRYMPI_FMT_USG);
       gcry_sexp_release (l2);
       if (!array[idx])
         {
           rc = gpg_error (GPG_ERR_INV_OBJ); /* required parameter invalid */
           goto leave;
         }
     }
   gcry_sexp_release (list);
 
  leave:
   if (rc)
     {
       for (i=0; i<idx; i++)
         {
           gcry_mpi_release (array[i]);
           array[i] = NULL;
         }
       gcry_sexp_release (list);
     }
   return rc;
 }
 
 
 /* Create a keyblock using the given KEYGRIP.  ALGO is the OpenPGP
  * algorithm of that keygrip.  If CARDKEY is true the key is expected
  * to already live on the active card.  */
 static int
 do_create_from_keygrip (ctrl_t ctrl, int algo,
                         const char *hexkeygrip, int cardkey,
                         kbnode_t pub_root, u32 timestamp, u32 expireval,
                         int is_subkey, int keygen_flags)
 {
   int err;
   PACKET *pkt;
   PKT_public_key *pk;
   gcry_sexp_t s_key;
   const char *algoelem;
 
   if (hexkeygrip[0] == '&')
     hexkeygrip++;
 
   switch (algo)
     {
     case PUBKEY_ALGO_RSA:       algoelem = "ne"; break;
     case PUBKEY_ALGO_DSA:       algoelem = "pqgy"; break;
     case PUBKEY_ALGO_ELGAMAL_E: algoelem = "pgy"; break;
     case PUBKEY_ALGO_ECDH:
     case PUBKEY_ALGO_ECDSA:     algoelem = ""; break;
     case PUBKEY_ALGO_EDDSA:     algoelem = ""; break;
     default: return gpg_error (GPG_ERR_INTERNAL);
     }
 
 
   /* Ask the agent for the public key matching HEXKEYGRIP.  */
   if (cardkey)
     {
       err = agent_scd_readkey (ctrl, hexkeygrip, &s_key, NULL);
       if (err)
         return err;
     }
   else
     {
       unsigned char *public;
 
       err = agent_readkey (ctrl, 0, hexkeygrip, &public);
       if (err)
         return err;
       err = gcry_sexp_sscan (&s_key, NULL, public,
                                gcry_sexp_canon_len (public, 0, NULL, NULL));
       xfree (public);
       if (err)
         return err;
     }
 
   /* Build a public key packet.  */
   pk = xtrycalloc (1, sizeof *pk);
   if (!pk)
     {
       err = gpg_error_from_syserror ();
       gcry_sexp_release (s_key);
       return err;
     }
 
   pk->timestamp = timestamp;
   pk->version = (keygen_flags & KEYGEN_FLAG_CREATE_V5_KEY)? 5 : 4;
   if (expireval)
     pk->expiredate = pk->timestamp + expireval;
   pk->pubkey_algo = algo;
 
   if (algo == PUBKEY_ALGO_ECDSA
       || algo == PUBKEY_ALGO_EDDSA
       || algo == PUBKEY_ALGO_ECDH )
     err = ecckey_from_sexp (pk->pkey, s_key, algo);
   else
     err = key_from_sexp (pk->pkey, s_key, "public-key", algoelem);
   if (err)
     {
       log_error ("key_from_sexp failed: %s\n", gpg_strerror (err) );
       gcry_sexp_release (s_key);
       free_public_key (pk);
       return err;
     }
   gcry_sexp_release (s_key);
 
   pkt = xtrycalloc (1, sizeof *pkt);
   if (!pkt)
     {
       err = gpg_error_from_syserror ();
       free_public_key (pk);
       return err;
     }
 
   pkt->pkttype = is_subkey ? PKT_PUBLIC_SUBKEY : PKT_PUBLIC_KEY;
   pkt->pkt.public_key = pk;
   add_kbnode (pub_root, new_kbnode (pkt));
 
   return 0;
 }
 
 
 /* Common code for the key generation function gen_xxx.  */
 static int
 common_gen (const char *keyparms, int algo, const char *algoelem,
             kbnode_t pub_root, u32 timestamp, u32 expireval, int is_subkey,
             int keygen_flags, const char *passphrase,
             char **cache_nonce_addr, char **passwd_nonce_addr)
 {
   int err;
   PACKET *pkt;
   PKT_public_key *pk;
   gcry_sexp_t s_key;
 
   err = agent_genkey (NULL, cache_nonce_addr, passwd_nonce_addr, keyparms,
                       !!(keygen_flags & KEYGEN_FLAG_NO_PROTECTION),
                       passphrase, timestamp,
                       &s_key);
   if (err)
     {
       log_error ("agent_genkey failed: %s\n", gpg_strerror (err) );
       return err;
     }
 
   pk = xtrycalloc (1, sizeof *pk);
   if (!pk)
     {
       err = gpg_error_from_syserror ();
       gcry_sexp_release (s_key);
       return err;
     }
 
   pk->timestamp = timestamp;
   pk->version = (keygen_flags & KEYGEN_FLAG_CREATE_V5_KEY)? 5 : 4;
   if (expireval)
     pk->expiredate = pk->timestamp + expireval;
   pk->pubkey_algo = algo;
 
   if (algo == PUBKEY_ALGO_ECDSA
       || algo == PUBKEY_ALGO_EDDSA
       || algo == PUBKEY_ALGO_ECDH )
     err = ecckey_from_sexp (pk->pkey, s_key, algo);
   else
     err = key_from_sexp (pk->pkey, s_key, "public-key", algoelem);
   if (err)
     {
       log_error ("key_from_sexp failed: %s\n", gpg_strerror (err) );
       gcry_sexp_release (s_key);
       free_public_key (pk);
       return err;
     }
   gcry_sexp_release (s_key);
 
   pkt = xtrycalloc (1, sizeof *pkt);
   if (!pkt)
     {
       err = gpg_error_from_syserror ();
       free_public_key (pk);
       return err;
     }
 
   pkt->pkttype = is_subkey ? PKT_PUBLIC_SUBKEY : PKT_PUBLIC_KEY;
   pkt->pkt.public_key = pk;
   add_kbnode (pub_root, new_kbnode (pkt));
 
   return 0;
 }
 
 
 /*
  * Generate an Elgamal key.
  */
 static int
 gen_elg (int algo, unsigned int nbits, KBNODE pub_root,
          u32 timestamp, u32 expireval, int is_subkey,
          int keygen_flags, const char *passphrase,
          char **cache_nonce_addr, char **passwd_nonce_addr)
 {
   int err;
   char *keyparms;
   char nbitsstr[35];
 
   log_assert (is_ELGAMAL (algo));
 
   if (nbits < 1024)
     {
       nbits = 2048;
       log_info (_("keysize invalid; using %u bits\n"), nbits );
     }
   else if (nbits > 4096)
     {
       nbits = 4096;
       log_info (_("keysize invalid; using %u bits\n"), nbits );
     }
 
   if ((nbits % 32))
     {
       nbits = ((nbits + 31) / 32) * 32;
       log_info (_("keysize rounded up to %u bits\n"), nbits );
     }
 
   /* Note that we use transient-key only if no-protection has also
      been enabled.  */
   snprintf (nbitsstr, sizeof nbitsstr, "%u", nbits);
   keyparms = xtryasprintf ("(genkey(%s(nbits %zu:%s)%s))",
                            algo == GCRY_PK_ELG_E ? "openpgp-elg" :
                            algo == GCRY_PK_ELG	 ? "elg" : "x-oops" ,
                            strlen (nbitsstr), nbitsstr,
                            ((keygen_flags & KEYGEN_FLAG_TRANSIENT_KEY)
                             && (keygen_flags & KEYGEN_FLAG_NO_PROTECTION))?
                            "(transient-key)" : "" );
   if (!keyparms)
     err = gpg_error_from_syserror ();
   else
     {
       err = common_gen (keyparms, algo, "pgy",
                         pub_root, timestamp, expireval, is_subkey,
                         keygen_flags, passphrase,
                         cache_nonce_addr, passwd_nonce_addr);
       xfree (keyparms);
     }
 
   return err;
 }
 
 
 /*
  * Generate an DSA key
  */
 static gpg_error_t
 gen_dsa (unsigned int nbits, KBNODE pub_root,
          u32 timestamp, u32 expireval, int is_subkey,
          int keygen_flags, const char *passphrase,
          char **cache_nonce_addr, char **passwd_nonce_addr)
 {
   int err;
   unsigned int qbits;
   char *keyparms;
   char nbitsstr[35];
   char qbitsstr[35];
 
   if (nbits < 768)
     {
       nbits = 2048;
       log_info(_("keysize invalid; using %u bits\n"), nbits );
     }
   else if ( nbits > 3072 )
     {
       nbits = 3072;
       log_info(_("keysize invalid; using %u bits\n"), nbits );
     }
 
   if( (nbits % 64) )
     {
       nbits = ((nbits + 63) / 64) * 64;
       log_info(_("keysize rounded up to %u bits\n"), nbits );
     }
 
   /* To comply with FIPS rules we round up to the next value unless in
      expert mode.  */
   if (!opt.expert && nbits > 1024 && (nbits % 1024))
     {
       nbits = ((nbits + 1023) / 1024) * 1024;
       log_info(_("keysize rounded up to %u bits\n"), nbits );
     }
 
   /*
     Figure out a q size based on the key size.  FIPS 180-3 says:
 
     L = 1024, N = 160
     L = 2048, N = 224
     L = 2048, N = 256
     L = 3072, N = 256
 
     2048/256 is an odd pair since there is also a 2048/224 and
     3072/256.  Matching sizes is not a very exact science.
 
     We'll do 256 qbits for nbits over 2047, 224 for nbits over 1024
     but less than 2048, and 160 for 1024 (DSA1).
   */
 
   if (nbits > 2047)
     qbits = 256;
   else if ( nbits > 1024)
     qbits = 224;
   else
     qbits = 160;
 
   if (qbits != 160 )
     log_info (_("WARNING: some OpenPGP programs can't"
                 " handle a DSA key with this digest size\n"));
 
   snprintf (nbitsstr, sizeof nbitsstr, "%u", nbits);
   snprintf (qbitsstr, sizeof qbitsstr, "%u", qbits);
   keyparms = xtryasprintf ("(genkey(dsa(nbits %zu:%s)(qbits %zu:%s)%s))",
                            strlen (nbitsstr), nbitsstr,
                            strlen (qbitsstr), qbitsstr,
                            ((keygen_flags & KEYGEN_FLAG_TRANSIENT_KEY)
                             && (keygen_flags & KEYGEN_FLAG_NO_PROTECTION))?
                            "(transient-key)" : "" );
   if (!keyparms)
     err = gpg_error_from_syserror ();
   else
     {
       err = common_gen (keyparms, PUBKEY_ALGO_DSA, "pqgy",
                         pub_root, timestamp, expireval, is_subkey,
                         keygen_flags, passphrase,
                         cache_nonce_addr, passwd_nonce_addr);
       xfree (keyparms);
     }
 
   return err;
 }
 
 
 
 /*
  * Generate an ECC key
  */
 static gpg_error_t
 gen_ecc (int algo, const char *curve, kbnode_t pub_root,
          u32 timestamp, u32 expireval, int is_subkey,
          int keygen_flags, const char *passphrase,
          char **cache_nonce_addr, char **passwd_nonce_addr)
 {
   gpg_error_t err;
   char *keyparms;
 
   log_assert (algo == PUBKEY_ALGO_ECDSA
               || algo == PUBKEY_ALGO_EDDSA
               || algo == PUBKEY_ALGO_ECDH);
 
   if (!curve || !*curve)
     return gpg_error (GPG_ERR_UNKNOWN_CURVE);
 
   /* Map the displayed short forms of some curves to their canonical
    * names. */
   if (!ascii_strcasecmp (curve, "cv25519"))
     curve = "Curve25519";
   else if (!ascii_strcasecmp (curve, "ed25519"))
     curve = "Ed25519";
   else if (!ascii_strcasecmp (curve, "cv448"))
     curve = "X448";
   else if (!ascii_strcasecmp (curve, "ed448"))
     curve = "Ed448";
 
   /* Note that we use the "comp" flag with EdDSA to request the use of
      a 0x40 compression prefix octet.  */
   if (algo == PUBKEY_ALGO_EDDSA && !strcmp (curve, "Ed25519"))
     keyparms = xtryasprintf
       ("(genkey(ecc(curve %zu:%s)(flags eddsa comp%s)))",
        strlen (curve), curve,
        (((keygen_flags & KEYGEN_FLAG_TRANSIENT_KEY)
          && (keygen_flags & KEYGEN_FLAG_NO_PROTECTION))?
         " transient-key" : ""));
   else if (algo == PUBKEY_ALGO_EDDSA && !strcmp (curve, "Ed448"))
     keyparms = xtryasprintf
       ("(genkey(ecc(curve %zu:%s)(flags comp%s)))",
        strlen (curve), curve,
        (((keygen_flags & KEYGEN_FLAG_TRANSIENT_KEY)
          && (keygen_flags & KEYGEN_FLAG_NO_PROTECTION))?
         " transient-key" : ""));
   else if (algo == PUBKEY_ALGO_ECDH && !strcmp (curve, "Curve25519"))
     keyparms = xtryasprintf
       ("(genkey(ecc(curve %zu:%s)(flags djb-tweak comp%s)))",
        strlen (curve), curve,
        (((keygen_flags & KEYGEN_FLAG_TRANSIENT_KEY)
          && (keygen_flags & KEYGEN_FLAG_NO_PROTECTION))?
         " transient-key" : ""));
   else if (algo == PUBKEY_ALGO_ECDH && !strcmp (curve, "X448"))
     keyparms = xtryasprintf
       ("(genkey(ecc(curve %zu:%s)(flags comp%s)))",
        strlen (curve), curve,
        (((keygen_flags & KEYGEN_FLAG_TRANSIENT_KEY)
          && (keygen_flags & KEYGEN_FLAG_NO_PROTECTION))?
         " transient-key" : ""));
   else
     keyparms = xtryasprintf
       ("(genkey(ecc(curve %zu:%s)(flags nocomp%s)))",
        strlen (curve), curve,
        (((keygen_flags & KEYGEN_FLAG_TRANSIENT_KEY)
          && (keygen_flags & KEYGEN_FLAG_NO_PROTECTION))?
         " transient-key" : ""));
 
   if (!keyparms)
     err = gpg_error_from_syserror ();
   else
     {
       err = common_gen (keyparms, algo, "",
                         pub_root, timestamp, expireval, is_subkey,
                         keygen_flags, passphrase,
                         cache_nonce_addr, passwd_nonce_addr);
       xfree (keyparms);
     }
 
   return err;
 }
 
 
 /*
  * Generate an RSA key.
  */
 static int
 gen_rsa (int algo, unsigned int nbits, KBNODE pub_root,
          u32 timestamp, u32 expireval, int is_subkey,
          int keygen_flags, const char *passphrase,
          char **cache_nonce_addr, char **passwd_nonce_addr)
 {
   int err;
   char *keyparms;
   char nbitsstr[35];
   const unsigned maxsize = (opt.flags.large_rsa ? 8192 : 4096);
 
   log_assert (is_RSA(algo));
 
   if (!nbits)
     nbits = get_keysize_range (algo, NULL, NULL);
 
   if (nbits < 1024)
     {
       nbits = 3072;
       log_info (_("keysize invalid; using %u bits\n"), nbits );
     }
   else if (nbits > maxsize)
     {
       nbits = maxsize;
       log_info (_("keysize invalid; using %u bits\n"), nbits );
     }
 
   if ((nbits % 32))
     {
       nbits = ((nbits + 31) / 32) * 32;
       log_info (_("keysize rounded up to %u bits\n"), nbits );
     }
 
   snprintf (nbitsstr, sizeof nbitsstr, "%u", nbits);
   keyparms = xtryasprintf ("(genkey(rsa(nbits %zu:%s)%s))",
                            strlen (nbitsstr), nbitsstr,
                            ((keygen_flags & KEYGEN_FLAG_TRANSIENT_KEY)
                             && (keygen_flags & KEYGEN_FLAG_NO_PROTECTION))?
                            "(transient-key)" : "" );
   if (!keyparms)
     err = gpg_error_from_syserror ();
   else
     {
       err = common_gen (keyparms, algo, "ne",
                         pub_root, timestamp, expireval, is_subkey,
                         keygen_flags, passphrase,
                         cache_nonce_addr, passwd_nonce_addr);
       xfree (keyparms);
     }
 
   return err;
 }
 
 
 /****************
  * check valid days:
  * return 0 on error or the multiplier
  */
 static int
 check_valid_days( const char *s )
 {
     if( !digitp(s) )
 	return 0;
     for( s++; *s; s++)
 	if( !digitp(s) )
 	    break;
     if( !*s )
 	return 1;
     if( s[1] )
 	return 0; /* e.g. "2323wc" */
     if( *s == 'd' || *s == 'D' )
 	return 1;
     if( *s == 'w' || *s == 'W' )
 	return 7;
     if( *s == 'm' || *s == 'M' )
 	return 30;
     if( *s == 'y' || *s == 'Y' )
 	return 365;
     return 0;
 }
 
 
 static void
 print_key_flags(int flags)
 {
   if(flags&PUBKEY_USAGE_SIG)
     tty_printf("%s ",_("Sign"));
 
   if(flags&PUBKEY_USAGE_CERT)
     tty_printf("%s ",_("Certify"));
 
   if(flags&PUBKEY_USAGE_ENC)
     tty_printf("%s ",_("Encrypt"));
 
   if(flags&PUBKEY_USAGE_AUTH)
     tty_printf("%s ",_("Authenticate"));
 }
 
 
 /* Ask for the key flags and return them.  CURRENT gives the current
  * usage which should normally be given as 0.  MASK gives the allowed
  * flags.  */
 unsigned int
 ask_key_flags_with_mask (int algo, int subkey, unsigned int current,
                          unsigned int mask)
 {
   /* TRANSLATORS: Please use only plain ASCII characters for the
    * translation.  If this is not possible use single digits.  The
    * string needs to 8 bytes long. Here is a description of the
    * functions:
    *
    *   s = Toggle signing capability
    *   e = Toggle encryption capability
    *   a = Toggle authentication capability
    *   q = Finish
    */
   const char *togglers = _("SsEeAaQq");
   char *answer = NULL;
   const char *s;
   unsigned int possible;
 
   if ( strlen(togglers) != 8 )
     {
       tty_printf ("NOTE: Bad translation at %s:%d. "
                   "Please report.\n", __FILE__, __LINE__);
       togglers = "11223300";
     }
 
   /* Mask the possible usage flags.  This is for example used for a
    * card based key.  For ECDH we need to allows additional usages if
    * they are provided. */
   possible = (openpgp_pk_algo_usage (algo) & mask);
   if (algo == PUBKEY_ALGO_ECDH)
     possible |= (current & (PUBKEY_USAGE_ENC
                             |PUBKEY_USAGE_CERT
                             |PUBKEY_USAGE_SIG
                             |PUBKEY_USAGE_AUTH));
 
   /* However, only primary keys may certify. */
   if (subkey)
     possible &= ~PUBKEY_USAGE_CERT;
 
   /* Preload the current set with the possible set, without
    * authentication if CURRENT is 0.  If CURRENT is non-zero we mask
    * with all possible usages.  */
   if (current)
     current &= possible;
   else
     current = (possible&~PUBKEY_USAGE_AUTH);
 
   for (;;)
     {
       tty_printf("\n");
       tty_printf(_("Possible actions for this %s key: "),
                  (algo == PUBKEY_ALGO_ECDH
                   || algo == PUBKEY_ALGO_ECDSA
                   || algo == PUBKEY_ALGO_EDDSA)
                  ? "ECC" : openpgp_pk_algo_name (algo));
       print_key_flags(possible);
       tty_printf("\n");
       tty_printf(_("Current allowed actions: "));
       print_key_flags(current);
       tty_printf("\n\n");
 
       if(possible&PUBKEY_USAGE_SIG)
 	tty_printf(_("   (%c) Toggle the sign capability\n"),
 		   togglers[0]);
       if(possible&PUBKEY_USAGE_ENC)
 	tty_printf(_("   (%c) Toggle the encrypt capability\n"),
 		   togglers[2]);
       if(possible&PUBKEY_USAGE_AUTH)
 	tty_printf(_("   (%c) Toggle the authenticate capability\n"),
 		   togglers[4]);
 
       tty_printf(_("   (%c) Finished\n"),togglers[6]);
       tty_printf("\n");
 
       xfree(answer);
       answer = cpr_get("keygen.flags",_("Your selection? "));
       cpr_kill_prompt();
 
       if (*answer == '=')
         {
           /* Hack to allow direct entry of the capabilities.  */
           current = 0;
           for (s=answer+1; *s; s++)
             {
               if ((*s == 's' || *s == 'S') && (possible&PUBKEY_USAGE_SIG))
                 current |= PUBKEY_USAGE_SIG;
               else if ((*s == 'e' || *s == 'E') && (possible&PUBKEY_USAGE_ENC))
                 current |= PUBKEY_USAGE_ENC;
               else if ((*s == 'a' || *s == 'A') && (possible&PUBKEY_USAGE_AUTH))
                 current |= PUBKEY_USAGE_AUTH;
               else if (!subkey && *s == 'c')
                 {
                   /* Accept 'c' for the primary key because USAGE_CERT
                      will be set anyway.  This is for folks who
                      want to experiment with a cert-only primary key.  */
                   current |= PUBKEY_USAGE_CERT;
                 }
             }
           break;
         }
       else if (strlen(answer)>1)
 	tty_printf(_("Invalid selection.\n"));
       else if(*answer=='\0' || *answer==togglers[6] || *answer==togglers[7])
 	break;
       else if((*answer==togglers[0] || *answer==togglers[1])
 	      && possible&PUBKEY_USAGE_SIG)
 	{
 	  if(current&PUBKEY_USAGE_SIG)
 	    current&=~PUBKEY_USAGE_SIG;
 	  else
 	    current|=PUBKEY_USAGE_SIG;
 	}
       else if((*answer==togglers[2] || *answer==togglers[3])
 	      && possible&PUBKEY_USAGE_ENC)
 	{
 	  if(current&PUBKEY_USAGE_ENC)
 	    current&=~PUBKEY_USAGE_ENC;
 	  else
 	    current|=PUBKEY_USAGE_ENC;
 	}
       else if((*answer==togglers[4] || *answer==togglers[5])
 	      && possible&PUBKEY_USAGE_AUTH)
 	{
 	  if(current&PUBKEY_USAGE_AUTH)
 	    current&=~PUBKEY_USAGE_AUTH;
 	  else
 	    current|=PUBKEY_USAGE_AUTH;
 	}
       else
 	tty_printf(_("Invalid selection.\n"));
     }
 
   xfree(answer);
 
   return current;
 }
 
 
 unsigned int
 ask_key_flags (int algo, int subkey, unsigned int current)
 {
   return ask_key_flags_with_mask (algo, subkey, current, ~0);
 }
 
 
 /* Check whether we have a key for the key with HEXGRIP.  Returns 0 if
    there is no such key or the OpenPGP algo number for the key.  */
 static int
 check_keygrip (ctrl_t ctrl, const char *hexgrip)
 {
   gpg_error_t err;
   unsigned char *public;
   size_t publiclen;
   int algo;
 
   if (hexgrip[0] == '&')
     hexgrip++;
 
   err = agent_readkey (ctrl, 0, hexgrip, &public);
   if (err)
     return 0;
   publiclen = gcry_sexp_canon_len (public, 0, NULL, NULL);
 
   algo = get_pk_algo_from_canon_sexp (public, publiclen);
   xfree (public);
 
   return map_gcry_pk_to_openpgp (algo);
 }
 
 
 
 /* Ask for an algorithm.  The function returns the algorithm id to
  * create. If ADDMODE is false the function won't show an option to
  * create the primary and subkey combined and won't set R_USAGE
  * either.  If a combined algorithm has been selected, the subkey
  * algorithm is stored at R_SUBKEY_ALGO.  If R_KEYGRIP is given, the
  * user has the choice to enter the keygrip of an existing key.  That
  * keygrip is then stored at this address.  The caller needs to free
  * it.  If R_CARDKEY is not NULL and the keygrip has been taken from
  * an active card, true is stored there; if R_KEYTIME is not NULL the
  * creation time of that key is then stored there.  */
 static int
 ask_algo (ctrl_t ctrl, int addmode, int *r_subkey_algo, unsigned int *r_usage,
           char **r_keygrip, int *r_cardkey, u32 *r_keytime)
 {
   gpg_error_t err;
   char *keygrip = NULL;
   u32 keytime = 0;
   char *answer = NULL;
   int cardkey = 0;
   int algo;
   int dummy_algo;
 
   if (!r_subkey_algo)
     r_subkey_algo = &dummy_algo;
 
   tty_printf (_("Please select what kind of key you want:\n"));
 
 #if GPG_USE_RSA
   if (!addmode)
     tty_printf (_("   (%d) RSA and RSA%s\n"), 1, "");
 #endif
 
   if (!addmode && opt.compliance != CO_DE_VS)
     tty_printf (_("   (%d) DSA and Elgamal%s\n"), 2, "");
 
   if (opt.compliance != CO_DE_VS)
     tty_printf (_("   (%d) DSA (sign only)%s\n"), 3, "");
 #if GPG_USE_RSA
   tty_printf (_("   (%d) RSA (sign only)%s\n"), 4, "");
 #endif
 
   if (addmode)
     {
       if (opt.compliance != CO_DE_VS)
         tty_printf (_("   (%d) Elgamal (encrypt only)%s\n"), 5, "");
 #if GPG_USE_RSA
       tty_printf (_("   (%d) RSA (encrypt only)%s\n"), 6, "");
 #endif
     }
   if (opt.expert)
     {
       if (opt.compliance != CO_DE_VS)
         tty_printf (_("   (%d) DSA (set your own capabilities)%s\n"), 7, "");
 #if GPG_USE_RSA
       tty_printf (_("   (%d) RSA (set your own capabilities)%s\n"), 8, "");
 #endif
     }
 
 #if GPG_USE_ECDSA || GPG_USE_ECDH || GPG_USE_EDDSA
   if (!addmode)
     tty_printf (_("   (%d) ECC (sign and encrypt)%s\n"), 9, _(" *default*") );
   tty_printf (_("  (%d) ECC (sign only)\n"), 10 );
   if (opt.expert)
     tty_printf (_("  (%d) ECC (set your own capabilities)%s\n"), 11, "");
   if (addmode)
     tty_printf (_("  (%d) ECC (encrypt only)%s\n"), 12, "");
 #endif
 
   if (opt.expert && r_keygrip)
     tty_printf (_("  (%d) Existing key%s\n"), 13, "");
   if (r_keygrip)
     tty_printf (_("  (%d) Existing key from card%s\n"), 14, "");
 
   for (;;)
     {
       *r_usage = 0;
       *r_subkey_algo = 0;
       xfree (answer);
       answer = cpr_get ("keygen.algo", _("Your selection? "));
       cpr_kill_prompt ();
       algo = *answer? atoi (answer) : 9;  /* Default algo is 9 */
 
       if (opt.compliance == CO_DE_VS
           && (algo == 2 || algo == 3 || algo == 5 || algo == 7))
         {
           tty_printf (_("Invalid selection.\n"));
         }
       else if ((algo == 1 || !strcmp (answer, "rsa+rsa")) && !addmode)
         {
           algo = PUBKEY_ALGO_RSA;
           *r_subkey_algo = PUBKEY_ALGO_RSA;
           break;
 	}
       else if ((algo == 2 || !strcmp (answer, "dsa+elg")) && !addmode)
         {
           algo = PUBKEY_ALGO_DSA;
           *r_subkey_algo = PUBKEY_ALGO_ELGAMAL_E;
           break;
 	}
       else if (algo == 3 || !strcmp (answer, "dsa"))
         {
           algo = PUBKEY_ALGO_DSA;
           *r_usage = PUBKEY_USAGE_SIG;
           break;
 	}
       else if (algo == 4 || !strcmp (answer, "rsa/s"))
         {
           algo = PUBKEY_ALGO_RSA;
           *r_usage = PUBKEY_USAGE_SIG;
           break;
 	}
       else if ((algo == 5 || !strcmp (answer, "elg")) && addmode)
         {
           algo = PUBKEY_ALGO_ELGAMAL_E;
           *r_usage = PUBKEY_USAGE_ENC;
           break;
 	}
       else if ((algo == 6 || !strcmp (answer, "rsa/e")) && addmode)
         {
           algo = PUBKEY_ALGO_RSA;
           *r_usage = PUBKEY_USAGE_ENC;
           break;
 	}
       else if ((algo == 7 || !strcmp (answer, "dsa/*")) && opt.expert)
         {
           algo = PUBKEY_ALGO_DSA;
           *r_usage = ask_key_flags (algo, addmode, 0);
           break;
 	}
       else if ((algo == 8 || !strcmp (answer, "rsa/*")) && opt.expert)
         {
           algo = PUBKEY_ALGO_RSA;
           *r_usage = ask_key_flags (algo, addmode, 0);
           break;
 	}
       else if ((algo == 9 || !strcmp (answer, "ecc+ecc"))
                && !addmode)
         {
           algo = PUBKEY_ALGO_ECDSA;
           *r_subkey_algo = PUBKEY_ALGO_ECDH;
           break;
 	}
       else if ((algo == 10 || !strcmp (answer, "ecc/s")))
         {
           algo = PUBKEY_ALGO_ECDSA;
           *r_usage = PUBKEY_USAGE_SIG;
           break;
 	}
       else if ((algo == 11 || !strcmp (answer, "ecc/*")) && opt.expert)
         {
           algo = PUBKEY_ALGO_ECDSA;
           *r_usage = ask_key_flags (algo, addmode, 0);
           break;
 	}
       else if ((algo == 12 || !strcmp (answer, "ecc/e"))
                && addmode)
         {
           algo = PUBKEY_ALGO_ECDH;
           *r_usage = PUBKEY_USAGE_ENC;
           break;
 	}
       else if ((algo == 13 || !strcmp (answer, "keygrip"))
                && opt.expert && r_keygrip)
         {
           for (;;)
             {
               xfree (answer);
               answer = tty_get (_("Enter the keygrip: "));
               tty_kill_prompt ();
               trim_spaces (answer);
               if (!*answer)
                 {
                   xfree (answer);
                   answer = NULL;
                   continue;
                 }
 
               if (strlen (answer) != 40 &&
                        !(answer[0] == '&' && strlen (answer+1) == 40))
                 tty_printf
                   (_("Not a valid keygrip (expecting 40 hex digits)\n"));
               else if (!(algo = check_keygrip (ctrl, answer)) )
                 tty_printf (_("No key with this keygrip\n"));
               else
                 break; /* Okay.  */
             }
           xfree (keygrip);
           keygrip = answer;
           answer = NULL;
           *r_usage = ask_key_flags (algo, addmode, 0);
           break;
 	}
       else if ((algo == 14 || !strcmp (answer, "cardkey")) && r_keygrip)
         {
           char *serialno;
           keypair_info_t keypairlist, kpi;
           int count, selection;
 
           err = agent_scd_serialno (&serialno, NULL);
           if (err)
             {
               tty_printf (_("error reading the card: %s\n"),
                           gpg_strerror (err));
               goto ask_again;
             }
           tty_printf (_("Serial number of the card: %s\n"), serialno);
           xfree (serialno);
 
           err = agent_scd_keypairinfo (ctrl, NULL, &keypairlist);
           if (err)
             {
               tty_printf (_("error reading the card: %s\n"),
                           gpg_strerror (err));
               goto ask_again;
             }
 
           do
             {
               char *authkeyref, *encrkeyref, *signkeyref;
 
               agent_scd_getattr_one ("$AUTHKEYID", &authkeyref);
               agent_scd_getattr_one ("$ENCRKEYID", &encrkeyref);
               agent_scd_getattr_one ("$SIGNKEYID", &signkeyref);
 
               tty_printf (_("Available keys:\n"));
               for (count=1, kpi=keypairlist; kpi; kpi = kpi->next, count++)
                 {
                   gcry_sexp_t s_pkey;
                   char *algostr = NULL;
                   enum gcry_pk_algos algoid = 0;
                   const char *keyref = kpi->idstr;
                   int any = 0;
 
                   if (keyref
                       && !agent_scd_readkey (ctrl, keyref, &s_pkey, NULL))
                     {
                       algostr = pubkey_algo_string (s_pkey, &algoid);
                       gcry_sexp_release (s_pkey);
                     }
 
                   /* We need to tweak the algo in case GCRY_PK_ECC is
                    * returned because pubkey_algo_string is not aware
                    * of the OpenPGP algo mapping.  We need to
                    * distinguish between ECDH and ECDSA but we can do
                    * that only if we got usage flags.
                    * Note: Keep this in sync with parse_key_parameter_part.
                    */
                   if (algoid == GCRY_PK_ECC && algostr)
                     {
                       if (!strcmp (algostr, "ed25519"))
                         kpi->algo = PUBKEY_ALGO_EDDSA;
                       else if (!strcmp (algostr, "ed448"))
                         kpi->algo = PUBKEY_ALGO_EDDSA;
                       else if (!strcmp (algostr, "cv25519"))
                         kpi->algo = PUBKEY_ALGO_ECDH;
                       else if (!strcmp (algostr, "cv448"))
                         kpi->algo = PUBKEY_ALGO_ECDH;
                       else if ((kpi->usage & GCRY_PK_USAGE_ENCR))
                         kpi->algo = PUBKEY_ALGO_ECDH;
                       else
                         kpi->algo = PUBKEY_ALGO_ECDSA;
                     }
                   else
                     kpi->algo = map_gcry_pk_to_openpgp (algoid);
 
                   tty_printf ("   (%d) %s %s %s",
                               count, kpi->keygrip, keyref, algostr);
                   if ((kpi->usage & GCRY_PK_USAGE_CERT))
                     {
                       tty_printf ("%scert", any?",":" (");
                       any = 1;
                     }
                   if ((kpi->usage & GCRY_PK_USAGE_SIGN))
                     {
                       tty_printf ("%ssign%s", any?",":" (",
                                   (signkeyref && keyref
                                    && !strcmp (signkeyref, keyref))? "*":"");
                       any = 1;
                     }
                   if ((kpi->usage & GCRY_PK_USAGE_AUTH))
                     {
                       tty_printf ("%sauth%s", any?",":" (",
                                   (authkeyref && keyref
                                    && !strcmp (authkeyref, keyref))? "*":"");
                       any = 1;
                     }
                   if ((kpi->usage & GCRY_PK_USAGE_ENCR))
                     {
                       tty_printf ("%sencr%s", any?",":" (",
                                   (encrkeyref && keyref
                                    && !strcmp (encrkeyref, keyref))? "*":"");
                       any = 1;
                     }
                   tty_printf ("%s\n", any?")":"");
                   xfree (algostr);
                 }
 
               xfree (answer);
               answer = cpr_get ("keygen.cardkey", _("Your selection? "));
               cpr_kill_prompt ();
               trim_spaces (answer);
               selection = atoi (answer);
               xfree (authkeyref);
               xfree (encrkeyref);
               xfree (signkeyref);
             }
           while (!(selection > 0 && selection < count));
 
           for (count=1,kpi=keypairlist; kpi; kpi = kpi->next, count++)
             if (count == selection)
               break;
           if (!kpi)
             {
               /* Just in case COUNT is zero (no keys).  */
               free_keypair_info (keypairlist);
               goto ask_again;
             }
 
           xfree (keygrip);
           keygrip = xstrdup (kpi->keygrip);
           cardkey = 1;
           algo = kpi->algo;
           keytime = kpi->keytime;
 
           /* In expert mode allow to change the usage flags.  */
           if (opt.expert)
             *r_usage = ask_key_flags_with_mask (algo, addmode,
                                                 kpi->usage, kpi->usage);
           else
             {
               *r_usage = kpi->usage;
               if (addmode)
                 *r_usage &= ~GCRY_PK_USAGE_CERT;
             }
           free_keypair_info (keypairlist);
           break;
 	}
       else
         tty_printf (_("Invalid selection.\n"));
 
     ask_again:
       ;
     }
 
   xfree(answer);
   if (r_keygrip)
     *r_keygrip = keygrip;
   if (r_cardkey)
     *r_cardkey = cardkey;
   if (r_keytime)
     *r_keytime = keytime;
   return algo;
 }
 
 
 static unsigned int
 get_keysize_range (int algo, unsigned int *min, unsigned int *max)
 {
   unsigned int def;
   unsigned int dummy1, dummy2;
 
   if (!min)
     min = &dummy1;
   if (!max)
     max = &dummy2;
 
   switch(algo)
     {
     case PUBKEY_ALGO_DSA:
       *min = opt.expert? 768 : 1024;
       *max=3072;
       def=2048;
       break;
 
     case PUBKEY_ALGO_ECDSA:
     case PUBKEY_ALGO_ECDH:
       *min=256;
       *max=521;
       def=256;
       break;
 
     case PUBKEY_ALGO_EDDSA:
       *min=255;
       *max=441;
       def=255;
       break;
 
     default:
       *min = opt.compliance == CO_DE_VS ? 2048: 1024;
       *max = 4096;
       def = 3072;
       break;
     }
 
   return def;
 }
 
 
 /* Return a fixed up keysize depending on ALGO.  */
 static unsigned int
 fixup_keysize (unsigned int nbits, int algo, int silent)
 {
   if (algo == PUBKEY_ALGO_DSA && (nbits % 64))
     {
       nbits = ((nbits + 63) / 64) * 64;
       if (!silent)
         tty_printf (_("rounded up to %u bits\n"), nbits);
     }
   else if (algo == PUBKEY_ALGO_EDDSA)
     {
       if (nbits != 255 && nbits != 441)
         {
           if (nbits < 256)
             nbits = 255;
           else
             nbits = 441;
           if (!silent)
             tty_printf (_("rounded to %u bits\n"), nbits);
         }
     }
   else if (algo == PUBKEY_ALGO_ECDH || algo == PUBKEY_ALGO_ECDSA)
     {
       if (nbits != 256 && nbits != 384 && nbits != 521)
         {
           if (nbits < 256)
             nbits = 256;
           else if (nbits < 384)
             nbits = 384;
           else
             nbits = 521;
           if (!silent)
             tty_printf (_("rounded to %u bits\n"), nbits);
         }
     }
   else if ((nbits % 32))
     {
       nbits = ((nbits + 31) / 32) * 32;
       if (!silent)
         tty_printf (_("rounded up to %u bits\n"), nbits );
     }
 
   return nbits;
 }
 
 
 /* Ask for the key size.  ALGO is the algorithm.  If PRIMARY_KEYSIZE
    is not 0, the function asks for the size of the encryption
    subkey. */
 static unsigned
 ask_keysize (int algo, unsigned int primary_keysize)
 {
   unsigned int nbits;
   unsigned int min, def, max;
   int for_subkey = !!primary_keysize;
   int autocomp = 0;
 
   def = get_keysize_range (algo, &min, &max);
 
   if (primary_keysize && !opt.expert)
     {
       /* Deduce the subkey size from the primary key size.  */
       if (algo == PUBKEY_ALGO_DSA && primary_keysize > 3072)
         nbits = 3072; /* For performance reasons we don't support more
                          than 3072 bit DSA.  However we won't see this
                          case anyway because DSA can't be used as an
                          encryption subkey ;-). */
       else
         nbits = primary_keysize;
       autocomp = 1;
       goto leave;
     }
 
   tty_printf(_("%s keys may be between %u and %u bits long.\n"),
 	     openpgp_pk_algo_name (algo), min, max);
 
   for (;;)
     {
       char *prompt, *answer;
 
       if (for_subkey)
         prompt = xasprintf (_("What keysize do you want "
                               "for the subkey? (%u) "), def);
       else
         prompt = xasprintf (_("What keysize do you want? (%u) "), def);
       answer = cpr_get ("keygen.size", prompt);
       cpr_kill_prompt ();
       nbits = *answer? atoi (answer): def;
       xfree(prompt);
       xfree(answer);
 
       if(nbits<min || nbits>max)
 	tty_printf(_("%s keysizes must be in the range %u-%u\n"),
 		   openpgp_pk_algo_name (algo), min, max);
       else
 	break;
     }
 
   tty_printf (_("Requested keysize is %u bits\n"), nbits);
 
  leave:
   nbits = fixup_keysize (nbits, algo, autocomp);
   return nbits;
 }
 
 
 /* Ask for the curve.  ALGO is the selected algorithm which this
    function may adjust.  Returns a const string of the name of the
    curve.  */
 const char *
 ask_curve (int *algo, int *subkey_algo, const char *current)
 {
   /* NB: We always use a complete algo list so that we have stable
      numbers in the menu regardless on how Gpg was configured.  */
   struct {
     const char *name;
     const char* eddsa_curve; /* Corresponding EdDSA curve.  */
     const char *pretty_name;
     unsigned int supported : 1;   /* Supported by gpg.     */
     unsigned int de_vs : 1;       /* Allowed in CO_DE_VS.  */
     unsigned int expert_only : 1; /* Only with --expert    */
     unsigned int available : 1;   /* Available in Libycrypt (runtime checked) */
   } curves[] = {
 #if GPG_USE_ECDSA || GPG_USE_ECDH
 # define MY_USE_ECDSADH 1
 #else
 # define MY_USE_ECDSADH 0
 #endif
     { "Curve25519",      "Ed25519", "Curve 25519", !!GPG_USE_EDDSA, 0, 0, 0 },
     { "X448",            "Ed448",   "Curve 448",   !!GPG_USE_EDDSA, 0, 1, 0 },
     { "NIST P-256",      NULL, NULL,               MY_USE_ECDSADH,  0, 1, 0 },
     { "NIST P-384",      NULL, NULL,               MY_USE_ECDSADH,  0, 0, 0 },
     { "NIST P-521",      NULL, NULL,               MY_USE_ECDSADH,  0, 1, 0 },
     { "brainpoolP256r1", NULL, "Brainpool P-256",  MY_USE_ECDSADH,  1, 0, 0 },
     { "brainpoolP384r1", NULL, "Brainpool P-384",  MY_USE_ECDSADH,  1, 1, 0 },
     { "brainpoolP512r1", NULL, "Brainpool P-512",  MY_USE_ECDSADH,  1, 1, 0 },
     { "secp256k1",       NULL, NULL,               MY_USE_ECDSADH,  0, 1, 0 },
   };
 #undef MY_USE_ECDSADH
   int idx;
   char *answer;
   const char *result = NULL;
   gcry_sexp_t keyparms;
 
   tty_printf (_("Please select which elliptic curve you want:\n"));
 
   keyparms = NULL;
   for (idx=0; idx < DIM(curves); idx++)
     {
       int rc;
 
       curves[idx].available = 0;
       if (!curves[idx].supported)
         continue;
 
       if (opt.compliance==CO_DE_VS)
         {
           if (!curves[idx].de_vs)
             continue; /* Not allowed.  */
         }
       else if (!opt.expert && curves[idx].expert_only)
         continue;
 
       /* We need to switch from the ECDH name of the curve to the
          EDDSA name of the curve if we want a signing key.  */
       gcry_sexp_release (keyparms);
       rc = gcry_sexp_build (&keyparms, NULL,
                             "(public-key(ecc(curve %s)))",
                             curves[idx].eddsa_curve? curves[idx].eddsa_curve
                             /**/                   : curves[idx].name);
       if (rc)
         continue;
       if (!gcry_pk_get_curve (keyparms, 0, NULL))
         continue;
       if (subkey_algo && curves[idx].eddsa_curve)
         {
           /* Both Curve 25519 (or 448) keys are to be created.  Check that
              Libgcrypt also supports the real Curve25519 (or 448).  */
           gcry_sexp_release (keyparms);
           rc = gcry_sexp_build (&keyparms, NULL,
                                 "(public-key(ecc(curve %s)))",
                                  curves[idx].name);
           if (rc)
             continue;
           if (!gcry_pk_get_curve (keyparms, 0, NULL))
             continue;
         }
 
       curves[idx].available = 1;
       tty_printf ("   (%d) %s%s\n", idx + 1,
                   curves[idx].pretty_name?
                   curves[idx].pretty_name:curves[idx].name,
                   idx == 0? _(" *default*"):"");
     }
   gcry_sexp_release (keyparms);
 
 
   for (;;)
     {
       answer = cpr_get ("keygen.curve", _("Your selection? "));
       cpr_kill_prompt ();
       idx = *answer? atoi (answer) : 1;
       if (!*answer && current)
         {
           xfree(answer);
           return NULL;
         }
       else if (*answer && !idx)
         {
           /* See whether the user entered the name of the curve.  */
           for (idx=0; idx < DIM(curves); idx++)
             {
               if (!opt.expert && curves[idx].expert_only)
                 continue;
               if (!stricmp (curves[idx].name, answer)
                   || (curves[idx].pretty_name
                       && !stricmp (curves[idx].pretty_name, answer)))
                 break;
             }
           if (idx == DIM(curves))
             idx = -1;
         }
       else
         idx--;
       xfree(answer);
       answer = NULL;
       if (idx < 0 || idx >= DIM (curves) || !curves[idx].available)
         tty_printf (_("Invalid selection.\n"));
       else
         {
           /* If the user selected a signing algorithm and Curve25519
              we need to set the algo to EdDSA and update the curve name.
              If switching away from EdDSA, we need to set the algo back
              to ECDSA. */
           if (*algo == PUBKEY_ALGO_ECDSA || *algo == PUBKEY_ALGO_EDDSA)
             {
               if (curves[idx].eddsa_curve)
                 {
                   if (subkey_algo && *subkey_algo == PUBKEY_ALGO_ECDSA)
                     *subkey_algo = PUBKEY_ALGO_EDDSA;
                   *algo = PUBKEY_ALGO_EDDSA;
                   result = curves[idx].eddsa_curve;
                 }
               else
                 {
                   if (subkey_algo && *subkey_algo == PUBKEY_ALGO_EDDSA)
                     *subkey_algo = PUBKEY_ALGO_ECDSA;
                   *algo = PUBKEY_ALGO_ECDSA;
                   result = curves[idx].name;
                 }
             }
           else
             result = curves[idx].name;
           break;
         }
     }
 
   if (!result)
     result = curves[0].name;
 
   return result;
 }
 
 
 /****************
  * Parse an expire string and return its value in seconds.
  * Returns (u32)-1 on error.
  * This isn't perfect since scan_isodatestr returns unix time, and
  * OpenPGP actually allows a 32-bit time *plus* a 32-bit offset.
  * Because of this, we only permit setting expirations up to 2106, but
  * OpenPGP could theoretically allow up to 2242.  I think we'll all
  * just cope for the next few years until we get a 64-bit time_t or
  * similar.
  */
 u32
 parse_expire_string( const char *string )
 {
   int mult;
   u32 seconds;
   u32 abs_date = 0;
   u32 curtime = make_timestamp ();
   time_t tt;
 
   if (!string || !*string || !strcmp (string, "none")
       || !strcmp (string, "never") || !strcmp (string, "-"))
     seconds = 0;
   else if (!strncmp (string, "seconds=", 8))
     seconds = atoi (string+8);
   else if ((abs_date = scan_isodatestr(string))
            && (abs_date+86400/2) > curtime)
     seconds = (abs_date+86400/2) - curtime;
   else if ((tt = isotime2epoch (string)) != (time_t)(-1))
     seconds = (u32)tt - curtime;
   else if ((mult = check_valid_days (string)))
     seconds = atoi (string) * 86400L * mult;
   else
     seconds = (u32)(-1);
 
   return seconds;
 }
 
 /* Parse a Creation-Date string which is either "1986-04-26" or
    "19860426T042640".  Returns 0 on error. */
 static u32
 parse_creation_string (const char *string)
 {
   u32 seconds;
 
   if (!*string)
     seconds = 0;
   else if ( !strncmp (string, "seconds=", 8) )
     seconds = atoi (string+8);
   else if ( !(seconds = scan_isodatestr (string)))
     {
       time_t tmp = isotime2epoch (string);
       seconds = (tmp == (time_t)(-1))? 0 : tmp;
     }
   return seconds;
 }
 
 
 /* object == 0 for a key, and 1 for a sig */
 u32
 ask_expire_interval(int object,const char *def_expire)
 {
     u32 interval;
     char *answer;
 
     switch(object)
       {
       case 0:
 	if(def_expire)
 	  BUG();
 	tty_printf(_("Please specify how long the key should be valid.\n"
 		     "         0 = key does not expire\n"
 		     "      <n>  = key expires in n days\n"
 		     "      <n>w = key expires in n weeks\n"
 		     "      <n>m = key expires in n months\n"
 		     "      <n>y = key expires in n years\n"));
 	break;
 
       case 1:
 	if(!def_expire)
 	  BUG();
 	tty_printf(_("Please specify how long the signature should be valid.\n"
 		     "         0 = signature does not expire\n"
 		     "      <n>  = signature expires in n days\n"
 		     "      <n>w = signature expires in n weeks\n"
 		     "      <n>m = signature expires in n months\n"
 		     "      <n>y = signature expires in n years\n"));
 	break;
 
       default:
 	BUG();
       }
 
     /* Note: The elgamal subkey for DSA has no expiration date because
      * it must be signed with the DSA key and this one has the expiration
      * date */
 
     answer = NULL;
     for(;;)
       {
 	u32 curtime;
 
 	xfree(answer);
 	if(object==0)
 	  answer = cpr_get("keygen.valid",_("Key is valid for? (0) "));
 	else
 	  {
 	    char *prompt;
 
 	    prompt = xasprintf (_("Signature is valid for? (%s) "), def_expire);
 	    answer = cpr_get("siggen.valid",prompt);
 	    xfree(prompt);
 
 	    if(*answer=='\0')
-	      answer=xstrdup(def_expire);
+              {
+                xfree (answer);
+	        answer = xstrdup (def_expire);
+              }
 	  }
 	cpr_kill_prompt();
 	trim_spaces(answer);
         curtime = make_timestamp ();
 	interval = parse_expire_string( answer );
 	if( interval == (u32)-1 )
 	  {
 	    tty_printf(_("invalid value\n"));
 	    continue;
 	  }
 
 	if( !interval )
 	  {
             tty_printf((object==0)
                        ? _("Key does not expire at all\n")
                        : _("Signature does not expire at all\n"));
 	  }
 	else
 	  {
 	    tty_printf(object==0
 		       ? _("Key expires at %s\n")
 		       : _("Signature expires at %s\n"),
 		       asctimestamp((ulong)(curtime + interval) ) );
 #if SIZEOF_TIME_T <= 4 && !defined (HAVE_UNSIGNED_TIME_T)
 	    if ( (time_t)((ulong)(curtime+interval)) < 0 )
 	      tty_printf (_("Your system can't display dates beyond 2038.\n"
                             "However, it will be correctly handled up to"
                             " 2106.\n"));
             else
 #endif /*SIZEOF_TIME_T*/
               if ( (time_t)((unsigned long)(curtime+interval)) < curtime )
                 {
                   tty_printf (_("invalid value\n"));
                   continue;
                 }
 	  }
 
 	if( cpr_enabled() || cpr_get_answer_is_yes("keygen.valid.okay",
 						   _("Is this correct? (y/N) ")) )
 	  break;
       }
 
     xfree(answer);
     return interval;
 }
 
 u32
 ask_expiredate()
 {
     u32 x = ask_expire_interval(0,NULL);
     return x? make_timestamp() + x : 0;
 }
 
 
 
 static PKT_user_id *
 uid_from_string (const char *string)
 {
   size_t n;
   PKT_user_id *uid;
 
   n = strlen (string);
   uid = xmalloc_clear (sizeof *uid + n);
   uid->len = n;
   strcpy (uid->name, string);
   uid->ref = 1;
   return uid;
 }
 
 
 /* Return true if the user id UID already exists in the keyblock.  */
 static int
 uid_already_in_keyblock (kbnode_t keyblock, const char *uid)
 {
   PKT_user_id *uidpkt = uid_from_string (uid);
   kbnode_t node;
   int result = 0;
 
   for (node=keyblock; node && !result; node=node->next)
     if (!is_deleted_kbnode (node)
         && node->pkt->pkttype == PKT_USER_ID
         && !cmp_user_ids (uidpkt, node->pkt->pkt.user_id))
       result = 1;
   free_user_id (uidpkt);
   return result;
 }
 
 
 /* Ask for a user ID.  With a MODE of 1 an extra help prompt is
    printed for use during a new key creation.  If KEYBLOCK is not NULL
    the function prevents the creation of an already existing user
    ID.  IF FULL is not set some prompts are not shown.  */
 static char *
 ask_user_id (int mode, int full, KBNODE keyblock)
 {
     char *answer;
     char *aname, *acomment, *amail, *uid;
 
     if ( !mode )
       {
         /* TRANSLATORS: This is the new string telling the user what
            gpg is now going to do (i.e. ask for the parts of the user
            ID).  Note that if you do not translate this string, a
            different string will be used, which might still have
            a correct translation.  */
 	const char *s1 =
           N_("\n"
              "GnuPG needs to construct a user ID to identify your key.\n"
              "\n");
         const char *s2 = _(s1);
 
         if (!strcmp (s1, s2))
           {
             /* There is no translation for the string thus we to use
                the old info text.  gettext has no way to tell whether
                a translation is actually available, thus we need to
                to compare again. */
             /* TRANSLATORS: This string is in general not anymore used
                but you should keep your existing translation.  In case
                the new string is not translated this old string will
                be used. */
             const char *s3 = N_("\n"
 "You need a user ID to identify your key; "
                                         "the software constructs the user ID\n"
 "from the Real Name, Comment and Email Address in this form:\n"
 "    \"Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>\"\n\n");
             const char *s4 = _(s3);
             if (strcmp (s3, s4))
               s2 = s3; /* A translation exists - use it. */
           }
         tty_printf ("%s", s2) ;
       }
     uid = aname = acomment = amail = NULL;
     for(;;) {
 	char *p;
 	int fail=0;
 
 	if( !aname ) {
 	    for(;;) {
 		xfree(aname);
 		aname = cpr_get("keygen.name",_("Real name: "));
 		trim_spaces(aname);
 		cpr_kill_prompt();
 
 		if( opt.allow_freeform_uid )
 		    break;
 
 		if( strpbrk( aname, "<>" ) )
                   {
 		    tty_printf(_("Invalid character in name\n"));
 		    tty_printf(_("The characters '%s' and '%s' may not "
                                  "appear in name\n"), "<", ">");
                   }
 		else if( digitp(aname) )
 		    tty_printf(_("Name may not start with a digit\n"));
 		else if (*aname && strlen (aname) < 5)
                   {
 		    tty_printf(_("Name must be at least 5 characters long\n"));
                     /* However, we allow an empty name.  */
                   }
 		else
 		    break;
 	    }
 	}
 	if( !amail ) {
 	    for(;;) {
 		xfree(amail);
 		amail = cpr_get("keygen.email",_("Email address: "));
 		trim_spaces(amail);
 		cpr_kill_prompt();
 		if( !*amail || opt.allow_freeform_uid )
 		    break;   /* no email address is okay */
 		else if ( !is_valid_mailbox (amail) )
                     tty_printf(_("Not a valid email address\n"));
 		else
 		    break;
 	    }
 	}
 	if (!acomment) {
           if (full) {
 	    for(;;) {
 		xfree(acomment);
 		acomment = cpr_get("keygen.comment",_("Comment: "));
 		trim_spaces(acomment);
 		cpr_kill_prompt();
 		if( !*acomment )
 		    break;   /* no comment is okay */
 		else if( strpbrk( acomment, "()" ) )
 		    tty_printf(_("Invalid character in comment\n"));
 		else
 		    break;
 	    }
           }
           else {
             xfree (acomment);
             acomment = xstrdup ("");
           }
 	}
 
 
 	xfree(uid);
 	uid = p = xmalloc(strlen(aname)+strlen(amail)+strlen(acomment)+12+10);
         if (!*aname && *amail && !*acomment && !random_is_faked ())
           { /* Empty name and comment but with mail address.  Use
                simplified form with only the non-angle-bracketed mail
                address.  */
             p = stpcpy (p, amail);
           }
         else
           {
             p = stpcpy (p, aname );
             if (*acomment)
               p = stpcpy(stpcpy(stpcpy(p," ("), acomment),")");
             if (*amail)
               p = stpcpy(stpcpy(stpcpy(p," <"), amail),">");
           }
 
 	/* Append a warning if the RNG is switched into fake mode.  */
         if ( random_is_faked ()  )
           strcpy(p, " (insecure!)" );
 
 	/* print a note in case that UTF8 mapping has to be done */
 	for(p=uid; *p; p++ ) {
 	    if( *p & 0x80 ) {
 		tty_printf(_("You are using the '%s' character set.\n"),
 			   get_native_charset() );
 		break;
 	    }
 	}
 
 	tty_printf(_("You selected this USER-ID:\n    \"%s\"\n\n"), uid);
 
 	if( !*amail && !opt.allow_freeform_uid
 	    && (strchr( aname, '@' ) || strchr( acomment, '@'))) {
 	    fail = 1;
             tty_printf(_("Please don't put the email address "
                          "into the real name or the comment\n") );
 	}
 
         if (!fail && keyblock)
           {
             if (uid_already_in_keyblock (keyblock, uid))
               {
                 tty_printf (_("Such a user ID already exists on this key!\n"));
                 fail = 1;
               }
           }
 
 	for(;;) {
             /* TRANSLATORS: These are the allowed answers in
                lower and uppercase.  Below you will find the matching
                string which should be translated accordingly and the
                letter changed to match the one in the answer string.
 
                  n = Change name
                  c = Change comment
                  e = Change email
                  o = Okay (ready, continue)
                  q = Quit
              */
 	    const char *ansstr = _("NnCcEeOoQq");
 
 	    if( strlen(ansstr) != 10 )
 		BUG();
 	    if( cpr_enabled() ) {
                 answer = xstrdup (ansstr + (fail?8:6));
 		answer[1] = 0;
 	    }
             else if (full) {
 		answer = cpr_get("keygen.userid.cmd", fail?
 		  _("Change (N)ame, (C)omment, (E)mail or (Q)uit? ") :
 		  _("Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? "));
 		cpr_kill_prompt();
             }
             else {
 		answer = cpr_get("keygen.userid.cmd", fail?
 		  _("Change (N)ame, (E)mail, or (Q)uit? ") :
 		  _("Change (N)ame, (E)mail, or (O)kay/(Q)uit? "));
 		cpr_kill_prompt();
 	    }
 	    if( strlen(answer) > 1 )
 		;
 	    else if( *answer == ansstr[0] || *answer == ansstr[1] ) {
 		xfree(aname); aname = NULL;
 		break;
 	    }
 	    else if( *answer == ansstr[2] || *answer == ansstr[3] ) {
 		xfree(acomment); acomment = NULL;
 		break;
 	    }
 	    else if( *answer == ansstr[4] || *answer == ansstr[5] ) {
 		xfree(amail); amail = NULL;
 		break;
 	    }
 	    else if( *answer == ansstr[6] || *answer == ansstr[7] ) {
 		if( fail ) {
 		    tty_printf(_("Please correct the error first\n"));
 		}
 		else {
 		    xfree(aname); aname = NULL;
 		    xfree(acomment); acomment = NULL;
 		    xfree(amail); amail = NULL;
 		    break;
 		}
 	    }
 	    else if( *answer == ansstr[8] || *answer == ansstr[9] ) {
 		xfree(aname); aname = NULL;
 		xfree(acomment); acomment = NULL;
 		xfree(amail); amail = NULL;
 		xfree(uid); uid = NULL;
 		break;
 	    }
 	    xfree(answer);
 	}
 	xfree(answer);
 	if (!amail && !acomment)
 	    break;
 	xfree(uid); uid = NULL;
     }
     if( uid ) {
 	char *p = native_to_utf8( uid );
 	xfree( uid );
 	uid = p;
     }
     return uid;
 }
 
 
 /* Basic key generation.  Here we divert to the actual generation
    routines based on the requested algorithm.  */
 static int
 do_create (int algo, unsigned int nbits, const char *curve, kbnode_t pub_root,
            u32 timestamp, u32 expiredate, int is_subkey,
            int keygen_flags, const char *passphrase,
            char **cache_nonce_addr, char **passwd_nonce_addr)
 {
   gpg_error_t err;
 
   /* Fixme: The entropy collecting message should be moved to a
      libgcrypt progress handler.  */
   if (!opt.batch)
     tty_printf (_(
 "We need to generate a lot of random bytes. It is a good idea to perform\n"
 "some other action (type on the keyboard, move the mouse, utilize the\n"
 "disks) during the prime generation; this gives the random number\n"
 "generator a better chance to gain enough entropy.\n") );
 
   if (algo == PUBKEY_ALGO_ELGAMAL_E)
     err = gen_elg (algo, nbits, pub_root, timestamp, expiredate, is_subkey,
                    keygen_flags, passphrase,
                    cache_nonce_addr, passwd_nonce_addr);
   else if (algo == PUBKEY_ALGO_DSA)
     err = gen_dsa (nbits, pub_root, timestamp, expiredate, is_subkey,
                    keygen_flags, passphrase,
                    cache_nonce_addr, passwd_nonce_addr);
   else if (algo == PUBKEY_ALGO_ECDSA
            || algo == PUBKEY_ALGO_EDDSA
            || algo == PUBKEY_ALGO_ECDH)
     err = gen_ecc (algo, curve, pub_root, timestamp, expiredate, is_subkey,
                    keygen_flags, passphrase,
                    cache_nonce_addr, passwd_nonce_addr);
   else if (algo == PUBKEY_ALGO_RSA)
     err = gen_rsa (algo, nbits, pub_root, timestamp, expiredate, is_subkey,
                    keygen_flags, passphrase,
                    cache_nonce_addr, passwd_nonce_addr);
   else
     BUG();
 
   return err;
 }
 
 
 /* Generate a new user id packet or return NULL if canceled.  If
    KEYBLOCK is not NULL the function prevents the creation of an
    already existing user ID.  If UIDSTR is not NULL the user is not
    asked but UIDSTR is used to create the user id packet; if the user
    id already exists NULL is returned.  UIDSTR is expected to be utf-8
    encoded and should have already been checked for a valid length
    etc.  */
 PKT_user_id *
 generate_user_id (KBNODE keyblock, const char *uidstr)
 {
   PKT_user_id *uid;
   char *p;
 
   if (uidstr)
     {
       if (uid_already_in_keyblock (keyblock, uidstr))
         return NULL;  /* Already exists.  */
       uid = uid_from_string (uidstr);
     }
   else
     {
       p = ask_user_id (1, 1, keyblock);
       if (!p)
         return NULL;  /* Canceled. */
       uid = uid_from_string (p);
       xfree (p);
     }
   return uid;
 }
 
 
 /* Helper for parse_key_parameter_part_parameter_string for one part of the
  * specification string; i.e.  ALGO/FLAGS.  If STRING is NULL or empty
  * success is returned.  On error an error code is returned.  Note
  * that STRING may be modified by this function.  NULL may be passed
  * for any parameter.  FOR_SUBKEY shall be true if this is used as a
  * subkey.  If CLEAR_CERT is set a default CERT usage will be cleared;
  * this is useful if for example the default algorithm is used for a
  * subkey.  If R_KEYVERSION is not NULL it will receive the version of
  * the key; this is currently 4 but can be changed with the flag "v5"
  * to create a v5 key.  If R_KEYTIME is not NULL and the key has been
  * taken from active OpenPGP card, its creation time is stored
  * there.  */
 static gpg_error_t
 parse_key_parameter_part (ctrl_t ctrl,
                           char *string, int for_subkey, int clear_cert,
                           int *r_algo, unsigned int *r_size,
                           unsigned int *r_keyuse,
                           char const **r_curve, int *r_keyversion,
                           char **r_keygrip, u32 *r_keytime)
 {
   gpg_error_t err;
   char *flags;
   int algo;
   char *endp;
   const char *curve = NULL;
   int ecdh_or_ecdsa = 0;
   unsigned int size;
   int keyuse;
   int keyversion = 0;           /* Not specified.  */
   int i;
   const char *s;
   int from_card = 0;
   char *keygrip = NULL;
   u32 keytime = 0;
   int is_448 = 0;
 
   if (!string || !*string)
     return 0; /* Success.  */
 
   flags = strchr (string, '/');
   if (flags)
     *flags++ = 0;
 
   algo = 0;
   if (!ascii_strcasecmp (string, "card"))
     from_card = 1;
   else if (strlen (string) >= 3 && (digitp (string+3) || !string[3]))
     {
       if (!ascii_memcasecmp (string, "rsa", 3))
         algo = PUBKEY_ALGO_RSA;
       else if (!ascii_memcasecmp (string, "dsa", 3))
         algo = PUBKEY_ALGO_DSA;
       else if (!ascii_memcasecmp (string, "elg", 3))
         algo = PUBKEY_ALGO_ELGAMAL_E;
     }
 
   if (from_card)
     ; /* We need the flags before we can figure out the key to use.  */
   else if (algo)
     {
       if (!string[3])
         size = get_keysize_range (algo, NULL, NULL);
       else
         {
           size = strtoul (string+3, &endp, 10);
           if (size < 512 || size > 16384 || *endp)
             return gpg_error (GPG_ERR_INV_VALUE);
         }
     }
   else if ((curve = openpgp_is_curve_supported (string, &algo, &size)))
     {
       if (!algo)
         {
           algo = PUBKEY_ALGO_ECDH; /* Default ECC algorithm.  */
           ecdh_or_ecdsa = 1;       /* We may need to switch the algo.  */
         }
       if (curve && (!strcmp (curve, "X448") || !strcmp (curve, "Ed448")))
         is_448 = 1;
     }
   else
     return gpg_error (GPG_ERR_UNKNOWN_CURVE);
 
   /* Parse the flags.  */
   keyuse = 0;
   if (flags)
     {
       char **tokens = NULL;
 
       tokens = strtokenize (flags, ",");
       if (!tokens)
         return gpg_error_from_syserror ();
 
       for (i=0; (s = tokens[i]); i++)
         {
           if (!*s)
             ;
           else if (!ascii_strcasecmp (s, "sign"))
             keyuse |= PUBKEY_USAGE_SIG;
           else if (!ascii_strcasecmp (s, "encrypt")
                    || !ascii_strcasecmp (s, "encr"))
             keyuse |= PUBKEY_USAGE_ENC;
           else if (!ascii_strcasecmp (s, "auth"))
             keyuse |= PUBKEY_USAGE_AUTH;
           else if (!ascii_strcasecmp (s, "cert"))
             keyuse |= PUBKEY_USAGE_CERT;
           else if (!ascii_strcasecmp (s, "ecdsa") && !from_card)
             {
               if (algo == PUBKEY_ALGO_ECDH || algo == PUBKEY_ALGO_ECDSA)
                 algo = PUBKEY_ALGO_ECDSA;
               else
                 {
                   xfree (tokens);
                   return gpg_error (GPG_ERR_INV_FLAG);
                 }
               ecdh_or_ecdsa = 0;
             }
           else if (!ascii_strcasecmp (s, "ecdh") && !from_card)
             {
               if (algo == PUBKEY_ALGO_ECDH || algo == PUBKEY_ALGO_ECDSA)
                 algo = PUBKEY_ALGO_ECDH;
               else
                 {
                   xfree (tokens);
                   return gpg_error (GPG_ERR_INV_FLAG);
                 }
               ecdh_or_ecdsa = 0;
             }
           else if (!ascii_strcasecmp (s, "eddsa") && !from_card)
             {
               /* Not required but we allow it for consistency.  */
               if (algo == PUBKEY_ALGO_EDDSA)
                 ;
               else
                 {
                   xfree (tokens);
                   return gpg_error (GPG_ERR_INV_FLAG);
                 }
             }
           else if (!ascii_strcasecmp (s, "v5"))
             {
               if (opt.flags.rfc4880bis)
                 keyversion = 5;
             }
           else if (!ascii_strcasecmp (s, "v4"))
             keyversion = 4;
           else
             {
               xfree (tokens);
               return gpg_error (GPG_ERR_UNKNOWN_FLAG);
             }
         }
 
       xfree (tokens);
     }
 
   /* If not yet decided switch between ecdh and ecdsa unless we want
    * to read the algo from the current card.  */
   if (from_card)
     {
       keypair_info_t keypairlist, kpi;
       char *reqkeyref;
 
       if (!keyuse)
         keyuse = (for_subkey? PUBKEY_USAGE_ENC
                   /* */     : (PUBKEY_USAGE_CERT|PUBKEY_USAGE_SIG));
 
       /* Access the card to make sure we have one and to show the S/N.  */
       {
         char *serialno;
 
         err = agent_scd_serialno (&serialno, NULL);
         if (err)
           {
             log_error (_("error reading the card: %s\n"), gpg_strerror (err));
             return err;
           }
         if (!opt.quiet)
           log_info (_("Serial number of the card: %s\n"), serialno);
         xfree (serialno);
       }
 
       err = agent_scd_keypairinfo (ctrl, NULL, &keypairlist);
       if (err)
         {
           log_error (_("error reading the card: %s\n"), gpg_strerror (err));
           return err;
         }
       agent_scd_getattr_one ((keyuse & (PUBKEY_USAGE_SIG|PUBKEY_USAGE_CERT))
                              ? "$SIGNKEYID":"$ENCRKEYID", &reqkeyref);
 
       algo = 0; /* Should already be the case.  */
       for (kpi=keypairlist; kpi && !algo; kpi = kpi->next)
         {
           gcry_sexp_t s_pkey;
           char *algostr = NULL;
           enum gcry_pk_algos algoid = 0;
           const char *keyref = kpi->idstr;
 
           if (!reqkeyref)
             continue; /* Card does not provide the info (skip all).  */
 
           if (!keyref)
             continue; /* Ooops.  */
           if (strcmp (reqkeyref, keyref))
             continue;  /* This is not the requested keyref.  */
 
           if ((keyuse & (PUBKEY_USAGE_SIG|PUBKEY_USAGE_CERT))
               && (kpi->usage & (GCRY_PK_USAGE_SIGN|GCRY_PK_USAGE_CERT)))
             ; /* Okay */
           else if ((keyuse & PUBKEY_USAGE_ENC)
                    && (kpi->usage & GCRY_PK_USAGE_ENCR))
             ; /* Okay */
           else
             continue; /* Not usable for us.  */
 
           if (agent_scd_readkey (ctrl, keyref, &s_pkey, NULL))
             continue;  /* Could not read the key.  */
 
           algostr = pubkey_algo_string (s_pkey, &algoid);
           gcry_sexp_release (s_pkey);
 
           /* Map to OpenPGP algo number.
            * We need to tweak the algo in case GCRY_PK_ECC is
            * returned because pubkey_algo_string is not aware
            * of the OpenPGP algo mapping.  We need to
            * distinguish between ECDH and ECDSA but we can do
            * that only if we got usage flags.
            * Note: Keep this in sync with ask_algo.  */
           if (algoid == GCRY_PK_ECC && algostr)
             {
               if (!strcmp (algostr, "ed25519"))
                 algo = PUBKEY_ALGO_EDDSA;
               else if (!strcmp (algostr, "ed448"))
                 {
                   algo = PUBKEY_ALGO_EDDSA;
                   is_448 = 1;
                 }
               else if (!strcmp (algostr, "cv25519"))
                 algo = PUBKEY_ALGO_ECDH;
               else if (!strcmp (algostr, "cv448"))
                 {
                   algo = PUBKEY_ALGO_ECDH;
                   is_448 = 1;
                 }
               else if ((kpi->usage & GCRY_PK_USAGE_ENCR))
                 algo = PUBKEY_ALGO_ECDH;
               else
                 algo = PUBKEY_ALGO_ECDSA;
             }
           else
             algo = map_gcry_pk_to_openpgp (algoid);
 
           xfree (algostr);
           xfree (keygrip);
           keygrip = xtrystrdup (kpi->keygrip);
           if (!keygrip)
             {
               err = gpg_error_from_syserror ();
               xfree (reqkeyref);
               free_keypair_info (keypairlist);
               return err;
             }
           keytime = kpi->keytime;
         }
 
       xfree (reqkeyref);
       free_keypair_info (keypairlist);
       if (!algo || !keygrip)
         {
           err = gpg_error (GPG_ERR_PUBKEY_ALGO);
           log_error ("no usable key on the card: %s\n", gpg_strerror (err));
           xfree (keygrip);
           return err;
         }
     }
   else if (ecdh_or_ecdsa && keyuse)
     algo = (keyuse & PUBKEY_USAGE_ENC)? PUBKEY_ALGO_ECDH : PUBKEY_ALGO_ECDSA;
   else if (ecdh_or_ecdsa)
     algo = for_subkey? PUBKEY_ALGO_ECDH : PUBKEY_ALGO_ECDSA;
 
   /* Set or fix key usage.  */
   if (!keyuse)
     {
       if (algo == PUBKEY_ALGO_ECDSA || algo == PUBKEY_ALGO_EDDSA
           || algo == PUBKEY_ALGO_DSA)
         keyuse = PUBKEY_USAGE_SIG;
       else if (algo == PUBKEY_ALGO_RSA)
         keyuse = for_subkey? PUBKEY_USAGE_ENC : PUBKEY_USAGE_SIG;
       else
         keyuse = PUBKEY_USAGE_ENC;
     }
   else if (algo == PUBKEY_ALGO_ECDSA || algo == PUBKEY_ALGO_EDDSA
            || algo == PUBKEY_ALGO_DSA)
     {
       keyuse &= ~PUBKEY_USAGE_ENC; /* Forbid encryption.  */
     }
   else if (algo == PUBKEY_ALGO_ECDH || algo == PUBKEY_ALGO_ELGAMAL_E)
     {
       keyuse = PUBKEY_USAGE_ENC;   /* Allow only encryption.  */
     }
 
   /* Make sure a primary key can certify.  */
   if (!for_subkey)
     keyuse |= PUBKEY_USAGE_CERT;
 
   /* But if requested remove th cert usage.  */
   if (clear_cert)
     keyuse &= ~PUBKEY_USAGE_CERT;
 
   /* Check that usage is actually possible.  */
   if (/**/((keyuse & (PUBKEY_USAGE_SIG|PUBKEY_USAGE_AUTH|PUBKEY_USAGE_CERT))
            && !pubkey_get_nsig (algo))
        || ((keyuse & PUBKEY_USAGE_ENC)
            && !pubkey_get_nenc (algo))
        || (for_subkey && (keyuse & PUBKEY_USAGE_CERT)))
     {
       xfree (keygrip);
       return gpg_error (GPG_ERR_WRONG_KEY_USAGE);
     }
 
   /* Ed448 and X448 must only be used as v5 keys.  */
   if (is_448)
     {
       if (keyversion == 4)
         log_info (_("WARNING: v4 is specified, but overridden by v5.\n"));
 
       keyversion = 5;
     }
   else if (keyversion == 0)
     keyversion = 4;
 
   /* Return values.  */
   if (r_algo)
     *r_algo = algo;
   if (r_size)
     {
       unsigned int min, def, max;
 
       /* Make sure the keysize is in the allowed range.  */
       def = get_keysize_range (algo, &min, &max);
       if (!size)
         size = def;
       else if (size < min)
         size = min;
       else if (size > max)
         size = max;
 
       *r_size = fixup_keysize (size, algo, 1);
     }
 
   if (r_keyuse)
     *r_keyuse = keyuse;
   if (r_curve)
     *r_curve = curve;
   if (r_keyversion)
     *r_keyversion = keyversion;
 
   if (r_keygrip)
     *r_keygrip = keygrip;
   else
     xfree (keygrip);
 
   if (r_keytime)
     *r_keytime = keytime;
 
   return 0;
 }
 
 
 /* Parse and return the standard key generation parameter.
  * The string is expected to be in this format:
  *
  *   ALGO[/FLAGS][+SUBALGO[/FLAGS]]
  *
  * Here ALGO is a string in the same format as printed by the
  * keylisting.  For example:
  *
  *   rsa3072 := RSA with 3072 bit.
  *   dsa2048 := DSA with 2048 bit.
  *   elg2048 := Elgamal with 2048 bit.
  *   ed25519 := EDDSA using curve Ed25519.
  *   ed448   := EDDSA using curve Ed448.
  *   cv25519 := ECDH using curve Curve25519.
  *   cv448   := ECDH using curve X448.
  *   nistp256:= ECDSA or ECDH using curve NIST P-256
  *
  * All strings with an unknown prefix are considered an elliptic
  * curve.  Curves which have no implicit algorithm require that FLAGS
  * is given to select whether ECDSA or ECDH is used; this can either
  * be done using an algorithm keyword or usage keywords.
  *
  * FLAGS is a comma delimited string of keywords:
  *
  *   cert := Allow usage Certify
  *   sign := Allow usage Sign
  *   encr := Allow usage Encrypt
  *   auth := Allow usage Authentication
  *   encrypt := Alias for "encr"
  *   ecdsa := Use algorithm ECDSA.
  *   eddsa := Use algorithm EdDSA.
  *   ecdh  := Use algorithm ECDH.
  *   v5    := Create version 5 key (requires option --rfc4880bis)
  *
  * There are several defaults and fallbacks depending on the
  * algorithm.  PART can be used to select which part of STRING is
  * used:
  *   -1 := Both parts
  *    0 := Only the part of the primary key
  *    1 := If there is one part parse that one, if there are
  *         two parts parse the part which best matches the
  *         SUGGESTED_USE or in case that can't be evaluated the second part.
  *         Always return using the args for the primary key (R_ALGO,....).
  *
  */
 gpg_error_t
 parse_key_parameter_string (ctrl_t ctrl,
                             const char *string, int part,
                             unsigned int suggested_use,
                             int *r_algo, unsigned int *r_size,
                             unsigned int *r_keyuse,
                             char const **r_curve,
                             int *r_version,
                             char **r_keygrip,
                             u32 *r_keytime,
                             int *r_subalgo, unsigned int *r_subsize,
                             unsigned int *r_subkeyuse,
                             char const **r_subcurve,
                             int *r_subversion,
                             char **r_subkeygrip,
                             u32 *r_subkeytime)
 {
   gpg_error_t err = 0;
   char *primary, *secondary;
 
   if (r_algo)
     *r_algo = 0;
   if (r_size)
     *r_size = 0;
   if (r_keyuse)
     *r_keyuse = 0;
   if (r_curve)
     *r_curve = NULL;
   if (r_version)
     *r_version = 4;
   if (r_keygrip)
     *r_keygrip = NULL;
   if (r_keytime)
     *r_keytime = 0;
   if (r_subalgo)
     *r_subalgo = 0;
   if (r_subsize)
     *r_subsize = 0;
   if (r_subkeyuse)
     *r_subkeyuse = 0;
   if (r_subcurve)
     *r_subcurve = NULL;
   if (r_subversion)
     *r_subversion = 4;
   if (r_subkeygrip)
     *r_subkeygrip = NULL;
   if (r_subkeytime)
     *r_subkeytime = 0;
 
   if (!string || !*string
       || !ascii_strcasecmp (string, "default") || !strcmp (string, "-"))
     string = get_default_pubkey_algo ();
   else if (!ascii_strcasecmp (string, "future-default")
            || !ascii_strcasecmp (string, "futuredefault"))
     string = FUTURE_STD_KEY_PARAM;
   else if (!ascii_strcasecmp (string, "card"))
     string = "card/cert,sign+card/encr";
 
   primary = xstrdup (string);
   secondary = strchr (primary, '+');
   if (secondary)
     *secondary++ = 0;
   if (part == -1 || part == 0)
     {
       err = parse_key_parameter_part (ctrl, primary,
                                       0, 0, r_algo, r_size,
                                       r_keyuse, r_curve, r_version,
                                       r_keygrip, r_keytime);
       if (!err && part == -1)
         err = parse_key_parameter_part (ctrl, secondary,
                                         1, 0, r_subalgo, r_subsize,
                                         r_subkeyuse, r_subcurve, r_subversion,
                                         r_subkeygrip, r_subkeytime);
     }
   else if (part == 1)
     {
       /* If we have SECONDARY, use that part.  If there is only one
        * part consider this to be the subkey algo.  In case a
        * SUGGESTED_USE has been given and the usage of the secondary
        * part does not match SUGGESTED_USE try again using the primary
        * part.  Note that when falling back to the primary key we need
        * to force clearing the cert usage. */
       if (secondary)
         {
           err = parse_key_parameter_part (ctrl, secondary,
                                           1, 0,
                                           r_algo, r_size, r_keyuse, r_curve,
                                           r_version, r_keygrip, r_keytime);
           if (!err && suggested_use && r_keyuse && !(suggested_use & *r_keyuse))
             err = parse_key_parameter_part (ctrl, primary,
                                             1, 1 /*(clear cert)*/,
                                             r_algo, r_size, r_keyuse, r_curve,
                                             r_version, r_keygrip, r_keytime);
         }
       else
         err = parse_key_parameter_part (ctrl, primary,
                                         1, 0,
                                         r_algo, r_size, r_keyuse, r_curve,
                                         r_version, r_keygrip, r_keytime);
     }
 
   xfree (primary);
 
   return err;
 }
 
 
 
 /* Append R to the linked list PARA.  */
 static void
 append_to_parameter (struct para_data_s *para, struct para_data_s *r)
 {
   log_assert (para);
   while (para->next)
     para = para->next;
   para->next = r;
 }
 
 /* Release the parameter list R.  */
 static void
 release_parameter_list (struct para_data_s *r)
 {
   struct para_data_s *r2;
 
   for (; r ; r = r2)
     {
       r2 = r->next;
       if (r->key == pPASSPHRASE && *r->u.value)
         wipememory (r->u.value, strlen (r->u.value));
       xfree (r);
     }
 }
 
 static struct para_data_s *
 get_parameter( struct para_data_s *para, enum para_name key )
 {
     struct para_data_s *r;
 
     for( r = para; r && r->key != key; r = r->next )
 	;
     return r;
 }
 
 static const char *
 get_parameter_value( struct para_data_s *para, enum para_name key )
 {
     struct para_data_s *r = get_parameter( para, key );
     return (r && *r->u.value)? r->u.value : NULL;
 }
 
 
 /* This is similar to get_parameter_value but also returns the empty
    string.  This is required so that quick_generate_keypair can use an
    empty Passphrase to specify no-protection.  */
 static const char *
 get_parameter_passphrase (struct para_data_s *para)
 {
   struct para_data_s *r = get_parameter (para, pPASSPHRASE);
   return r ? r->u.value : NULL;
 }
 
 
 static int
 get_parameter_algo (ctrl_t ctrl, struct para_data_s *para, enum para_name key,
                     int *r_default)
 {
   int i;
   struct para_data_s *r = get_parameter( para, key );
 
   if (r_default)
     *r_default = 0;
 
   if (!r)
     return -1;
 
   /* Note that we need to handle the ECC algorithms specified as
      strings directly because Libgcrypt folds them all to ECC.  */
   if (!ascii_strcasecmp (r->u.value, "default"))
     {
       /* Note: If you change this default algo, remember to change it
        * also in gpg.c:gpgconf_list.  */
       /* FIXME: We only allow the algo here and have a separate thing
        * for the curve etc.  That is a ugly but demanded for backward
        * compatibility with the batch key generation.  It would be
        * better to make full use of parse_key_parameter_string.  */
       parse_key_parameter_string (ctrl, NULL, 0, 0,
                                   &i, NULL, NULL, NULL, NULL, NULL, NULL,
                                   NULL, NULL, NULL, NULL, NULL, NULL, NULL);
       if (r_default)
         *r_default = 1;
     }
   else if (digitp (r->u.value))
     i = atoi( r->u.value );
   else if (!strcmp (r->u.value, "ELG-E")
            || !strcmp (r->u.value, "ELG"))
     i = PUBKEY_ALGO_ELGAMAL_E;
   else if (!ascii_strcasecmp (r->u.value, "EdDSA"))
     i = PUBKEY_ALGO_EDDSA;
   else if (!ascii_strcasecmp (r->u.value, "ECDSA"))
     i = PUBKEY_ALGO_ECDSA;
   else if (!ascii_strcasecmp (r->u.value, "ECDH"))
     i = PUBKEY_ALGO_ECDH;
   else
     i = map_gcry_pk_to_openpgp (gcry_pk_map_name (r->u.value));
 
   if (i == PUBKEY_ALGO_RSA_E || i == PUBKEY_ALGO_RSA_S)
     i = 0; /* we don't want to allow generation of these algorithms */
   return i;
 }
 
 
 /* Parse a usage string.  The usage keywords "auth", "sign", "encr"
  * may be delimited by space, tab, or comma.  On error -1 is returned
  * instead of the usage flags.  */
 static int
 parse_usagestr (const char *usagestr)
 {
   gpg_error_t err;
   char **tokens = NULL;
   const char *s;
   int i;
   unsigned int use = 0;
 
   tokens = strtokenize (usagestr, " \t,");
   if (!tokens)
     {
       err = gpg_error_from_syserror ();
       log_error ("strtokenize failed: %s\n", gpg_strerror (err));
       return -1;
     }
 
   for (i=0; (s = tokens[i]); i++)
     {
       if (!*s)
         ;
       else if (!ascii_strcasecmp (s, "sign"))
         use |= PUBKEY_USAGE_SIG;
       else if (!ascii_strcasecmp (s, "encrypt")
                 || !ascii_strcasecmp (s, "encr"))
         use |= PUBKEY_USAGE_ENC;
       else if (!ascii_strcasecmp (s, "auth"))
         use |= PUBKEY_USAGE_AUTH;
       else if (!ascii_strcasecmp (s, "cert"))
         use |= PUBKEY_USAGE_CERT;
       else
         {
           xfree (tokens);
           return -1; /* error */
         }
     }
 
   xfree (tokens);
   return use;
 }
 
 
 /*
  * Parse the usage parameter and set the keyflags.  Returns -1 on
  * error, 0 for no usage given or 1 for usage available.
  */
 static int
 parse_parameter_usage (const char *fname,
                        struct para_data_s *para, enum para_name key)
 {
   struct para_data_s *r = get_parameter( para, key );
   int i;
 
   if (!r)
     return 0; /* none (this is an optional parameter)*/
 
   i = parse_usagestr (r->u.value);
   if (i == -1)
     {
       log_error ("%s:%d: invalid usage list\n", fname, r->lnr );
       return -1; /* error */
     }
 
   r->u.usage = i;
   return 1;
 }
 
 
 static int
 parse_revocation_key (const char *fname,
 		      struct para_data_s *para, enum para_name key)
 {
   struct para_data_s *r = get_parameter( para, key );
   struct revocation_key revkey;
   char *pn;
   int i;
 
   if( !r )
     return 0; /* none (this is an optional parameter) */
 
   pn = r->u.value;
 
   revkey.class=0x80;
   revkey.algid=atoi(pn);
   if(!revkey.algid)
     goto fail;
 
   /* Skip to the fpr */
   while(*pn && *pn!=':')
     pn++;
 
   if(*pn!=':')
     goto fail;
 
   pn++;
 
   for(i=0;i<MAX_FINGERPRINT_LEN && *pn;i++,pn+=2)
     {
       int c=hextobyte(pn);
       if(c==-1)
 	goto fail;
 
       revkey.fpr[i]=c;
     }
   if (i != 20 && i != 32)
     goto fail;
 
   /* skip to the tag */
   while(*pn && *pn!='s' && *pn!='S')
     pn++;
 
   if(ascii_strcasecmp(pn,"sensitive")==0)
     revkey.class|=0x40;
 
   memcpy(&r->u.revkey,&revkey,sizeof(struct revocation_key));
 
   return 0;
 
  fail:
   log_error("%s:%d: invalid revocation key\n", fname, r->lnr );
   return -1; /* error */
 }
 
 
 static u32
 get_parameter_u32( struct para_data_s *para, enum para_name key )
 {
   struct para_data_s *r = get_parameter( para, key );
 
   if( !r )
     return 0;
   if (r->key == pKEYCREATIONDATE || r->key == pSUBKEYCREATIONDATE
       || r->key == pAUTHKEYCREATIONDATE)
     return r->u.creation;
   if( r->key == pKEYEXPIRE || r->key == pSUBKEYEXPIRE )
     return r->u.expire;
   if( r->key == pKEYUSAGE || r->key == pSUBKEYUSAGE )
     return r->u.usage;
 
   return (unsigned int)strtoul( r->u.value, NULL, 10 );
 }
 
 static unsigned int
 get_parameter_uint( struct para_data_s *para, enum para_name key )
 {
     return get_parameter_u32( para, key );
 }
 
 static struct revocation_key *
 get_parameter_revkey( struct para_data_s *para, enum para_name key )
 {
     struct para_data_s *r = get_parameter( para, key );
     return r? &r->u.revkey : NULL;
 }
 
 static int
 get_parameter_bool (struct para_data_s *para, enum para_name key)
 {
   struct para_data_s *r = get_parameter (para, key);
   return (r && r->u.abool);
 }
 
 
 static int
 proc_parameter_file (ctrl_t ctrl, struct para_data_s *para, const char *fname,
                      struct output_control_s *outctrl, int card )
 {
   struct para_data_s *r;
   const char *s1, *s2, *s3;
   size_t n;
   char *p;
   int is_default = 0;
   int have_user_id = 0;
   int err, algo;
 
   /* Check that we have all required parameters. */
   r = get_parameter( para, pKEYTYPE );
   if(r)
     {
       algo = get_parameter_algo (ctrl, para, pKEYTYPE, &is_default);
       if (openpgp_pk_test_algo2 (algo, PUBKEY_USAGE_SIG))
 	{
 	  log_error ("%s:%d: invalid algorithm\n", fname, r->lnr );
 	  return -1;
 	}
     }
   else
     {
       log_error ("%s: no Key-Type specified\n",fname);
       return -1;
     }
 
   err = parse_parameter_usage (fname, para, pKEYUSAGE);
   if (!err)
     {
       /* Default to algo capabilities if key-usage is not provided and
          no default algorithm has been requested.  */
       r = xmalloc_clear(sizeof(*r));
       r->key = pKEYUSAGE;
       r->u.usage = (is_default
                     ? (PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG)
                     : openpgp_pk_algo_usage(algo));
       append_to_parameter (para, r);
     }
   else if (err == -1)
     return -1;
   else
     {
       r = get_parameter (para, pKEYUSAGE);
       if (r && (r->u.usage & ~openpgp_pk_algo_usage (algo)))
         {
           log_error ("%s:%d: specified Key-Usage not allowed for algo %d\n",
                      fname, r->lnr, algo);
           return -1;
         }
     }
 
   is_default = 0;
   r = get_parameter( para, pSUBKEYTYPE );
   if(r)
     {
       algo = get_parameter_algo (ctrl, para, pSUBKEYTYPE, &is_default);
       if (openpgp_pk_test_algo (algo))
 	{
 	  log_error ("%s:%d: invalid algorithm\n", fname, r->lnr );
 	  return -1;
 	}
 
       err = parse_parameter_usage (fname, para, pSUBKEYUSAGE);
       if (!err)
 	{
 	  /* Default to algo capabilities if subkey-usage is not
 	     provided */
 	  r = xmalloc_clear (sizeof(*r));
 	  r->key = pSUBKEYUSAGE;
 	  r->u.usage = (is_default
                         ? PUBKEY_USAGE_ENC
                         : openpgp_pk_algo_usage (algo));
           append_to_parameter (para, r);
 	}
       else if (err == -1)
 	return -1;
       else
         {
           r = get_parameter (para, pSUBKEYUSAGE);
           if (r && (r->u.usage & ~openpgp_pk_algo_usage (algo)))
             {
               log_error ("%s:%d: specified Subkey-Usage not allowed"
                          " for algo %d\n", fname, r->lnr, algo);
               return -1;
             }
         }
     }
 
 
   if( get_parameter_value( para, pUSERID ) )
     have_user_id=1;
   else
     {
       /* create the formatted user ID */
       s1 = get_parameter_value( para, pNAMEREAL );
       s2 = get_parameter_value( para, pNAMECOMMENT );
       s3 = get_parameter_value( para, pNAMEEMAIL );
       if( s1 || s2 || s3 )
 	{
 	  n = (s1?strlen(s1):0) + (s2?strlen(s2):0) + (s3?strlen(s3):0);
 	  r = xmalloc_clear( sizeof *r + n + 20 );
 	  r->key = pUSERID;
 	  p = r->u.value;
 	  if( s1 )
 	    p = stpcpy(p, s1 );
 	  if( s2 )
 	    p = stpcpy(stpcpy(stpcpy(p," ("), s2 ),")");
 	  if( s3 )
             {
               /* If we have only the email part, do not add the space
                * and the angle brackets.  */
               if (*r->u.value)
                 p = stpcpy(stpcpy(stpcpy(p," <"), s3 ),">");
               else
                 p = stpcpy (p, s3);
             }
           append_to_parameter (para, r);
 	  have_user_id=1;
 	}
     }
 
   if(!have_user_id)
     {
       log_error("%s: no User-ID specified\n",fname);
       return -1;
     }
 
   /* Set preferences, if any. */
   keygen_set_std_prefs(get_parameter_value( para, pPREFERENCES ), 0);
 
   /* Set keyserver, if any. */
   s1=get_parameter_value( para, pKEYSERVER );
   if(s1)
     {
       struct keyserver_spec *spec;
 
       spec = parse_keyserver_uri (s1, 1);
       if(spec)
 	{
 	  free_keyserver_spec(spec);
 	  opt.def_keyserver_url=s1;
 	}
       else
 	{
           r = get_parameter (para, pKEYSERVER);
 	  log_error("%s:%d: invalid keyserver url\n", fname, r->lnr );
 	  return -1;
 	}
     }
 
   /* Set revoker, if any. */
   if (parse_revocation_key (fname, para, pREVOKER))
     return -1;
 
 
   /* Make KEYCREATIONDATE from Creation-Date.  We ignore this if the
    * key has been taken from a card and a keycreationtime has already
    * been set.  This is so that we don't generate a key with a
    * fingerprint different from the one stored on the OpenPGP card. */
   r = get_parameter (para, pCREATIONDATE);
   if (r && *r->u.value && !(get_parameter_bool (para, pCARDKEY)
                             && get_parameter_u32 (para, pKEYCREATIONDATE)))
     {
       u32 seconds;
 
       seconds = parse_creation_string (r->u.value);
       if (!seconds)
 	{
 	  log_error ("%s:%d: invalid creation date\n", fname, r->lnr );
 	  return -1;
 	}
       r->u.creation = seconds;
       r->key = pKEYCREATIONDATE;  /* Change that entry. */
     }
 
   /* Make KEYEXPIRE from Expire-Date.  */
   r = get_parameter( para, pEXPIREDATE );
   if( r && *r->u.value )
     {
       u32 seconds;
 
       seconds = parse_expire_string( r->u.value );
       if( seconds == (u32)-1 )
 	{
 	  log_error("%s:%d: invalid expire date\n", fname, r->lnr );
 	  return -1;
 	}
       r->u.expire = seconds;
       r->key = pKEYEXPIRE;  /* change hat entry */
       /* also set it for the subkey */
       r = xmalloc_clear( sizeof *r + 20 );
       r->key = pSUBKEYEXPIRE;
       r->u.expire = seconds;
       append_to_parameter (para, r);
     }
 
   do_generate_keypair (ctrl, para, outctrl, card );
   return 0;
 }
 
 
 /****************
  * Kludge to allow non interactive key generation controlled
  * by a parameter file.
  * Note, that string parameters are expected to be in UTF-8
  */
 static void
 read_parameter_file (ctrl_t ctrl, const char *fname )
 {
     static struct { const char *name;
 		    enum para_name key;
     } keywords[] = {
 	{ "Key-Type",       pKEYTYPE},
 	{ "Key-Length",     pKEYLENGTH },
 	{ "Key-Curve",      pKEYCURVE },
 	{ "Key-Usage",      pKEYUSAGE },
 	{ "Subkey-Type",    pSUBKEYTYPE },
 	{ "Subkey-Length",  pSUBKEYLENGTH },
 	{ "Subkey-Curve",   pSUBKEYCURVE },
 	{ "Subkey-Usage",   pSUBKEYUSAGE },
 	{ "Name-Real",      pNAMEREAL },
 	{ "Name-Email",     pNAMEEMAIL },
 	{ "Name-Comment",   pNAMECOMMENT },
 	{ "Expire-Date",    pEXPIREDATE },
 	{ "Creation-Date",  pCREATIONDATE },
 	{ "Passphrase",     pPASSPHRASE },
 	{ "Preferences",    pPREFERENCES },
 	{ "Revoker",        pREVOKER },
         { "Handle",         pHANDLE },
         { "Keyserver",      pKEYSERVER },
         { "Keygrip",        pKEYGRIP },
         { "Key-Grip",       pKEYGRIP },
         { "Subkey-grip",    pSUBKEYGRIP },
         { "Key-Version",    pVERSION },
         { "Subkey-Version", pSUBVERSION },
         { NULL, 0 }
     };
     IOBUF fp;
     byte *line;
     unsigned int maxlen, nline;
     char *p;
     int lnr;
     const char *err = NULL;
     struct para_data_s *para, *r;
     int i;
     struct output_control_s outctrl;
 
     memset( &outctrl, 0, sizeof( outctrl ) );
     outctrl.pub.afx = new_armor_context ();
 
     if( !fname || !*fname)
       fname = "-";
 
     fp = iobuf_open (fname);
     if (fp && is_secured_file (iobuf_get_fd (fp)))
       {
         iobuf_close (fp);
         fp = NULL;
         gpg_err_set_errno (EPERM);
       }
     if (!fp) {
       log_error (_("can't open '%s': %s\n"), fname, strerror(errno) );
       return;
     }
     iobuf_ioctl (fp, IOBUF_IOCTL_NO_CACHE, 1, NULL);
 
     lnr = 0;
     err = NULL;
     para = NULL;
     maxlen = 1024;
     line = NULL;
     nline = 0;
     while ( iobuf_read_line (fp, &line, &nline, &maxlen) ) {
 	char *keyword, *value;
 
 	lnr++;
 	if( !maxlen ) {
 	    err = "line too long";
 	    break;
 	}
 	for( p = line; isspace(*(byte*)p); p++ )
 	    ;
 	if( !*p || *p == '#' )
 	    continue;
 	keyword = p;
 	if( *keyword == '%' ) {
 	    for( ; !isspace(*(byte*)p); p++ )
 		;
 	    if( *p )
 		*p++ = 0;
 	    for( ; isspace(*(byte*)p); p++ )
 		;
 	    value = p;
 	    trim_trailing_ws( value, strlen(value) );
 	    if( !ascii_strcasecmp( keyword, "%echo" ) )
 		log_info("%s\n", value );
 	    else if( !ascii_strcasecmp( keyword, "%dry-run" ) )
 		outctrl.dryrun = 1;
 	    else if( !ascii_strcasecmp( keyword, "%ask-passphrase" ) )
               ; /* Dummy for backward compatibility. */
 	    else if( !ascii_strcasecmp( keyword, "%no-ask-passphrase" ) )
 	      ; /* Dummy for backward compatibility. */
 	    else if( !ascii_strcasecmp( keyword, "%no-protection" ) )
                 outctrl.keygen_flags |= KEYGEN_FLAG_NO_PROTECTION;
 	    else if( !ascii_strcasecmp( keyword, "%transient-key" ) )
                 outctrl.keygen_flags |= KEYGEN_FLAG_TRANSIENT_KEY;
 	    else if( !ascii_strcasecmp( keyword, "%commit" ) ) {
 		outctrl.lnr = lnr;
 		if (proc_parameter_file (ctrl, para, fname, &outctrl, 0 ))
                   print_status_key_not_created
                     (get_parameter_value (para, pHANDLE));
 		release_parameter_list( para );
 		para = NULL;
 	    }
 	    else if( !ascii_strcasecmp( keyword, "%pubring" ) ) {
 		if( outctrl.pub.fname && !strcmp( outctrl.pub.fname, value ) )
 		    ; /* still the same file - ignore it */
 		else {
 		    xfree( outctrl.pub.newfname );
 		    outctrl.pub.newfname = xstrdup( value );
 		    outctrl.use_files = 1;
 		}
 	    }
 	    else if( !ascii_strcasecmp( keyword, "%secring" ) ) {
               /* Ignore this command.  */
 	    }
 	    else
 		log_info("skipping control '%s' (%s)\n", keyword, value );
 
 
 	    continue;
 	}
 
 
 	if( !(p = strchr( p, ':' )) || p == keyword ) {
 	    err = "missing colon";
 	    break;
 	}
 	if( *p )
 	    *p++ = 0;
 	for( ; isspace(*(byte*)p); p++ )
 	    ;
 	if( !*p ) {
 	    err = "missing argument";
 	    break;
 	}
 	value = p;
 	trim_trailing_ws( value, strlen(value) );
 
 	for(i=0; keywords[i].name; i++ ) {
 	    if( !ascii_strcasecmp( keywords[i].name, keyword ) )
 		break;
 	}
 	if( !keywords[i].name ) {
 	    err = "unknown keyword";
 	    break;
 	}
 	if( keywords[i].key != pKEYTYPE && !para ) {
 	    err = "parameter block does not start with \"Key-Type\"";
 	    break;
 	}
 
 	if( keywords[i].key == pKEYTYPE && para ) {
 	    outctrl.lnr = lnr;
 	    if (proc_parameter_file (ctrl, para, fname, &outctrl, 0 ))
               print_status_key_not_created
                 (get_parameter_value (para, pHANDLE));
 	    release_parameter_list( para );
 	    para = NULL;
 	}
 	else {
 	    for( r = para; r; r = r->next ) {
 		if( r->key == keywords[i].key )
 		    break;
 	    }
 	    if( r ) {
 		err = "duplicate keyword";
 		break;
 	    }
 	}
 
         if (!opt.flags.rfc4880bis && (keywords[i].key == pVERSION
                                       || keywords[i].key == pSUBVERSION))
           ; /* Ignore version unless --rfc4880bis is active.  */
         else
           {
             r = xmalloc_clear( sizeof *r + strlen( value ) );
             r->lnr = lnr;
             r->key = keywords[i].key;
             strcpy( r->u.value, value );
             r->next = para;
             para = r;
           }
     }
     if( err )
 	log_error("%s:%d: %s\n", fname, lnr, err );
     else if( iobuf_error (fp) ) {
 	log_error("%s:%d: read error\n", fname, lnr);
     }
     else if( para ) {
 	outctrl.lnr = lnr;
 	if (proc_parameter_file (ctrl, para, fname, &outctrl, 0 ))
           print_status_key_not_created (get_parameter_value (para, pHANDLE));
     }
 
     if( outctrl.use_files ) { /* close open streams */
 	iobuf_close( outctrl.pub.stream );
 
         /* Must invalidate that ugly cache to actually close it.  */
         if (outctrl.pub.fname)
           iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE,
                        0, (char*)outctrl.pub.fname);
 
 	xfree( outctrl.pub.fname );
 	xfree( outctrl.pub.newfname );
     }
 
     xfree (line);
     release_parameter_list( para );
     iobuf_close (fp);
     release_armor_context (outctrl.pub.afx);
 }
 
 
 /* Helper for quick_generate_keypair.  */
 static struct para_data_s *
 quickgen_set_para (struct para_data_s *para, int for_subkey,
                    int algo, int nbits, const char *curve, unsigned int use,
                    int version, const char *keygrip, u32 keytime)
 {
   struct para_data_s *r;
 
   r = xmalloc_clear (sizeof *r + 30);
   r->key = for_subkey? pSUBKEYUSAGE :  pKEYUSAGE;
   if (use)
     snprintf (r->u.value, 30, "%s%s%s%s",
               (use & PUBKEY_USAGE_ENC)?  "encr " : "",
               (use & PUBKEY_USAGE_SIG)?  "sign " : "",
               (use & PUBKEY_USAGE_AUTH)? "auth " : "",
               (use & PUBKEY_USAGE_CERT)? "cert " : "");
   else
     strcpy (r->u.value, for_subkey ? "encr" : "sign");
   r->next = para;
   para = r;
   r = xmalloc_clear (sizeof *r + 20);
   r->key = for_subkey? pSUBKEYTYPE : pKEYTYPE;
   snprintf (r->u.value, 20, "%d", algo);
   r->next = para;
   para = r;
 
   if (keygrip)
     {
       r = xmalloc_clear (sizeof *r + strlen (keygrip));
       r->key = for_subkey? pSUBKEYGRIP : pKEYGRIP;
       strcpy (r->u.value, keygrip);
       r->next = para;
       para = r;
     }
   else if (curve)
     {
       r = xmalloc_clear (sizeof *r + strlen (curve));
       r->key = for_subkey? pSUBKEYCURVE : pKEYCURVE;
       strcpy (r->u.value, curve);
       r->next = para;
       para = r;
     }
   else
     {
       r = xmalloc_clear (sizeof *r + 20);
       r->key = for_subkey? pSUBKEYLENGTH : pKEYLENGTH;
       sprintf (r->u.value, "%u", nbits);
       r->next = para;
       para = r;
     }
 
   if (opt.flags.rfc4880bis)
     {
       r = xmalloc_clear (sizeof *r + 20);
       r->key = for_subkey? pSUBVERSION : pVERSION;
       snprintf (r->u.value, 20, "%d", version);
       r->next = para;
       para = r;
     }
 
   if (keytime)
     {
       r = xmalloc_clear (sizeof *r);
       r->key = for_subkey? pSUBKEYCREATIONDATE : pKEYCREATIONDATE;
       r->u.creation = keytime;
       r->next = para;
       para = r;
 
     }
 
   return para;
 }
 
 
 /*
  * Unattended generation of a standard key.
  */
 void
 quick_generate_keypair (ctrl_t ctrl, const char *uid, const char *algostr,
                         const char *usagestr, const char *expirestr)
 {
   gpg_error_t err;
   struct para_data_s *para = NULL;
   struct para_data_s *r;
   struct output_control_s outctrl;
   int use_tty;
 
   memset (&outctrl, 0, sizeof outctrl);
 
   use_tty = (!opt.batch && !opt.answer_yes
              && !*algostr && !*usagestr && !*expirestr
              && !cpr_enabled ()
              && gnupg_isatty (fileno (stdin))
              && gnupg_isatty (fileno (stdout))
              && gnupg_isatty (fileno (stderr)));
 
   r = xmalloc_clear (sizeof *r + strlen (uid));
   r->key = pUSERID;
   strcpy (r->u.value, uid);
   r->next = para;
   para = r;
 
   uid = trim_spaces (r->u.value);
   if (!*uid || (!opt.allow_freeform_uid && !is_valid_user_id (uid)))
     {
       log_error (_("Key generation failed: %s\n"),
                  gpg_strerror (GPG_ERR_INV_USER_ID));
       goto leave;
     }
 
   /* If gpg is directly used on the console ask whether a key with the
      given user id shall really be created.  */
   if (use_tty)
     {
       tty_printf (_("About to create a key for:\n    \"%s\"\n\n"), uid);
       if (!cpr_get_answer_is_yes_def ("quick_keygen.okay",
                                       _("Continue? (Y/n) "), 1))
         goto leave;
     }
 
   /* Check whether such a user ID already exists.  */
   {
     KEYDB_HANDLE kdbhd;
     KEYDB_SEARCH_DESC desc;
 
     memset (&desc, 0, sizeof desc);
     desc.mode = KEYDB_SEARCH_MODE_EXACT;
     desc.u.name = uid;
 
     kdbhd = keydb_new (ctrl);
     if (!kdbhd)
       goto leave;
 
     err = keydb_search (kdbhd, &desc, 1, NULL);
     keydb_release (kdbhd);
     if (gpg_err_code (err) != GPG_ERR_NOT_FOUND)
       {
         log_info (_("A key for \"%s\" already exists\n"), uid);
         if (opt.answer_yes)
           ;
         else if (!use_tty
                  || !cpr_get_answer_is_yes_def ("quick_keygen.force",
                                                 _("Create anyway? (y/N) "), 0))
           {
             write_status_error ("genkey", gpg_error (304));
             log_inc_errorcount ();  /* we used log_info */
             goto leave;
           }
         log_info (_("creating anyway\n"));
       }
   }
 
   if (!*expirestr || strcmp (expirestr, "-") == 0)
     expirestr = default_expiration_interval;
 
   if ((!*algostr || !ascii_strcasecmp (algostr, "default")
        || !ascii_strcasecmp (algostr, "future-default")
        || !ascii_strcasecmp (algostr, "futuredefault")
        || !ascii_strcasecmp (algostr, "card"))
       && (!*usagestr || !ascii_strcasecmp (usagestr, "default")
           || !strcmp (usagestr, "-")))
     {
       /* Use default key parameters.  */
       int algo, subalgo, version, subversion;
       unsigned int size, subsize;
       unsigned int keyuse, subkeyuse;
       const char *curve, *subcurve;
       char *keygrip, *subkeygrip;
       u32 keytime, subkeytime;
 
       err = parse_key_parameter_string (ctrl, algostr, -1, 0,
                                         &algo, &size, &keyuse, &curve, &version,
                                         &keygrip, &keytime,
                                         &subalgo, &subsize, &subkeyuse,
                                         &subcurve, &subversion,
                                         &subkeygrip, &subkeytime);
       if (err)
         {
           log_error (_("Key generation failed: %s\n"), gpg_strerror (err));
           goto leave;
         }
 
       para = quickgen_set_para (para, 0, algo, size, curve, keyuse, version,
                                 keygrip, keytime);
       if (subalgo)
         para = quickgen_set_para (para, 1,
                                   subalgo, subsize, subcurve, subkeyuse,
                                   subversion, subkeygrip, subkeytime);
       if (*expirestr)
         {
           u32 expire;
 
           expire = parse_expire_string (expirestr);
           if (expire == (u32)-1 )
             {
               err = gpg_error (GPG_ERR_INV_VALUE);
               log_error (_("Key generation failed: %s\n"), gpg_strerror (err));
               goto leave;
             }
           r = xmalloc_clear (sizeof *r + 20);
           r->key = pKEYEXPIRE;
           r->u.expire = expire;
           r->next = para;
           para = r;
         }
 
       xfree (keygrip);
       xfree (subkeygrip);
     }
   else
     {
       /* Extended unattended mode.  Creates only the primary key. */
       int algo, version;
       unsigned int use;
       u32 expire;
       unsigned int nbits;
       const char *curve;
       char *keygrip;
       u32 keytime;
 
       err = parse_algo_usage_expire (ctrl, 0, algostr, usagestr, expirestr,
                                      &algo, &use, &expire, &nbits, &curve,
                                      &version, &keygrip, &keytime);
       if (err)
         {
           log_error (_("Key generation failed: %s\n"), gpg_strerror (err) );
           goto leave;
         }
 
       para = quickgen_set_para (para, 0, algo, nbits, curve, use, version,
                                 keygrip, keytime);
       r = xmalloc_clear (sizeof *r + 20);
       r->key = pKEYEXPIRE;
       r->u.expire = expire;
       r->next = para;
       para = r;
 
       xfree (keygrip);
     }
 
   /* If the pinentry loopback mode is not and we have a static
      passphrase (i.e. set with --passphrase{,-fd,-file} while in batch
      mode), we use that passphrase for the new key.  */
   if (opt.pinentry_mode != PINENTRY_MODE_LOOPBACK
       && have_static_passphrase ())
     {
       const char *s = get_static_passphrase ();
 
       r = xmalloc_clear (sizeof *r + strlen (s));
       r->key = pPASSPHRASE;
       strcpy (r->u.value, s);
       r->next = para;
       para = r;
     }
 
   if (!ascii_strcasecmp (algostr, "card")
       || !ascii_strncasecmp (algostr, "card/", 5))
     {
       r = xmalloc_clear (sizeof *r);
       r->key = pCARDKEY;
       r->u.abool = 1;
       r->next = para;
       para = r;
     }
 
   proc_parameter_file (ctrl, para, "[internal]", &outctrl, 0);
 
  leave:
   release_parameter_list (para);
 }
 
 
 /*
  * Generate a keypair (fname is only used in batch mode) If
  * CARD_SERIALNO is not NULL the function will create the keys on an
  * OpenPGP Card.  If CARD_BACKUP_KEY has been set and CARD_SERIALNO is
  * NOT NULL, the encryption key for the card is generated on the host,
  * imported to the card and a backup file created by gpg-agent.  If
  * FULL is not set only the basic prompts are used (except for batch
  * mode).
  */
 void
 generate_keypair (ctrl_t ctrl, int full, const char *fname,
                   const char *card_serialno, int card_backup_key)
 {
   gpg_error_t err;
   unsigned int nbits;
   char *uid = NULL;
   int algo;
   unsigned int use;
   int both = 0;
   u32 expire;
   struct para_data_s *para = NULL;
   struct para_data_s *r;
   struct output_control_s outctrl;
 
 #ifndef ENABLE_CARD_SUPPORT
   (void)card_backup_key;
 #endif
 
   memset( &outctrl, 0, sizeof( outctrl ) );
 
   if (opt.batch && card_serialno)
     {
       /* We don't yet support unattended key generation with a card
        * serial number. */
       log_error (_("can't do this in batch mode\n"));
       print_further_info ("key generation with card serial number");
       return;
     }
 
   if (opt.batch)
     {
       read_parameter_file (ctrl, fname);
       return;
     }
 
   if (card_serialno)
     {
 #ifdef ENABLE_CARD_SUPPORT
       struct agent_card_info_s info;
 
       memset (&info, 0, sizeof (info));
       err = agent_scd_getattr ("KEY-ATTR", &info);
       if (err)
         {
           log_error (_("error getting current key info: %s\n"),
                      gpg_strerror (err));
           return;
         }
 
       r = xcalloc (1, sizeof *r + strlen (card_serialno) );
       r->key = pSERIALNO;
       strcpy( r->u.value, card_serialno);
       r->next = para;
       para = r;
 
       r = xcalloc (1, sizeof *r + 20 );
       r->key = pKEYTYPE;
       sprintf( r->u.value, "%d", info.key_attr[0].algo );
       r->next = para;
       para = r;
       r = xcalloc (1, sizeof *r + 20 );
       r->key = pKEYUSAGE;
       strcpy (r->u.value, "sign");
       r->next = para;
       para = r;
 
       r = xcalloc (1, sizeof *r + 20 );
       r->key = pSUBKEYTYPE;
       sprintf( r->u.value, "%d", info.key_attr[1].algo );
       r->next = para;
       para = r;
       r = xcalloc (1, sizeof *r + 20 );
       r->key = pSUBKEYUSAGE;
       strcpy (r->u.value, "encrypt");
       r->next = para;
       para = r;
       if (info.key_attr[1].algo == PUBKEY_ALGO_RSA)
         {
           r = xcalloc (1, sizeof *r + 20 );
           r->key = pSUBKEYLENGTH;
           sprintf( r->u.value, "%u", info.key_attr[1].nbits);
           r->next = para;
           para = r;
         }
       else if (info.key_attr[1].algo == PUBKEY_ALGO_ECDSA
                || info.key_attr[1].algo == PUBKEY_ALGO_EDDSA
                || info.key_attr[1].algo == PUBKEY_ALGO_ECDH)
         {
           r = xcalloc (1, sizeof *r + strlen (info.key_attr[1].curve));
           r->key = pSUBKEYCURVE;
           strcpy (r->u.value, info.key_attr[1].curve);
           r->next = para;
           para = r;
         }
 
       r = xcalloc (1, sizeof *r + 20 );
       r->key = pAUTHKEYTYPE;
       sprintf( r->u.value, "%d", info.key_attr[2].algo );
       r->next = para;
       para = r;
 
       if (card_backup_key)
         {
           r = xcalloc (1, sizeof *r + 1);
           r->key = pCARDBACKUPKEY;
           strcpy (r->u.value, "1");
           r->next = para;
           para = r;
         }
 #endif /*ENABLE_CARD_SUPPORT*/
     }
   else if (full)  /* Full featured key generation.  */
     {
       int subkey_algo;
       char *key_from_hexgrip = NULL;
       int cardkey;
       u32 keytime;
 
       algo = ask_algo (ctrl, 0, &subkey_algo, &use,
                        &key_from_hexgrip, &cardkey, &keytime);
       if (key_from_hexgrip)
         {
           r = xmalloc_clear( sizeof *r + 20 );
           r->key = pKEYTYPE;
           sprintf( r->u.value, "%d", algo);
           r->next = para;
           para = r;
 
           if (use)
             {
               r = xmalloc_clear( sizeof *r + 25 );
               r->key = pKEYUSAGE;
               sprintf( r->u.value, "%s%s%s",
                        (use & PUBKEY_USAGE_SIG)? "sign ":"",
                        (use & PUBKEY_USAGE_ENC)? "encrypt ":"",
                        (use & PUBKEY_USAGE_AUTH)? "auth":"" );
               r->next = para;
               para = r;
             }
 
           r = xmalloc_clear( sizeof *r + 40 );
           r->key = pKEYGRIP;
           strcpy (r->u.value, key_from_hexgrip);
           r->next = para;
           para = r;
 
           r = xmalloc_clear (sizeof *r);
           r->key = pCARDKEY;
           r->u.abool = cardkey;
           r->next = para;
           para = r;
 
           if (cardkey)
             {
               r = xmalloc_clear (sizeof *r);
               r->key = pKEYCREATIONDATE;
               r->u.creation = keytime;
               r->next = para;
               para = r;
             }
 
           xfree (key_from_hexgrip);
         }
       else
         {
           const char *curve = NULL;
 
           if (subkey_algo)
             {
               /* Create primary and subkey at once.  */
               both = 1;
               if (algo == PUBKEY_ALGO_ECDSA
                   || algo == PUBKEY_ALGO_EDDSA
                   || algo == PUBKEY_ALGO_ECDH)
                 {
                   curve = ask_curve (&algo, &subkey_algo, NULL);
                   r = xmalloc_clear( sizeof *r + 20 );
                   r->key = pKEYTYPE;
                   sprintf( r->u.value, "%d", algo);
                   r->next = para;
                   para = r;
                   nbits = 0;
                   r = xmalloc_clear (sizeof *r + strlen (curve));
                   r->key = pKEYCURVE;
                   strcpy (r->u.value, curve);
                   r->next = para;
                   para = r;
                 }
               else
                 {
                   r = xmalloc_clear( sizeof *r + 20 );
                   r->key = pKEYTYPE;
                   sprintf( r->u.value, "%d", algo);
                   r->next = para;
                   para = r;
                   nbits = ask_keysize (algo, 0);
                   r = xmalloc_clear( sizeof *r + 20 );
                   r->key = pKEYLENGTH;
                   sprintf( r->u.value, "%u", nbits);
                   r->next = para;
                   para = r;
                 }
               r = xmalloc_clear( sizeof *r + 20 );
               r->key = pKEYUSAGE;
               strcpy( r->u.value, "sign" );
               r->next = para;
               para = r;
 
               r = xmalloc_clear( sizeof *r + 20 );
               r->key = pSUBKEYTYPE;
               sprintf( r->u.value, "%d", subkey_algo);
               r->next = para;
               para = r;
               r = xmalloc_clear( sizeof *r + 20 );
               r->key = pSUBKEYUSAGE;
               strcpy( r->u.value, "encrypt" );
               r->next = para;
               para = r;
 
               if (algo == PUBKEY_ALGO_ECDSA
                   || algo == PUBKEY_ALGO_EDDSA
                   || algo == PUBKEY_ALGO_ECDH)
                 {
                   if (algo == PUBKEY_ALGO_EDDSA
                       && subkey_algo == PUBKEY_ALGO_ECDH)
                     {
                       /* Need to switch to a different curve for the
                          encryption key.  */
                       if (!strcmp (curve, "Ed25519"))
                         curve = "Curve25519";
                       else
                         curve = "X448";
                     }
                   r = xmalloc_clear (sizeof *r + strlen (curve));
                   r->key = pSUBKEYCURVE;
                   strcpy (r->u.value, curve);
                   r->next = para;
                   para = r;
                 }
             }
           else /* Create only a single key.  */
             {
               /* For ECC we need to ask for the curve before storing the
                  algo because ask_curve may change the algo.  */
               if (algo == PUBKEY_ALGO_ECDSA
                   || algo == PUBKEY_ALGO_EDDSA
                   || algo == PUBKEY_ALGO_ECDH)
                 {
                   curve = ask_curve (&algo, NULL, NULL);
                   r = xmalloc_clear (sizeof *r + strlen (curve));
                   r->key = pKEYCURVE;
                   strcpy (r->u.value, curve);
                   r->next = para;
                   para = r;
                 }
 
               r = xmalloc_clear( sizeof *r + 20 );
               r->key = pKEYTYPE;
               sprintf( r->u.value, "%d", algo );
               r->next = para;
               para = r;
 
               if (use)
                 {
                   r = xmalloc_clear( sizeof *r + 25 );
                   r->key = pKEYUSAGE;
                   sprintf( r->u.value, "%s%s%s",
                            (use & PUBKEY_USAGE_SIG)? "sign ":"",
                            (use & PUBKEY_USAGE_ENC)? "encrypt ":"",
                            (use & PUBKEY_USAGE_AUTH)? "auth":"" );
                   r->next = para;
                   para = r;
                 }
               nbits = 0;
             }
 
           if (algo == PUBKEY_ALGO_ECDSA
               || algo == PUBKEY_ALGO_EDDSA
               || algo == PUBKEY_ALGO_ECDH)
             {
               /* The curve has already been set.  */
             }
           else
             {
               nbits = ask_keysize (both? subkey_algo : algo, nbits);
               r = xmalloc_clear( sizeof *r + 20 );
               r->key = both? pSUBKEYLENGTH : pKEYLENGTH;
               sprintf( r->u.value, "%u", nbits);
               r->next = para;
               para = r;
             }
         }
     }
   else /* Default key generation.  */
     {
       int subalgo, version, subversion;
       unsigned int size, subsize;
       unsigned int keyuse, subkeyuse;
       const char *curve, *subcurve;
       char *keygrip, *subkeygrip;
       u32 keytime, subkeytime;
 
       tty_printf ( _("Note: Use \"%s %s\""
                      " for a full featured key generation dialog.\n"),
 #if USE_GPG2_HACK
                    GPG_NAME "2"
 #else
                    GPG_NAME
 #endif
                    , "--full-generate-key" );
 
       err = parse_key_parameter_string (ctrl, NULL, -1, 0,
                                         &algo, &size, &keyuse, &curve, &version,
                                         &keygrip, &keytime,
                                         &subalgo, &subsize,
                                         &subkeyuse, &subcurve, &subversion,
                                         &subkeygrip, &subkeytime);
       if (err)
         {
           log_error (_("Key generation failed: %s\n"), gpg_strerror (err));
           return;
         }
       para = quickgen_set_para (para, 0,
                                 algo, size, curve, keyuse,
                                 version, keygrip, keytime);
       if (subalgo)
         para = quickgen_set_para (para, 1,
                                   subalgo, subsize, subcurve, subkeyuse,
                                   subversion, subkeygrip, subkeytime);
 
       xfree (keygrip);
       xfree (subkeygrip);
     }
 
 
   expire = full? ask_expire_interval (0, NULL)
                : parse_expire_string (default_expiration_interval);
   r = xcalloc (1, sizeof *r + 20);
   r->key = pKEYEXPIRE;
   r->u.expire = expire;
   r->next = para;
   para = r;
   r = xcalloc (1, sizeof *r + 20);
   r->key = pSUBKEYEXPIRE;
   r->u.expire = expire;
   r->next = para;
   para = r;
 
   uid = ask_user_id (0, full, NULL);
   if (!uid)
     {
       log_error(_("Key generation canceled.\n"));
       release_parameter_list( para );
       return;
     }
   r = xcalloc (1, sizeof *r + strlen (uid));
   r->key = pUSERID;
   strcpy (r->u.value, uid);
   r->next = para;
   para = r;
 
   proc_parameter_file (ctrl, para, "[internal]", &outctrl, !!card_serialno);
   release_parameter_list (para);
 }
 
 
 /* Create and delete a dummy packet to start off a list of kbnodes. */
 static void
 start_tree(KBNODE *tree)
 {
   PACKET *pkt;
 
   pkt=xmalloc_clear(sizeof(*pkt));
   pkt->pkttype=PKT_NONE;
   *tree=new_kbnode(pkt);
   delete_kbnode(*tree);
 }
 
 
 /* Write the *protected* secret key to the file.  */
 static gpg_error_t
 card_write_key_to_backup_file (PKT_public_key *sk, const char *backup_dir)
 {
   gpg_error_t err = 0;
   int rc;
   char keyid_buffer[2 * 8 + 1];
   char name_buffer[50];
   char *fname;
   IOBUF fp;
   mode_t oldmask;
   PACKET *pkt = NULL;
 
   format_keyid (pk_keyid (sk), KF_LONG, keyid_buffer, sizeof (keyid_buffer));
   snprintf (name_buffer, sizeof name_buffer, "sk_%s.gpg", keyid_buffer);
 
   fname = make_filename (backup_dir, name_buffer, NULL);
   /* Note that the umask call is not anymore needed because
      iobuf_create now takes care of it.  However, it does not harm
      and thus we keep it.  */
   oldmask = umask (077);
   if (is_secured_filename (fname))
     {
       fp = NULL;
       gpg_err_set_errno (EPERM);
     }
   else
     fp = iobuf_create (fname, 1);
   umask (oldmask);
   if (!fp)
     {
       err = gpg_error_from_syserror ();
       log_error (_("can't create backup file '%s': %s\n"), fname, strerror (errno) );
       goto leave;
     }
 
   pkt = xcalloc (1, sizeof *pkt);
   pkt->pkttype = PKT_SECRET_KEY;
   pkt->pkt.secret_key = sk;
 
   rc = build_packet (fp, pkt);
   if (rc)
     {
       log_error ("build packet failed: %s\n", gpg_strerror (rc));
       iobuf_cancel (fp);
     }
   else
     {
       char *fprbuf;
 
       iobuf_close (fp);
       iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char*)fname);
       log_info (_("Note: backup of card key saved to '%s'\n"), fname);
 
       fprbuf = hexfingerprint (sk, NULL, 0);
       if (!fprbuf)
         {
           err = gpg_error_from_syserror ();
           goto leave;
         }
       write_status_text_and_buffer (STATUS_BACKUP_KEY_CREATED, fprbuf,
                                     fname, strlen (fname), 0);
       xfree (fprbuf);
     }
 
  leave:
   xfree (pkt);
   xfree (fname);
   return err;
 }
 
 
 /* Store key to card and make a backup file in OpenPGP format.  */
 static gpg_error_t
 card_store_key_with_backup (ctrl_t ctrl, PKT_public_key *sub_psk,
                             const char *backup_dir)
 {
   PKT_public_key *sk;
   gnupg_isotime_t timestamp;
   gpg_error_t err;
   char *hexgrip;
   int rc;
   struct agent_card_info_s info;
   gcry_cipher_hd_t cipherhd = NULL;
   char *cache_nonce = NULL;
   void *kek = NULL;
   size_t keklen;
 
   sk = copy_public_key (NULL, sub_psk);
   if (!sk)
     return gpg_error_from_syserror ();
 
   epoch2isotime (timestamp, (time_t)sk->timestamp);
   err = hexkeygrip_from_pk (sk, &hexgrip);
   if (err)
-    return err;
+    goto leave;
 
   memset(&info, 0, sizeof (info));
   rc = agent_scd_getattr ("SERIALNO", &info);
   if (rc)
-    return (gpg_error_t)rc;
+    {
+      err = (gpg_error_t)rc;
+      goto leave;
+    }
 
   rc = agent_keytocard (hexgrip, 2, 1, info.serialno, timestamp);
   xfree (info.serialno);
   if (rc)
     {
       err = (gpg_error_t)rc;
       goto leave;
     }
 
   err = agent_keywrap_key (ctrl, 1, &kek, &keklen);
   if (err)
     {
       log_error ("error getting the KEK: %s\n", gpg_strerror (err));
       goto leave;
     }
 
   err = gcry_cipher_open (&cipherhd, GCRY_CIPHER_AES128,
                           GCRY_CIPHER_MODE_AESWRAP, 0);
   if (!err)
     err = gcry_cipher_setkey (cipherhd, kek, keklen);
   if (err)
     {
       log_error ("error setting up an encryption context: %s\n",
                  gpg_strerror (err));
       goto leave;
     }
 
   err = receive_seckey_from_agent (ctrl, cipherhd, 0,
                                    &cache_nonce, hexgrip, sk);
   if (err)
     {
       log_error ("error getting secret key from agent: %s\n",
                  gpg_strerror (err));
       goto leave;
     }
 
   err = card_write_key_to_backup_file (sk, backup_dir);
   if (err)
     log_error ("writing card key to backup file: %s\n", gpg_strerror (err));
   else
     /* Remove secret key data in agent side.  */
     agent_scd_learn (NULL, 1);
 
  leave:
   xfree (cache_nonce);
   gcry_cipher_close (cipherhd);
   xfree (kek);
   xfree (hexgrip);
   free_public_key (sk);
   return err;
 }
 
 
 static void
 do_generate_keypair (ctrl_t ctrl, struct para_data_s *para,
 		     struct output_control_s *outctrl, int card)
 {
   gpg_error_t err;
   KBNODE pub_root = NULL;
   const char *s;
   PKT_public_key *pri_psk = NULL;
   PKT_public_key *sub_psk = NULL;
   struct revocation_key *revkey;
   int did_sub = 0;
   u32 keytimestamp, subkeytimestamp, authkeytimestamp, signtimestamp;
   char *cache_nonce = NULL;
   int algo;
   u32 expire;
   const char *key_from_hexgrip = NULL;
   int cardkey;
   unsigned int keygen_flags;
 
   if (outctrl->dryrun)
     {
       log_info("dry-run mode - key generation skipped\n");
       return;
     }
 
   if ( outctrl->use_files )
     {
       if ( outctrl->pub.newfname )
         {
           iobuf_close(outctrl->pub.stream);
           outctrl->pub.stream = NULL;
           if (outctrl->pub.fname)
             iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE,
                          0, (char*)outctrl->pub.fname);
           xfree( outctrl->pub.fname );
           outctrl->pub.fname =  outctrl->pub.newfname;
           outctrl->pub.newfname = NULL;
 
           if (is_secured_filename (outctrl->pub.fname) )
             {
               outctrl->pub.stream = NULL;
               gpg_err_set_errno (EPERM);
             }
           else
             outctrl->pub.stream = iobuf_create (outctrl->pub.fname, 0);
           if (!outctrl->pub.stream)
             {
               log_error(_("can't create '%s': %s\n"), outctrl->pub.newfname,
                         strerror(errno) );
               return;
             }
           if (opt.armor)
             {
               outctrl->pub.afx->what = 1;
               push_armor_filter (outctrl->pub.afx, outctrl->pub.stream);
             }
         }
       log_assert( outctrl->pub.stream );
       if (opt.verbose)
         log_info (_("writing public key to '%s'\n"), outctrl->pub.fname );
     }
 
 
   /* We create the packets as a tree of kbnodes.  Because the
      structure we create is known in advance we simply generate a
      linked list.  The first packet is a dummy packet which we flag as
      deleted.  The very first packet must always be a KEY packet.  */
 
   start_tree (&pub_root);
 
   cardkey = get_parameter_bool (para, pCARDKEY);
 
   /* In the case that the keys are created from the card we need to
    * take the timestamps from the card.  Only in this case a
    * pSUBKEYCREATIONDATE or pAUTHKEYCREATIONDATE might be defined and
    * then we need to use that so that the fingerprint of the subkey
    * also matches the pre-computed and stored one on the card.  In
    * this case we also use the current time to create the
    * self-signatures.  */
   keytimestamp = get_parameter_u32 (para, pKEYCREATIONDATE);
   if (!keytimestamp)
     keytimestamp = make_timestamp ();
   subkeytimestamp = cardkey? get_parameter_u32 (para, pSUBKEYCREATIONDATE) : 0;
   if (!subkeytimestamp)
     subkeytimestamp = keytimestamp;
   authkeytimestamp = cardkey? get_parameter_u32 (para, pAUTHKEYCREATIONDATE): 0;
   if (!authkeytimestamp)
     authkeytimestamp = keytimestamp;
 
   signtimestamp = cardkey? make_timestamp () : keytimestamp;
 
   /* log_debug ("XXX: cardkey ..: %d\n", cardkey); */
   /* log_debug ("XXX: keytime ..: %s\n", isotimestamp (keytimestamp)); */
   /* log_debug ("XXX: subkeytime: %s\n", isotimestamp (subkeytimestamp)); */
   /* log_debug ("XXX: authkeytim: %s\n", isotimestamp (authkeytimestamp)); */
   /* log_debug ("XXX: signtime .: %s\n", isotimestamp (signtimestamp)); */
 
   /* Fixme: Check that this comment is still valid:
      Note that, depending on the backend (i.e. the used scdaemon
      version), the card key generation may update TIMESTAMP for each
      key.  Thus we need to pass TIMESTAMP to all signing function to
      make sure that the binding signature is done using the timestamp
      of the corresponding (sub)key and not that of the primary key.
      An alternative implementation could tell the signing function the
      node of the subkey but that is more work than just to pass the
      current timestamp.  */
 
   algo = get_parameter_algo (ctrl, para, pKEYTYPE, NULL );
   expire = get_parameter_u32( para, pKEYEXPIRE );
   key_from_hexgrip = get_parameter_value (para, pKEYGRIP);
   if (cardkey && !key_from_hexgrip)
     BUG ();
 
   keygen_flags = outctrl->keygen_flags;
   if (get_parameter_uint (para, pVERSION) == 5)
     keygen_flags |= KEYGEN_FLAG_CREATE_V5_KEY;
 
   if (key_from_hexgrip)
     err = do_create_from_keygrip (ctrl, algo, key_from_hexgrip, cardkey,
                                   pub_root,
                                   keytimestamp,
                                   expire, 0, keygen_flags);
   else if (!card)
     err = do_create (algo,
                      get_parameter_uint( para, pKEYLENGTH ),
                      get_parameter_value (para, pKEYCURVE),
                      pub_root,
                      keytimestamp,
                      expire, 0,
                      keygen_flags,
                      get_parameter_passphrase (para),
                      &cache_nonce, NULL);
   else
     err = gen_card_key (1, algo,
                         1, pub_root, &keytimestamp,
                         expire, keygen_flags);
 
   /* Get the pointer to the generated public key packet.  */
   if (!err)
     {
       pri_psk = pub_root->next->pkt->pkt.public_key;
       log_assert (pri_psk);
 
       /* Make sure a few fields are correctly set up before going
          further.  */
       pri_psk->flags.primary = 1;
       keyid_from_pk (pri_psk, NULL);
       /* We don't use pk_keyid to get keyid, because it also asserts
          that main_keyid is set!  */
       keyid_copy (pri_psk->main_keyid, pri_psk->keyid);
     }
 
   if (!err && (revkey = get_parameter_revkey (para, pREVOKER)))
     err = write_direct_sig (ctrl, pub_root, pri_psk,
                             revkey, signtimestamp, cache_nonce);
 
   if (!err && (s = get_parameter_value (para, pUSERID)))
     {
       err = write_uid (pub_root, s );
       if (!err)
         err = write_selfsigs (ctrl, pub_root, pri_psk,
                               get_parameter_uint (para, pKEYUSAGE),
                               signtimestamp, cache_nonce);
     }
 
   /* Write the auth key to the card before the encryption key.  This
      is a partial workaround for a PGP bug (as of this writing, all
      versions including 8.1), that causes it to try and encrypt to
      the most recent subkey regardless of whether that subkey is
      actually an encryption type.  In this case, the auth key is an
      RSA key so it succeeds. */
 
   if (!err && card && get_parameter (para, pAUTHKEYTYPE))
     {
       err = gen_card_key (3, get_parameter_algo (ctrl, para,
                                                  pAUTHKEYTYPE, NULL ),
                           0, pub_root, &authkeytimestamp, expire, keygen_flags);
       if (!err)
         err = write_keybinding (ctrl, pub_root, pri_psk, NULL,
                                 PUBKEY_USAGE_AUTH, signtimestamp, cache_nonce);
     }
 
   if (!err && get_parameter (para, pSUBKEYTYPE))
     {
       int subkey_algo = get_parameter_algo (ctrl, para, pSUBKEYTYPE, NULL);
 
       s = NULL;
       key_from_hexgrip = get_parameter_value (para, pSUBKEYGRIP);
 
       keygen_flags = outctrl->keygen_flags;
       if (get_parameter_uint (para, pSUBVERSION) == 5)
         keygen_flags |= KEYGEN_FLAG_CREATE_V5_KEY;
 
       if (key_from_hexgrip)
         err = do_create_from_keygrip (ctrl, subkey_algo,
                                       key_from_hexgrip, cardkey,
                                       pub_root, subkeytimestamp,
                                       get_parameter_u32 (para, pSUBKEYEXPIRE),
                                       1, keygen_flags);
       else if (!card || (s = get_parameter_value (para, pCARDBACKUPKEY)))
         {
           err = do_create (subkey_algo,
                            get_parameter_uint (para, pSUBKEYLENGTH),
                            get_parameter_value (para, pSUBKEYCURVE),
                            pub_root,
                            subkeytimestamp,
                            get_parameter_u32 (para, pSUBKEYEXPIRE), 1,
                            s? KEYGEN_FLAG_NO_PROTECTION : keygen_flags,
                            get_parameter_passphrase (para),
                            &cache_nonce, NULL);
           /* Get the pointer to the generated public subkey packet.  */
           if (!err)
             {
               kbnode_t node;
 
               for (node = pub_root; node; node = node->next)
                 if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
                   sub_psk = node->pkt->pkt.public_key;
               log_assert (sub_psk);
 
               if (s)
                 err = card_store_key_with_backup (ctrl,
                                                   sub_psk, gnupg_homedir ());
             }
         }
       else
         {
           err = gen_card_key (2, subkey_algo, 0, pub_root,
                               &subkeytimestamp, expire, keygen_flags);
         }
 
       if (!err)
         err = write_keybinding (ctrl, pub_root, pri_psk, sub_psk,
                                 get_parameter_uint (para, pSUBKEYUSAGE),
                                 signtimestamp, cache_nonce);
       did_sub = 1;
     }
 
   if (!err && outctrl->use_files)  /* Direct write to specified files.  */
     {
       err = write_keyblock (outctrl->pub.stream, pub_root);
       if (err)
         log_error ("can't write public key: %s\n", gpg_strerror (err));
     }
   else if (!err) /* Write to the standard keyrings.  */
     {
       KEYDB_HANDLE pub_hd;
 
       pub_hd = keydb_new (ctrl);
       if (!pub_hd)
         err = gpg_error_from_syserror ();
       else
         {
           err = keydb_locate_writable (pub_hd);
           if (err)
             log_error (_("no writable public keyring found: %s\n"),
                        gpg_strerror (err));
         }
 
       if (!err && opt.verbose)
         {
           log_info (_("writing public key to '%s'\n"),
                     keydb_get_resource_name (pub_hd));
         }
 
       if (!err)
         {
           err = keydb_insert_keyblock (pub_hd, pub_root);
           if (err)
             log_error (_("error writing public keyring '%s': %s\n"),
                        keydb_get_resource_name (pub_hd), gpg_strerror (err));
         }
 
       keydb_release (pub_hd);
 
       if (!err)
         {
           int no_enc_rsa;
           PKT_public_key *pk;
           char hexfpr[2*MAX_FINGERPRINT_LEN + 1];
 
           no_enc_rsa = ((get_parameter_algo (ctrl, para, pKEYTYPE, NULL)
                          == PUBKEY_ALGO_RSA)
                         && get_parameter_uint (para, pKEYUSAGE)
                         && !((get_parameter_uint (para, pKEYUSAGE)
                               & PUBKEY_USAGE_ENC)) );
 
           pk = find_kbnode (pub_root, PKT_PUBLIC_KEY)->pkt->pkt.public_key;
 
           hexfingerprint (pk, hexfpr, sizeof hexfpr);
           register_trusted_key (hexfpr);
 
           if (!opt.flags.no_auto_trust_new_key)
             update_ownertrust (ctrl, pk,
                                ((get_ownertrust (ctrl, pk) & ~TRUST_MASK)
                                 | TRUST_ULTIMATE ));
 
           gen_standard_revoke (ctrl, pk, cache_nonce);
 
           /* Get rid of the first empty packet.  */
           commit_kbnode (&pub_root);
 
           if (!opt.batch)
             {
               tty_printf (_("public and secret key created and signed.\n") );
               tty_printf ("\n");
               merge_keys_and_selfsig (ctrl, pub_root);
 
               list_keyblock_direct (ctrl, pub_root, 0, 1,
                                     opt.fingerprint || opt.with_fingerprint,
                                     1);
             }
 
 
           if (!opt.batch
               && (get_parameter_algo (ctrl, para,
                                       pKEYTYPE, NULL) == PUBKEY_ALGO_DSA
                   || no_enc_rsa )
               && !get_parameter (para, pSUBKEYTYPE) )
             {
               tty_printf(_("Note that this key cannot be used for "
                            "encryption.  You may want to use\n"
                            "the command \"--edit-key\" to generate a "
                            "subkey for this purpose.\n") );
             }
         }
     }
 
   if (err)
     {
       if (opt.batch)
         log_error ("key generation failed: %s\n", gpg_strerror (err) );
       else
         tty_printf (_("Key generation failed: %s\n"), gpg_strerror (err) );
       write_status_error (card? "card_key_generate":"key_generate", err);
       print_status_key_not_created ( get_parameter_value (para, pHANDLE) );
     }
   else
     {
       PKT_public_key *pk = find_kbnode (pub_root,
                                         PKT_PUBLIC_KEY)->pkt->pkt.public_key;
       print_status_key_created (did_sub? 'B':'P', pk,
                                 get_parameter_value (para, pHANDLE));
     }
 
   release_kbnode (pub_root);
   xfree (cache_nonce);
 }
 
 
 static gpg_error_t
 parse_algo_usage_expire (ctrl_t ctrl, int for_subkey,
                          const char *algostr, const char *usagestr,
                          const char *expirestr,
                          int *r_algo, unsigned int *r_usage, u32 *r_expire,
                          unsigned int *r_nbits, const char **r_curve,
                          int *r_version, char **r_keygrip, u32 *r_keytime)
 {
   gpg_error_t err;
   int algo;
   unsigned int use, nbits;
   u32 expire;
   int wantuse;
   int version = 4;
   const char *curve = NULL;
 
   *r_curve = NULL;
   if (r_keygrip)
     *r_keygrip = NULL;
   if (r_keytime)
     *r_keytime = 0;
 
   nbits = 0;
 
   /* Parse the algo string.  */
   if (algostr && *algostr == '&' && strlen (algostr) == 41)
     {
       /* Take algo from existing key.  */
       algo = check_keygrip (ctrl, algostr+1);
       /* FIXME: We need the curve name as well.  */
       return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
     }
 
   err = parse_key_parameter_string (ctrl, algostr, for_subkey? 1 : 0,
                                     usagestr? parse_usagestr (usagestr):0,
                                     &algo, &nbits, &use, &curve, &version,
                                     r_keygrip, r_keytime,
                                     NULL, NULL, NULL, NULL, NULL, NULL, NULL);
   if (err)
     {
       if (r_keygrip)
         {
           xfree (*r_keygrip);
           *r_keygrip = NULL;
         }
       return err;
     }
 
   /* Parse the usage string.  */
   if (!usagestr || !*usagestr
       || !ascii_strcasecmp (usagestr, "default") || !strcmp (usagestr, "-"))
     ; /* Keep usage from parse_key_parameter_string.  */
   else if ((wantuse = parse_usagestr (usagestr)) != -1)
     use = wantuse;
   else
     {
       if (r_keygrip)
         {
           xfree (*r_keygrip);
           *r_keygrip = NULL;
         }
       return gpg_error (GPG_ERR_INV_VALUE);
     }
 
   /* Make sure a primary key has the CERT usage.  */
   if (!for_subkey)
     use |= PUBKEY_USAGE_CERT;
 
   /* Check that usage is possible.  NB: We have the same check in
    * parse_key_parameter_string but need it here again in case the
    * separate usage value has been given. */
   if (/**/((use & (PUBKEY_USAGE_SIG|PUBKEY_USAGE_AUTH|PUBKEY_USAGE_CERT))
            && !pubkey_get_nsig (algo))
        || ((use & PUBKEY_USAGE_ENC)
            && !pubkey_get_nenc (algo))
        || (for_subkey && (use & PUBKEY_USAGE_CERT)))
     {
       if (r_keygrip)
         {
           xfree (*r_keygrip);
           *r_keygrip = NULL;
         }
       return gpg_error (GPG_ERR_WRONG_KEY_USAGE);
     }
 
   /* Parse the expire string.  */
   expire = parse_expire_string (expirestr);
   if (expire == (u32)-1 )
     {
       if (r_keygrip)
         {
           xfree (*r_keygrip);
           *r_keygrip = NULL;
         }
       return gpg_error (GPG_ERR_INV_VALUE);
     }
 
   if (curve)
     *r_curve = curve;
   *r_algo = algo;
   *r_usage = use;
   *r_expire = expire;
   *r_nbits = nbits;
   *r_version = version;
   return 0;
 }
 
 
 /* Add a new subkey to an existing key.  Returns 0 if a new key has
    been generated and put into the keyblocks.  If any of ALGOSTR,
    USAGESTR, or EXPIRESTR is NULL interactive mode is used. */
 gpg_error_t
 generate_subkeypair (ctrl_t ctrl, kbnode_t keyblock, const char *algostr,
                      const char *usagestr, const char *expirestr)
 {
   gpg_error_t err = 0;
   int interactive;
   kbnode_t node;
   PKT_public_key *pri_psk = NULL;
   PKT_public_key *sub_psk = NULL;
   int algo;
   unsigned int use;
   u32 expire;
   unsigned int nbits = 0;
   const char *curve = NULL;
   u32 cur_time;
   char *key_from_hexgrip = NULL;
   u32 keytime = 0;
   int cardkey = 0;
   char *hexgrip = NULL;
   char *serialno = NULL;
   char *cache_nonce = NULL;
   char *passwd_nonce = NULL;
   int keygen_flags = 0;
 
   interactive = (!algostr || !usagestr || !expirestr);
 
   /* Break out the primary key.  */
   node = find_kbnode (keyblock, PKT_PUBLIC_KEY);
   if (!node)
     {
       log_error ("Oops; primary key missing in keyblock!\n");
       err = gpg_error (GPG_ERR_BUG);
       goto leave;
     }
   pri_psk = node->pkt->pkt.public_key;
 
   cur_time = make_timestamp ();
 
   if (pri_psk->timestamp > cur_time)
     {
       ulong d = pri_psk->timestamp - cur_time;
       log_info ( d==1 ? _("key has been created %lu second "
                           "in future (time warp or clock problem)\n")
                  : _("key has been created %lu seconds "
                      "in future (time warp or clock problem)\n"), d );
       if (!opt.ignore_time_conflict)
         {
           err = gpg_error (GPG_ERR_TIME_CONFLICT);
           goto leave;
         }
     }
 
   if (pri_psk->version < 4)
     {
       log_info (_("Note: creating subkeys for v3 keys "
                   "is not OpenPGP compliant\n"));
       err = gpg_error (GPG_ERR_CONFLICT);
       goto leave;
     }
 
   err = hexkeygrip_from_pk (pri_psk, &hexgrip);
   if (err)
     goto leave;
   if (agent_get_keyinfo (NULL, hexgrip, &serialno, NULL))
     {
       if (interactive)
         tty_printf (_("Secret parts of primary key are not available.\n"));
       else
         log_info (  _("Secret parts of primary key are not available.\n"));
       err = gpg_error (GPG_ERR_NO_SECKEY);
       goto leave;
     }
   if (serialno)
     {
       if (interactive)
         tty_printf (_("Secret parts of primary key are stored on-card.\n"));
       else
         log_info (  _("Secret parts of primary key are stored on-card.\n"));
     }
 
   if (interactive)
     {
       algo = ask_algo (ctrl, 1, NULL, &use, &key_from_hexgrip, &cardkey,
                        &keytime);
       log_assert (algo);
 
       if (key_from_hexgrip)
         nbits = 0;
       else if (algo == PUBKEY_ALGO_ECDSA
                || algo == PUBKEY_ALGO_EDDSA
                || algo == PUBKEY_ALGO_ECDH)
         curve = ask_curve (&algo, NULL, NULL);
       else
         nbits = ask_keysize (algo, 0);
 
       expire = ask_expire_interval (0, NULL);
       if (!cpr_enabled() && !cpr_get_answer_is_yes("keygen.sub.okay",
                                                    _("Really create? (y/N) ")))
         {
           err = gpg_error (GPG_ERR_CANCELED);
           goto leave;
         }
     }
   else /* Unattended mode.  */
     {
       int version;
 
       err = parse_algo_usage_expire (ctrl, 1, algostr, usagestr, expirestr,
                                      &algo, &use, &expire, &nbits, &curve,
                                      &version, &key_from_hexgrip, &keytime);
       if (err)
         goto leave;
 
       if (version == 5)
         keygen_flags |= KEYGEN_FLAG_CREATE_V5_KEY;
     }
 
   /* Verify the passphrase now so that we get a cache item for the
    * primary key passphrase.  The agent also returns a passphrase
    * nonce, which we can use to set the passphrase for the subkey to
    * that of the primary key.  */
   {
     char *desc = gpg_format_keydesc (ctrl, pri_psk, FORMAT_KEYDESC_NORMAL, 1);
     err = agent_passwd (ctrl, hexgrip, desc, 1 /*=verify*/,
                         &cache_nonce, &passwd_nonce);
     xfree (desc);
     if (gpg_err_code (err) == GPG_ERR_NOT_IMPLEMENTED
         && gpg_err_source (err) == GPG_ERR_SOURCE_GPGAGENT)
       err = 0;  /* Very likely that the key is on a card.  */
     if (err)
       goto leave;
   }
 
   /* Start creation.  */
   if (key_from_hexgrip)
     {
       err = do_create_from_keygrip (ctrl, algo, key_from_hexgrip, cardkey,
                                     keyblock,
                                     keytime? keytime : cur_time,
                                     expire, 1,
                                     keygen_flags);
     }
   else
     {
       const char *passwd;
 
       /* If the pinentry loopback mode is not and we have a static
          passphrase (i.e. set with --passphrase{,-fd,-file} while in batch
          mode), we use that passphrase for the new subkey.  */
       if (opt.pinentry_mode != PINENTRY_MODE_LOOPBACK
           && have_static_passphrase ())
         passwd = get_static_passphrase ();
       else
         passwd = NULL;
 
       err = do_create (algo, nbits, curve,
                        keyblock, cur_time, expire, 1, keygen_flags,
                        passwd, &cache_nonce, &passwd_nonce);
     }
   if (err)
     goto leave;
 
   /* Get the pointer to the generated public subkey packet.  */
   for (node = keyblock; node; node = node->next)
     if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
       sub_psk = node->pkt->pkt.public_key;
 
   /* Write the binding signature.  */
   err = write_keybinding (ctrl, keyblock, pri_psk, sub_psk, use, cur_time,
                           cache_nonce);
   if (err)
     goto leave;
 
   print_status_key_created ('S', sub_psk, NULL);
 
 
  leave:
   xfree (key_from_hexgrip);
   xfree (hexgrip);
   xfree (serialno);
   xfree (cache_nonce);
   xfree (passwd_nonce);
   if (err)
     log_error (_("Key generation failed: %s\n"), gpg_strerror (err) );
   return err;
 }
 
 
 #ifdef ENABLE_CARD_SUPPORT
 /* Generate a subkey on a card. */
 gpg_error_t
 generate_card_subkeypair (ctrl_t ctrl, kbnode_t pub_keyblock,
                           int keyno, const char *serialno)
 {
   gpg_error_t err = 0;
   kbnode_t node;
   PKT_public_key *pri_pk = NULL;
   unsigned int use;
   u32 expire;
   u32 cur_time;
   struct para_data_s *para = NULL;
   PKT_public_key *sub_pk = NULL;
   int algo;
   struct agent_card_info_s info;
   int keygen_flags = 0;  /* FIXME!!! */
 
   log_assert (keyno >= 1 && keyno <= 3);
 
   memset (&info, 0, sizeof (info));
   err = agent_scd_getattr ("KEY-ATTR", &info);
   if (err)
     {
       log_error (_("error getting current key info: %s\n"), gpg_strerror (err));
       return err;
     }
   algo = info.key_attr[keyno-1].algo;
 
   para = xtrycalloc (1, sizeof *para + strlen (serialno) );
   if (!para)
     {
       err = gpg_error_from_syserror ();
       goto leave;
     }
   para->key = pSERIALNO;
   strcpy (para->u.value, serialno);
 
   /* Break out the primary secret key */
   node = find_kbnode (pub_keyblock, PKT_PUBLIC_KEY);
   if (!node)
     {
       log_error ("Oops; public key lost!\n");
       err = gpg_error (GPG_ERR_INTERNAL);
       goto leave;
     }
   pri_pk = node->pkt->pkt.public_key;
 
   cur_time = make_timestamp();
   if (pri_pk->timestamp > cur_time)
     {
       ulong d = pri_pk->timestamp - cur_time;
       log_info (d==1 ? _("key has been created %lu second "
                          "in future (time warp or clock problem)\n")
                      : _("key has been created %lu seconds "
                          "in future (time warp or clock problem)\n"), d );
 	if (!opt.ignore_time_conflict)
           {
 	    err = gpg_error (GPG_ERR_TIME_CONFLICT);
 	    goto leave;
           }
     }
 
   if (pri_pk->version < 4)
     {
       log_info (_("Note: creating subkeys for v3 keys "
                   "is not OpenPGP compliant\n"));
       err = gpg_error (GPG_ERR_NOT_SUPPORTED);
       goto leave;
     }
 
   expire = ask_expire_interval (0, NULL);
   if (keyno == 1)
     use = PUBKEY_USAGE_SIG;
   else if (keyno == 2)
     use = PUBKEY_USAGE_ENC;
   else
     use = PUBKEY_USAGE_AUTH;
   if (!cpr_enabled() && !cpr_get_answer_is_yes("keygen.cardsub.okay",
                                                _("Really create? (y/N) ")))
     {
       err = gpg_error (GPG_ERR_CANCELED);
       goto leave;
     }
 
   /* Note, that depending on the backend, the card key generation may
      update CUR_TIME.  */
   err = gen_card_key (keyno, algo, 0, pub_keyblock, &cur_time, expire,
                       keygen_flags);
   /* Get the pointer to the generated public subkey packet.  */
   if (!err)
     {
       for (node = pub_keyblock; node; node = node->next)
         if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
           sub_pk = node->pkt->pkt.public_key;
       log_assert (sub_pk);
       err = write_keybinding (ctrl, pub_keyblock, pri_pk, sub_pk,
                               use, cur_time, NULL);
     }
 
  leave:
   if (err)
     log_error (_("Key generation failed: %s\n"), gpg_strerror (err) );
   else
     print_status_key_created ('S', sub_pk, NULL);
   release_parameter_list (para);
   return err;
 }
 #endif /* !ENABLE_CARD_SUPPORT */
 
 /*
  * Write a keyblock to an output stream
  */
 static int
 write_keyblock( IOBUF out, KBNODE node )
 {
   for( ; node ; node = node->next )
     {
       if(!is_deleted_kbnode(node))
 	{
 	  int rc = build_packet( out, node->pkt );
 	  if( rc )
 	    {
 	      log_error("build_packet(%d) failed: %s\n",
 			node->pkt->pkttype, gpg_strerror (rc) );
 	      return rc;
 	    }
 	}
     }
 
   return 0;
 }
 
 
 /* Note that timestamp is an in/out arg.
  * FIXME: Does not yet support v5 keys.   */
 static gpg_error_t
 gen_card_key (int keyno, int algo, int is_primary, kbnode_t pub_root,
               u32 *timestamp, u32 expireval, int keygen_flags)
 {
 #ifdef ENABLE_CARD_SUPPORT
   gpg_error_t err;
   PACKET *pkt;
   PKT_public_key *pk;
   char keyid[10];
   unsigned char *public;
   gcry_sexp_t s_key;
 
   snprintf (keyid, DIM(keyid), "OPENPGP.%d", keyno);
 
   pk = xtrycalloc (1, sizeof *pk );
   if (!pk)
     return gpg_error_from_syserror ();
   pkt = xtrycalloc (1, sizeof *pkt);
   if (!pkt)
     {
       xfree (pk);
       return gpg_error_from_syserror ();
     }
 
   /* Note: SCD knows the serialnumber, thus there is no point in passing it.  */
   err = agent_scd_genkey (keyno, 1, timestamp);
   /*  The code below is not used because we force creation of
    *  the a card key (3rd arg).
    * if (gpg_err_code (rc) == GPG_ERR_EEXIST)
    *   {
    *     tty_printf ("\n");
    *     log_error ("WARNING: key does already exists!\n");
    *     tty_printf ("\n");
    *     if ( cpr_get_answer_is_yes( "keygen.card.replace_key",
    *                                 _("Replace existing key? ")))
    *       rc = agent_scd_genkey (keyno, 1, timestamp);
    *   }
   */
   if (err)
     {
       log_error ("key generation failed: %s\n", gpg_strerror (err));
       xfree (pkt);
       xfree (pk);
       return err;
     }
 
   /* Send the READKEY command so that the agent creates a shadow key for
      card key.  We need to do that now so that we are able to create
      the self-signatures. */
   err = agent_readkey (NULL, 1, keyid, &public);
   if (err)
     return err;
   err = gcry_sexp_sscan (&s_key, NULL, public,
                          gcry_sexp_canon_len (public, 0, NULL, NULL));
   xfree (public);
   if (err)
     return err;
 
   if (algo == PUBKEY_ALGO_RSA)
     err = key_from_sexp (pk->pkey, s_key, "public-key", "ne");
   else if (algo == PUBKEY_ALGO_ECDSA
            || algo == PUBKEY_ALGO_EDDSA
            || algo == PUBKEY_ALGO_ECDH )
     err = ecckey_from_sexp (pk->pkey, s_key, algo);
   else
     err = gpg_error (GPG_ERR_PUBKEY_ALGO);
   gcry_sexp_release (s_key);
 
   if (err)
     {
       log_error ("key_from_sexp failed: %s\n", gpg_strerror (err) );
       free_public_key (pk);
       return err;
     }
 
   pk->timestamp = *timestamp;
   pk->version = (keygen_flags & KEYGEN_FLAG_CREATE_V5_KEY)? 5 : 4;
   if (expireval)
     pk->expiredate = pk->timestamp + expireval;
   pk->pubkey_algo = algo;
 
   pkt->pkttype = is_primary ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
   pkt->pkt.public_key = pk;
   add_kbnode (pub_root, new_kbnode (pkt));
 
   return 0;
 #else
   (void)keyno;
   (void)is_primary;
   (void)pub_root;
   (void)timestamp;
   (void)expireval;
   return gpg_error (GPG_ERR_NOT_SUPPORTED);
 #endif /*!ENABLE_CARD_SUPPORT*/
 }
diff --git a/g10/keyserver.c b/g10/keyserver.c
index c56021691..a20ebf24e 100644
--- a/g10/keyserver.c
+++ b/g10/keyserver.c
@@ -1,2188 +1,2188 @@
 /* keyserver.c - generic keyserver code
  * Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
  *               2009, 2011, 2012 Free Software Foundation, Inc.
  * Copyright (C) 2014 Werner Koch
  *
  * 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 <ctype.h>
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <errno.h>
 
 #include "gpg.h"
 #include "../common/iobuf.h"
 #include "filter.h"
 #include "keydb.h"
 #include "../common/status.h"
 #include "main.h"
 #include "../common/i18n.h"
 #include "../common/ttyio.h"
 #include "options.h"
 #include "packet.h"
 #include "trustdb.h"
 #include "keyserver-internal.h"
 #include "../common/util.h"
 #include "../common/membuf.h"
 #include "../common/mbox-util.h"
 #include "call-dirmngr.h"
 
 #ifdef HAVE_W32_SYSTEM
 /* It seems Vista doesn't grok X_OK and so fails access() tests.
    Previous versions interpreted X_OK as F_OK anyway, so we'll just
    use F_OK directly. */
 #undef X_OK
 #define X_OK F_OK
 #endif /* HAVE_W32_SYSTEM */
 
 struct keyrec
 {
   KEYDB_SEARCH_DESC desc;
   u32 createtime,expiretime;
   int size,flags;
   byte type;
   IOBUF uidbuf;
   unsigned int lines;
 };
 
 /* Parameters for the search line handler.  */
 struct search_line_handler_parm_s
 {
   ctrl_t ctrl;     /* The session control structure.  */
   char *searchstr_disp;  /* Native encoded search string or NULL.  */
   KEYDB_SEARCH_DESC *desc; /* Array with search descriptions.  */
   int count;      /* Number of keys we are currently prepared to
                      handle.  This is the size of the DESC array.  If
                      it is too small, it will grow safely.  */
   int validcount; /* Enable the "Key x-y of z" messages. */
   int nkeys;      /* Number of processed records.  */
   int any_lines;  /* At least one line has been processed.  */
   unsigned int numlines;  /* Counter for displayed lines.  */
   int eof_seen;   /* EOF encountered.  */
   int not_found;  /* Set if no keys have been found.  */
 };
 
 
 enum ks_action {KS_UNKNOWN=0,KS_GET,KS_GETNAME,KS_SEND,KS_SEARCH};
 
 static struct parse_options keyserver_opts[]=
   {
     /* some of these options are not real - just for the help
        message */
     {"max-cert-size",0,NULL,NULL},  /* MUST be the first in this array! */
     {"http-proxy", KEYSERVER_HTTP_PROXY, NULL, /* MUST be the second!  */
      N_("override proxy options set for dirmngr")},
 
     {"include-revoked",0,NULL,N_("include revoked keys in search results")},
     {"include-subkeys",0,NULL,N_("include subkeys when searching by key ID")},
     {"timeout", KEYSERVER_TIMEOUT, NULL,
      N_("override timeout options set for dirmngr")},
     {"refresh-add-fake-v3-keyids",KEYSERVER_ADD_FAKE_V3,NULL,
      NULL},
     {"auto-key-retrieve",KEYSERVER_AUTO_KEY_RETRIEVE,NULL,
      N_("automatically retrieve keys when verifying signatures")},
     {"honor-keyserver-url",KEYSERVER_HONOR_KEYSERVER_URL,NULL,
      N_("honor the preferred keyserver URL set on the key")},
     {NULL,0,NULL,NULL}
   };
 
 static gpg_error_t keyserver_get (ctrl_t ctrl,
                                   KEYDB_SEARCH_DESC *desc, int ndesc,
                                   struct keyserver_spec *override_keyserver,
                                   unsigned int flags,
                                   unsigned char **r_fpr, size_t *r_fprlen);
 static gpg_error_t keyserver_put (ctrl_t ctrl, strlist_t keyspecs);
 
 
 /* Reasonable guess.  The commonly used test key simon.josefsson.org
    is larger than 32k, thus we need at least this value. */
 #define DEFAULT_MAX_CERT_SIZE 65536
 
 static size_t max_cert_size=DEFAULT_MAX_CERT_SIZE;
 
 
 static void
 warn_kshelper_option(char *option, int noisy)
 {
   char *p;
 
   if ((p=strchr (option, '=')))
     *p = 0;
 
   if (!strcmp (option, "ca-cert-file"))
     log_info ("keyserver option '%s' is obsolete; please use "
               "'%s' in dirmngr.conf\n",
               "ca-cert-file", "hkp-cacert");
   else if (!strcmp (option, "check-cert")
            || !strcmp (option, "broken-http-proxy"))
     log_info ("keyserver option '%s' is obsolete\n", option);
   else if (noisy || opt.verbose)
     log_info ("keyserver option '%s' is unknown\n", option);
 }
 
 
 /* Called from main to parse the args for --keyserver-options.  */
 int
 parse_keyserver_options(char *options)
 {
   int ret=1;
   char *tok;
   char *max_cert=NULL;
 
   keyserver_opts[0].value=&max_cert;
   keyserver_opts[1].value=&opt.keyserver_options.http_proxy;
 
   while((tok=optsep(&options)))
     {
       if(tok[0]=='\0')
 	continue;
 
       /* We accept quite a few possible options here - some options to
 	 handle specially, the keyserver_options list, and import and
 	 export options that pertain to keyserver operations.  */
 
       if (!parse_options (tok,&opt.keyserver_options.options, keyserver_opts,0)
           && !parse_import_options(tok,&opt.keyserver_options.import_options,0)
           && !parse_export_options(tok,&opt.keyserver_options.export_options,0))
 	{
 	  /* All of the standard options have failed, so the option was
 	     destined for a keyserver plugin as used by GnuPG < 2.1 */
 	  warn_kshelper_option (tok, 1);
 	}
     }
 
   if(max_cert)
     {
       max_cert_size=strtoul(max_cert,(char **)NULL,10);
 
       if(max_cert_size==0)
 	max_cert_size=DEFAULT_MAX_CERT_SIZE;
     }
 
   return ret;
 }
 
 
 void
 free_keyserver_spec(struct keyserver_spec *keyserver)
 {
   xfree(keyserver->uri);
   xfree(keyserver->scheme);
   xfree(keyserver->auth);
   xfree(keyserver->host);
   xfree(keyserver->port);
   xfree(keyserver->path);
   xfree(keyserver->opaque);
   free_strlist(keyserver->options);
   xfree(keyserver);
 }
 
 /* Return 0 for match */
 static int
 cmp_keyserver_spec(struct keyserver_spec *one,struct keyserver_spec *two)
 {
   if(ascii_strcasecmp(one->scheme,two->scheme)==0)
     {
       if(one->host && two->host && ascii_strcasecmp(one->host,two->host)==0)
 	{
 	  if((one->port && two->port
 	      && ascii_strcasecmp(one->port,two->port)==0)
 	     || (!one->port && !two->port))
 	    return 0;
 	}
       else if(one->opaque && two->opaque
 	      && ascii_strcasecmp(one->opaque,two->opaque)==0)
 	return 0;
     }
 
   return 1;
 }
 
 /* Try and match one of our keyservers.  If we can, return that.  If
    we can't, return our input. */
 struct keyserver_spec *
 keyserver_match(struct keyserver_spec *spec)
 {
   struct keyserver_spec *ks;
 
   for(ks=opt.keyserver;ks;ks=ks->next)
     if(cmp_keyserver_spec(spec,ks)==0)
       return ks;
 
   return spec;
 }
 
 /* TODO: once we cut over to an all-curl world, we don't need this
    parser any longer so it can be removed, or at least moved to
    keyserver/ksutil.c for limited use in gpgkeys_ldap or the like. */
 
 keyserver_spec_t
 parse_keyserver_uri (const char *string,int require_scheme)
 {
   int assume_hkp=0;
   struct keyserver_spec *keyserver;
   const char *idx;
   int count;
   char *uri, *duped_uri, *options;
 
   log_assert (string);
 
   keyserver=xmalloc_clear(sizeof(struct keyserver_spec));
 
   duped_uri = uri = xstrdup (string);
 
   options=strchr(uri,' ');
   if(options)
     {
       char *tok;
 
       *options='\0';
       options++;
 
       while((tok=optsep(&options)))
 	warn_kshelper_option (tok, 0);
     }
 
   /* Get the scheme */
 
   for(idx=uri,count=0;*idx && *idx!=':';idx++)
     {
       count++;
 
       /* Do we see the start of an RFC-2732 ipv6 address here?  If so,
 	 there clearly isn't a scheme so get out early. */
       if(*idx=='[')
 	{
 	  /* Was the '[' the first thing in the string?  If not, we
 	     have a mangled scheme with a [ in it so fail. */
 	  if(count==1)
 	    break;
 	  else
 	    goto fail;
 	}
     }
 
   if(count==0)
     goto fail;
 
   if(*idx=='\0' || *idx=='[')
     {
       if(require_scheme)
-	return NULL;
+	goto fail;
 
       /* Assume HKP if there is no scheme */
       assume_hkp=1;
       keyserver->scheme=xstrdup("hkp");
 
       keyserver->uri=xmalloc(strlen(keyserver->scheme)+3+strlen(uri)+1);
       strcpy(keyserver->uri,keyserver->scheme);
       strcat(keyserver->uri,"://");
       strcat(keyserver->uri,uri);
     }
   else
     {
       int i;
 
       keyserver->uri=xstrdup(uri);
 
       keyserver->scheme=xmalloc(count+1);
 
       /* Force to lowercase */
       for(i=0;i<count;i++)
 	keyserver->scheme[i]=ascii_tolower(uri[i]);
 
       keyserver->scheme[i]='\0';
 
       /* Skip past the scheme and colon */
       uri+=count+1;
     }
 
   if(ascii_strcasecmp(keyserver->scheme,"x-broken-hkp")==0)
     {
       log_info ("keyserver option '%s' is obsolete\n",
                 "x-broken-hkp");
     }
   else if(ascii_strcasecmp(keyserver->scheme,"x-hkp")==0)
     {
       /* Canonicalize this to "hkp" so it works with both the internal
 	 and external keyserver interface. */
       xfree(keyserver->scheme);
       keyserver->scheme=xstrdup("hkp");
     }
 
   if (uri[0]=='/' && uri[1]=='/' && uri[2] == '/')
     {
       /* Three slashes means network path with a default host name.
          This is a hack because it does not crok all possible
          combinations.  We should better replace all code by the parser
          from http.c.  */
       keyserver->path = xstrdup (uri+2);
     }
   else if(assume_hkp || (uri[0]=='/' && uri[1]=='/'))
     {
       /* Two slashes means network path. */
 
       /* Skip over the "//", if any */
       if(!assume_hkp)
 	uri+=2;
 
       /* Do we have userinfo auth data present? */
       for(idx=uri,count=0;*idx && *idx!='@' && *idx!='/';idx++)
 	count++;
 
       /* We found a @ before the slash, so that means everything
 	 before the @ is auth data. */
       if(*idx=='@')
 	{
 	  if(count==0)
 	    goto fail;
 
 	  keyserver->auth=xmalloc(count+1);
 	  strncpy(keyserver->auth,uri,count);
 	  keyserver->auth[count]='\0';
 	  uri+=count+1;
 	}
 
       /* Is it an RFC-2732 ipv6 [literal address] ? */
       if(*uri=='[')
 	{
 	  for(idx=uri+1,count=1;*idx
 		&& ((isascii (*idx) && isxdigit(*idx))
                     || *idx==':' || *idx=='.');idx++)
 	    count++;
 
 	  /* Is the ipv6 literal address terminated? */
 	  if(*idx==']')
 	    count++;
 	  else
 	    goto fail;
 	}
       else
 	for(idx=uri,count=0;*idx && *idx!=':' && *idx!='/';idx++)
 	  count++;
 
       if(count==0)
 	goto fail;
 
       keyserver->host=xmalloc(count+1);
       strncpy(keyserver->host,uri,count);
       keyserver->host[count]='\0';
 
       /* Skip past the host */
       uri+=count;
 
       if(*uri==':')
 	{
 	  /* It would seem to be reasonable to limit the range of the
 	     ports to values between 1-65535, but RFC 1738 and 1808
 	     imply there is no limit.  Of course, the real world has
 	     limits. */
 
 	  for(idx=uri+1,count=0;*idx && *idx!='/';idx++)
 	    {
 	      count++;
 
 	      /* Ports are digits only */
 	      if(!digitp(idx))
 		goto fail;
 	    }
 
 	  keyserver->port=xmalloc(count+1);
 	  strncpy(keyserver->port,uri+1,count);
 	  keyserver->port[count]='\0';
 
 	  /* Skip past the colon and port number */
 	  uri+=1+count;
 	}
 
       /* Everything else is the path */
       if(*uri)
 	keyserver->path=xstrdup(uri);
       else
 	keyserver->path=xstrdup("/");
 
       if(keyserver->path[1])
 	keyserver->flags.direct_uri=1;
     }
   else if(uri[0]!='/')
     {
       /* No slash means opaque.  Just record the opaque blob and get
 	 out. */
       keyserver->opaque=xstrdup(uri);
     }
   else
     {
       /* One slash means absolute path.  We don't need to support that
 	 yet. */
       goto fail;
     }
 
   xfree (duped_uri);
   return keyserver;
 
  fail:
   free_keyserver_spec(keyserver);
 
   xfree (duped_uri);
   return NULL;
 }
 
 struct keyserver_spec *
 parse_preferred_keyserver(PKT_signature *sig)
 {
   struct keyserver_spec *spec=NULL;
   const byte *p;
   size_t plen;
 
   p = parse_sig_subpkt (sig, 1, SIGSUBPKT_PREF_KS, &plen);
   if(p && plen)
     {
       byte *dupe=xmalloc(plen+1);
 
       memcpy(dupe,p,plen);
       dupe[plen]='\0';
       spec = parse_keyserver_uri (dupe, 1);
       xfree(dupe);
     }
 
   return spec;
 }
 
 static void
 print_keyrec (ctrl_t ctrl, int number,struct keyrec *keyrec)
 {
 
   iobuf_writebyte(keyrec->uidbuf,0);
   iobuf_flush_temp(keyrec->uidbuf);
   es_printf ("(%d)\t%s  ", number, iobuf_get_temp_buffer (keyrec->uidbuf));
 
   if (keyrec->size>0)
     es_printf ("%d bit ", keyrec->size);
 
   if(keyrec->type)
     {
       const char *str;
 
       str = openpgp_pk_algo_name (keyrec->type);
 
       if (str && strcmp (str, "?"))
 	es_printf ("%s ",str);
       else
 	es_printf ("unknown ");
     }
 
   switch(keyrec->desc.mode)
     {
       /* If the keyserver helper gave us a short keyid, we have no
 	 choice but to use it.  Do check --keyid-format to add a 0x if
 	 needed. */
     case KEYDB_SEARCH_MODE_SHORT_KID:
       es_printf ("key %s%08lX",
                  (opt.keyid_format==KF_0xSHORT
                   || opt.keyid_format==KF_0xLONG)?"0x":"",
                  (ulong)keyrec->desc.u.kid[1]);
       break;
 
       /* However, if it gave us a long keyid, we can honor
 	 --keyid-format via keystr(). */
     case KEYDB_SEARCH_MODE_LONG_KID:
       es_printf ("key %s",keystr(keyrec->desc.u.kid));
       break;
 
     case KEYDB_SEARCH_MODE_FPR:
       {
 	u32 kid[2];
 	keyid_from_fingerprint (ctrl, keyrec->desc.u.fpr, keyrec->desc.fprlen,
                                 kid);
 	es_printf("key %s",keystr(kid));
       }
       break;
 
     default:
       BUG();
       break;
     }
 
   if(keyrec->createtime>0)
     {
       es_printf (", ");
       es_printf (_("created: %s"), strtimestamp(keyrec->createtime));
     }
 
   if(keyrec->expiretime>0)
     {
       es_printf (", ");
       es_printf (_("expires: %s"), strtimestamp(keyrec->expiretime));
     }
 
   if (keyrec->flags&1)
     es_printf (" (%s)", _("revoked"));
   if(keyrec->flags&2)
     es_printf (" (%s)", _("disabled"));
   if(keyrec->flags&4)
     es_printf (" (%s)", _("expired"));
 
   es_printf ("\n");
 }
 
 /* Returns a keyrec (which must be freed) once a key is complete, and
    NULL otherwise.  Call with a NULL keystring once key parsing is
    complete to return any unfinished keys. */
 static struct keyrec *
 parse_keyrec(char *keystring)
 {
   /* FIXME: Remove the static and put the data into the parms we use
      for the caller anyway.  */
   static struct keyrec *work=NULL;
   struct keyrec *ret=NULL;
   char *record;
   int i;
 
   if(keystring==NULL)
     {
       if(work==NULL)
 	return NULL;
       else if(work->desc.mode==KEYDB_SEARCH_MODE_NONE)
 	{
 	  xfree(work);
 	  return NULL;
 	}
       else
 	{
 	  ret=work;
 	  work=NULL;
 	  return ret;
 	}
     }
 
   if(work==NULL)
     {
       work=xmalloc_clear(sizeof(struct keyrec));
       work->uidbuf=iobuf_temp();
     }
 
   trim_trailing_ws (keystring, strlen (keystring));
 
   if((record=strsep(&keystring,":"))==NULL)
     return ret;
 
   if(ascii_strcasecmp("pub",record)==0)
     {
       char *tok;
       gpg_error_t err;
 
       if(work->desc.mode)
 	{
 	  ret=work;
 	  work=xmalloc_clear(sizeof(struct keyrec));
 	  work->uidbuf=iobuf_temp();
 	}
 
       if((tok=strsep(&keystring,":"))==NULL)
 	return ret;
 
       err = classify_user_id (tok, &work->desc, 1);
       if (err || (work->desc.mode    != KEYDB_SEARCH_MODE_SHORT_KID
                   && work->desc.mode != KEYDB_SEARCH_MODE_LONG_KID
                   && work->desc.mode != KEYDB_SEARCH_MODE_FPR))
 	{
 	  work->desc.mode=KEYDB_SEARCH_MODE_NONE;
 	  return ret;
 	}
 
       /* Note all items after this are optional.  This allows us to
          have a pub line as simple as pub:keyid and nothing else. */
 
       work->lines++;
 
       if((tok=strsep(&keystring,":"))==NULL)
 	return ret;
 
       work->type=atoi(tok);
 
       if((tok=strsep(&keystring,":"))==NULL)
 	return ret;
 
       work->size=atoi(tok);
 
       if((tok=strsep(&keystring,":"))==NULL)
 	return ret;
 
       if(atoi(tok)<=0)
 	work->createtime=0;
       else
 	work->createtime=atoi(tok);
 
       if((tok=strsep(&keystring,":"))==NULL)
 	return ret;
 
       if(atoi(tok)<=0)
 	work->expiretime=0;
       else
 	{
 	  work->expiretime=atoi(tok);
 	  /* Force the 'e' flag on if this key is expired. */
 	  if(work->expiretime<=make_timestamp())
 	    work->flags|=4;
 	}
 
       if((tok=strsep(&keystring,":"))==NULL)
 	return ret;
 
       while(*tok)
 	switch(*tok++)
 	  {
 	  case 'r':
 	  case 'R':
 	    work->flags|=1;
 	    break;
 
 	  case 'd':
 	  case 'D':
 	    work->flags|=2;
 	    break;
 
 	  case 'e':
 	  case 'E':
 	    work->flags|=4;
 	    break;
 	  }
     }
   else if(ascii_strcasecmp("uid",record)==0 && work->desc.mode)
     {
       char *userid,*tok,*decoded;
 
       if((tok=strsep(&keystring,":"))==NULL)
 	return ret;
 
       if(strlen(tok)==0)
 	return ret;
 
       userid=tok;
 
       /* By definition, de-%-encoding is always smaller than the
          original string so we can decode in place. */
 
       i=0;
 
       while(*tok)
 	if(tok[0]=='%' && tok[1] && tok[2])
 	  {
             int c;
 
 	    userid[i] = (c=hextobyte(&tok[1])) == -1 ? '?' : c;
 	    i++;
 	    tok+=3;
 	  }
 	else
 	  userid[i++]=*tok++;
 
       /* We don't care about the other info provided in the uid: line
          since no keyserver supports marking userids with timestamps
          or revoked/expired/disabled yet. */
 
       /* No need to check for control characters, as utf8_to_native
 	 does this for us. */
 
       decoded=utf8_to_native(userid,i,0);
       if(strlen(decoded)>opt.screen_columns-10)
 	decoded[opt.screen_columns-10]='\0';
       iobuf_writestr(work->uidbuf,decoded);
       xfree(decoded);
       iobuf_writestr(work->uidbuf,"\n\t");
       work->lines++;
     }
 
   /* Ignore any records other than "pri" and "uid" for easy future
      growth. */
 
   return ret;
 }
 
 /* Show a prompt and allow the user to select keys for retrieval.  */
 static gpg_error_t
 show_prompt (ctrl_t ctrl, KEYDB_SEARCH_DESC *desc, int numdesc,
              int count, const char *search)
 {
   gpg_error_t err;
   char *answer = NULL;
 
   es_fflush (es_stdout);
 
   if (count && opt.command_fd == -1)
     {
       static int from = 1;
       tty_printf ("Keys %d-%d of %d for \"%s\".  ",
                   from, numdesc, count, search);
       from = numdesc + 1;
     }
 
  again:
   err = 0;
   xfree (answer);
   answer = cpr_get_no_help ("keysearch.prompt",
                             _("Enter number(s), N)ext, or Q)uit > "));
   /* control-d */
   if (answer[0]=='\x04')
     {
       tty_printf ("Q\n");
       answer[0] = 'q';
     }
 
   if (answer[0]=='q' || answer[0]=='Q')
     err = gpg_error (GPG_ERR_CANCELED);
   else if (atoi (answer) >= 1 && atoi (answer) <= numdesc)
     {
       char *split = answer;
       char *num;
       int numarray[50];
       int numidx = 0;
       int idx;
 
       while ((num = strsep (&split, " ,")))
 	if (atoi (num) >= 1 && atoi (num) <= numdesc)
           {
             if (numidx >= DIM (numarray))
               {
                 tty_printf ("Too many keys selected\n");
                 goto again;
               }
             numarray[numidx++] = atoi (num);
           }
 
       if (!numidx)
         goto again;
 
       {
         KEYDB_SEARCH_DESC *selarray;
 
         selarray = xtrymalloc (numidx * sizeof *selarray);
         if (!selarray)
           {
             err = gpg_error_from_syserror ();
             goto leave;
           }
         for (idx = 0; idx < numidx; idx++)
           selarray[idx] = desc[numarray[idx]-1];
         err = keyserver_get (ctrl, selarray, numidx, NULL, 0, NULL, NULL);
         xfree (selarray);
       }
     }
 
  leave:
   xfree (answer);
   return err;
 }
 
 
 /* This is a callback used by call-dirmngr.c to process the result of
    KS_SEARCH command.  If SPECIAL is 0, LINE is the actual data line
    received with all escaping removed and guaranteed to be exactly one
    line with stripped LF; an EOF is indicated by LINE passed as NULL.
    If special is 1, the line contains the source of the information
    (usually an URL).  LINE may be modified after return.  */
 static gpg_error_t
 search_line_handler (void *opaque, int special, char *line)
 {
   struct search_line_handler_parm_s *parm = opaque;
   gpg_error_t err = 0;
   struct keyrec *keyrec;
 
   if (special == 1)
     {
       log_info ("data source: %s\n", line);
       return 0;
     }
   else if (special)
     {
       log_debug ("unknown value %d for special search callback", special);
       return 0;
     }
 
   if (parm->eof_seen && line)
     {
       log_debug ("ooops: unexpected data after EOF\n");
       line = NULL;
     }
 
   /* Print the received line.  */
   if (opt.with_colons && line)
     {
       es_printf ("%s\n", line);
     }
 
   /* Look for an info: line.  The only current info: values defined
      are the version and key count. */
   if (line && !parm->any_lines && !ascii_strncasecmp ("info:", line, 5))
     {
       char *str = line + 5;
       char *tok;
 
       if ((tok = strsep (&str, ":")))
         {
           int version;
 
           if (sscanf (tok, "%d", &version) !=1 )
             version = 1;
 
           if (version !=1 )
             {
               log_error (_("invalid keyserver protocol "
                            "(us %d!=handler %d)\n"), 1, version);
               return gpg_error (GPG_ERR_UNSUPPORTED_PROTOCOL);
             }
         }
 
       if ((tok = strsep (&str, ":"))
           && sscanf (tok, "%d", &parm->count) == 1)
         {
           if (!parm->count)
             parm->not_found = 1;/* Server indicated that no items follow.  */
           else if (parm->count < 0)
             parm->count = 10;   /* Bad value - assume something reasonable.  */
           else
             parm->validcount = 1; /* COUNT seems to be okay.  */
         }
 
       parm->any_lines = 1;
       return 0; /* Line processing finished.  */
     }
 
  again:
   if (line)
     keyrec = parse_keyrec (line);
   else
     {
       /* Received EOF - flush data */
       parm->eof_seen = 1;
       keyrec = parse_keyrec (NULL);
       if (!keyrec)
         {
           if (!parm->nkeys)
             parm->not_found = 1;  /* No keys at all.  */
           else
             {
               if (parm->nkeys != parm->count)
                 parm->validcount = 0;
 
               if (!(opt.with_colons && opt.batch))
                 {
                   err = show_prompt (parm->ctrl, parm->desc, parm->nkeys,
                                      parm->validcount? parm->count : 0,
                                      parm->searchstr_disp);
                   return err;
                 }
             }
         }
     }
 
   /* Save the key in the key array.  */
   if (keyrec)
     {
       /* Allocate or enlarge the key array if needed.  */
       if (!parm->desc)
         {
           if (parm->count < 1)
             {
               parm->count = 10;
               parm->validcount = 0;
             }
           parm->desc = xtrymalloc (parm->count * sizeof *parm->desc);
           if (!parm->desc)
             {
               err = gpg_error_from_syserror ();
               iobuf_close (keyrec->uidbuf);
               xfree (keyrec);
               return err;
             }
         }
       else if (parm->nkeys == parm->count)
         {
           /* Keyserver sent more keys than claimed in the info: line. */
           KEYDB_SEARCH_DESC *tmp;
           int newcount = parm->count + 10;
 
           tmp = xtryrealloc (parm->desc, newcount * sizeof *parm->desc);
           if (!tmp)
             {
               err = gpg_error_from_syserror ();
               iobuf_close (keyrec->uidbuf);
               xfree (keyrec);
               return err;
             }
           parm->count = newcount;
           parm->desc = tmp;
           parm->validcount = 0;
         }
 
       parm->desc[parm->nkeys] = keyrec->desc;
 
       if (!opt.with_colons)
         {
           /* SCREEN_LINES - 1 for the prompt. */
           if (parm->numlines + keyrec->lines > opt.screen_lines - 1)
             {
               err = show_prompt (parm->ctrl, parm->desc, parm->nkeys,
                                  parm->validcount ? parm->count:0,
                                  parm->searchstr_disp);
               if (err)
                 return err;
               parm->numlines = 0;
             }
 
           print_keyrec (parm->ctrl, parm->nkeys+1, keyrec);
         }
 
       parm->numlines += keyrec->lines;
       iobuf_close (keyrec->uidbuf);
       xfree (keyrec);
 
       parm->any_lines = 1;
       parm->nkeys++;
 
       /* If we are here due to a flush after the EOF, run again for
          the last prompt.  Fixme: Make this code better readable. */
       if (parm->eof_seen)
         goto again;
     }
 
   return 0;
 }
 
 
 
 int
 keyserver_export (ctrl_t ctrl, strlist_t users)
 {
   gpg_error_t err;
   strlist_t sl=NULL;
   KEYDB_SEARCH_DESC desc;
   int rc=0;
 
   /* Weed out descriptors that we don't support sending */
   for(;users;users=users->next)
     {
       err = classify_user_id (users->d, &desc, 1);
       if (err || (desc.mode    != KEYDB_SEARCH_MODE_SHORT_KID
                   && desc.mode != KEYDB_SEARCH_MODE_LONG_KID
                   && desc.mode != KEYDB_SEARCH_MODE_FPR))
 	{
 	  log_error(_("\"%s\" not a key ID: skipping\n"),users->d);
 	  continue;
 	}
       else
 	append_to_strlist(&sl,users->d);
     }
 
   if(sl)
     {
       rc = keyserver_put (ctrl, sl);
       free_strlist(sl);
     }
 
   return rc;
 }
 
 
 /* Structure to convey the arg to keyserver_retrieval_screener.  */
 struct ks_retrieval_screener_arg_s
 {
   KEYDB_SEARCH_DESC *desc;
   int ndesc;
 };
 
 
 /* Check whether a key matches the search description.  The function
    returns 0 if the key shall be imported.  */
 static gpg_error_t
 keyserver_retrieval_screener (kbnode_t keyblock, void *opaque)
 {
   struct ks_retrieval_screener_arg_s *arg = opaque;
   KEYDB_SEARCH_DESC *desc = arg->desc;
   int ndesc = arg->ndesc;
   kbnode_t node;
   PKT_public_key *pk;
   int n;
   u32 keyid[2];
   byte fpr[MAX_FINGERPRINT_LEN];
   size_t fpr_len = 0;
 
   /* Secret keys are not expected from a keyserver.  We do not
      care about secret subkeys because the import code takes care
      of skipping them.  Not allowing an import of a public key
      with a secret subkey would make it too easy to inhibit the
      downloading of a public key.  Recall that keyservers do only
      limited checks.  */
   node = find_kbnode (keyblock, PKT_SECRET_KEY);
   if (node)
     return gpg_error (GPG_ERR_GENERAL);   /* Do not import. */
 
   if (!ndesc)
     return 0; /* Okay if no description given.  */
 
   /* Loop over all key packets.  */
   for (node = keyblock; node; node = node->next)
     {
       if (node->pkt->pkttype != PKT_PUBLIC_KEY
           && node->pkt->pkttype != PKT_PUBLIC_SUBKEY)
         continue;
 
       pk = node->pkt->pkt.public_key;
       fingerprint_from_pk (pk, fpr, &fpr_len);
       keyid_from_pk (pk, keyid);
 
       /* Compare requested and returned fingerprints if available. */
       for (n = 0; n < ndesc; n++)
         {
           if (desc[n].mode == KEYDB_SEARCH_MODE_FPR)
             {
               if (fpr_len == desc[n].fprlen
                   && !memcmp (fpr, desc[n].u.fpr, desc[n].fprlen))
                 return 0;
             }
           else if (desc[n].mode == KEYDB_SEARCH_MODE_LONG_KID)
             {
               if (keyid[0] == desc[n].u.kid[0] && keyid[1] == desc[n].u.kid[1])
                 return 0;
             }
           else if (desc[n].mode == KEYDB_SEARCH_MODE_SHORT_KID)
             {
               if (keyid[1] == desc[n].u.kid[1])
                 return 0;
             }
           else /* No keyid or fingerprint - can't check.  */
             return 0; /* allow import.  */
         }
     }
 
   return gpg_error (GPG_ERR_GENERAL);
 }
 
 
 int
 keyserver_import (ctrl_t ctrl, strlist_t users)
 {
   gpg_error_t err;
   KEYDB_SEARCH_DESC *desc;
   int num=100,count=0;
   int rc=0;
 
   /* Build a list of key ids */
   desc=xmalloc(sizeof(KEYDB_SEARCH_DESC)*num);
 
   for(;users;users=users->next)
     {
       err = classify_user_id (users->d, &desc[count], 1);
       if (err || (desc[count].mode    != KEYDB_SEARCH_MODE_SHORT_KID
                   && desc[count].mode != KEYDB_SEARCH_MODE_LONG_KID
                   && desc[count].mode != KEYDB_SEARCH_MODE_FPR))
 	{
 	  log_error (_("\"%s\" not a key ID: skipping\n"), users->d);
 	  continue;
 	}
 
       count++;
       if(count==num)
 	{
 	  num+=100;
 	  desc=xrealloc(desc,sizeof(KEYDB_SEARCH_DESC)*num);
 	}
     }
 
   if(count>0)
     rc = keyserver_get (ctrl, desc, count, NULL, 0, NULL, NULL);
 
   xfree(desc);
 
   return rc;
 }
 
 
 /* Return true if any keyserver has been configured. */
 int
 keyserver_any_configured (ctrl_t ctrl)
 {
   return !gpg_dirmngr_ks_list (ctrl, NULL);
 }
 
 
 /* Import all keys that exactly match MBOX */
 int
 keyserver_import_mbox (ctrl_t ctrl, const char *mbox,
                        unsigned char **fpr, size_t *fprlen,
                        struct keyserver_spec *keyserver)
 {
   KEYDB_SEARCH_DESC desc = { 0 };
 
   desc.mode = KEYDB_SEARCH_MODE_MAIL;
   desc.u.name = mbox;
 
   return keyserver_get (ctrl, &desc, 1, keyserver, 0, fpr, fprlen);
 }
 
 
 /* Import the keys that match exactly MBOX */
 int
 keyserver_import_ntds (ctrl_t ctrl, const char *mbox,
                        unsigned char **fpr, size_t *fprlen)
 {
   KEYDB_SEARCH_DESC desc = { 0 };
   struct keyserver_spec keyserver = { NULL, "ldap:///" };
 
   desc.mode = KEYDB_SEARCH_MODE_MAIL;
   desc.u.name = mbox;
 
   return keyserver_get (ctrl, &desc, 1, &keyserver, 0, fpr, fprlen);
 }
 
 
 int
 keyserver_import_fprint (ctrl_t ctrl, const byte *fprint, size_t fprint_len,
 			 struct keyserver_spec *keyserver,
                          unsigned int flags)
 {
   KEYDB_SEARCH_DESC desc;
 
   memset (&desc, 0, sizeof(desc));
 
   if (fprint_len == 16 || fprint_len == 20 || fprint_len == 32)
     desc.mode = KEYDB_SEARCH_MODE_FPR;
   else
     return gpg_error (GPG_ERR_INV_ARG);
 
   memcpy (desc.u.fpr, fprint, fprint_len);
   desc.fprlen = fprint_len;
 
   return keyserver_get (ctrl, &desc, 1, keyserver, flags, NULL, NULL);
 }
 
 
 int
 keyserver_import_fprint_ntds (ctrl_t ctrl,
                               const byte *fprint, size_t fprint_len)
 {
   struct keyserver_spec keyserver = { NULL, "ldap:///" };
 
   return keyserver_import_fprint (ctrl, fprint, fprint_len,
                                   &keyserver, KEYSERVER_IMPORT_FLAG_LDAP);
 }
 
 
 int
 keyserver_import_keyid (ctrl_t ctrl,
                         u32 *keyid,struct keyserver_spec *keyserver,
                         unsigned int flags)
 {
   KEYDB_SEARCH_DESC desc;
 
   memset(&desc,0,sizeof(desc));
 
   desc.mode=KEYDB_SEARCH_MODE_LONG_KID;
   desc.u.kid[0]=keyid[0];
   desc.u.kid[1]=keyid[1];
 
   return keyserver_get (ctrl, &desc, 1, keyserver, flags, NULL, NULL);
 }
 
 
 /* code mostly stolen from do_export_stream */
 static int
 keyidlist (ctrl_t ctrl, strlist_t users, KEYDB_SEARCH_DESC **klist,
            int *count, int fakev3)
 {
   int rc = 0;
   int num = 100;
   kbnode_t keyblock = NULL;
   kbnode_t node;
   KEYDB_HANDLE kdbhd;
   int ndesc;
   KEYDB_SEARCH_DESC *desc = NULL;
   strlist_t sl;
 
   *count=0;
 
   *klist=xmalloc(sizeof(KEYDB_SEARCH_DESC)*num);
 
   kdbhd = keydb_new (ctrl);
   if (!kdbhd)
     {
       rc = gpg_error_from_syserror ();
       goto leave;
     }
   keydb_disable_caching (kdbhd);  /* We are looping the search.  */
 
   if(!users)
     {
       ndesc = 1;
       desc = xmalloc_clear ( ndesc * sizeof *desc);
       desc[0].mode = KEYDB_SEARCH_MODE_FIRST;
     }
   else
     {
       for (ndesc=0, sl=users; sl; sl = sl->next, ndesc++)
 	;
       desc = xmalloc ( ndesc * sizeof *desc);
 
       for (ndesc=0, sl=users; sl; sl = sl->next)
 	{
           gpg_error_t err;
 	  if (!(err = classify_user_id (sl->d, desc+ndesc, 1)))
 	    ndesc++;
 	  else
 	    log_error (_("key \"%s\" not found: %s\n"),
 		       sl->d, gpg_strerror (err));
 	}
     }
 
   for (;;)
     {
       rc = keydb_search (kdbhd, desc, ndesc, NULL);
       if (rc)
         break;  /* ready.  */
 
       if (!users)
 	desc[0].mode = KEYDB_SEARCH_MODE_NEXT;
 
       /* read the keyblock */
       rc = keydb_get_keyblock (kdbhd, &keyblock );
       if( rc )
 	{
           log_error (_("error reading keyblock: %s\n"), gpg_strerror (rc) );
 	  goto leave;
 	}
 
       if((node=find_kbnode(keyblock,PKT_PUBLIC_KEY)))
 	{
 	  /* This is to work around a bug in some keyservers (pksd and
              OKS) that calculate v4 RSA keyids as if they were v3 RSA.
              The answer is to refresh both the correct v4 keyid
              (e.g. 99242560) and the fake v3 keyid (e.g. 68FDDBC7).
              This only happens for key refresh using the HKP scheme
              and if the refresh-add-fake-v3-keyids keyserver option is
              set. */
 	  if(fakev3 && is_RSA(node->pkt->pkt.public_key->pubkey_algo) &&
 	     node->pkt->pkt.public_key->version>=4)
 	    {
 	      (*klist)[*count].mode=KEYDB_SEARCH_MODE_LONG_KID;
 	      v3_keyid (node->pkt->pkt.public_key->pkey[0],
                         (*klist)[*count].u.kid);
 	      (*count)++;
 
 	      if(*count==num)
 		{
 		  num+=100;
 		  *klist=xrealloc(*klist,sizeof(KEYDB_SEARCH_DESC)*num);
 		}
 	    }
 
 	  /* v4 keys get full fingerprints.  v3 keys get long keyids.
              This is because it's easy to calculate any sort of keyid
              from a v4 fingerprint, but not a v3 fingerprint. */
 
 	  if (node->pkt->pkt.public_key->version < 4)
 	    {
 	      (*klist)[*count].mode=KEYDB_SEARCH_MODE_LONG_KID;
 	      keyid_from_pk(node->pkt->pkt.public_key,
 			    (*klist)[*count].u.kid);
 	    }
 	  else
             {
 	      size_t fprlen;
 
 	      fingerprint_from_pk (node->pkt->pkt.public_key,
                                    (*klist)[*count].u.fpr, &fprlen);
               (*klist)[*count].mode = KEYDB_SEARCH_MODE_FPR;
               (*klist)[*count].fprlen = fprlen;
             }
 
 	  /* This is a little hackish, using the skipfncvalue as a
 	     void* pointer to the keyserver spec, but we don't need
 	     the skipfnc here, and it saves having an additional field
 	     for this (which would be wasted space most of the
 	     time). */
 
 	  (*klist)[*count].skipfncvalue=NULL;
 
 	  /* Are we honoring preferred keyservers? */
 	  if(opt.keyserver_options.options&KEYSERVER_HONOR_KEYSERVER_URL)
 	    {
 	      PKT_user_id *uid=NULL;
 	      PKT_signature *sig=NULL;
 
 	      merge_keys_and_selfsig (ctrl, keyblock);
 
 	      for(node=node->next;node;node=node->next)
 		{
 		  if(node->pkt->pkttype==PKT_USER_ID
 		     && node->pkt->pkt.user_id->flags.primary)
 		    uid=node->pkt->pkt.user_id;
 		  else if(node->pkt->pkttype==PKT_SIGNATURE
 			  && node->pkt->pkt.signature->
 			  flags.chosen_selfsig && uid)
 		    {
 		      sig=node->pkt->pkt.signature;
 		      break;
 		    }
 		}
 
 	      /* Try and parse the keyserver URL.  If it doesn't work,
 		 then we end up writing NULL which indicates we are
 		 the same as any other key. */
 	      if(sig)
 		(*klist)[*count].skipfncvalue=parse_preferred_keyserver(sig);
 	    }
 
 	  (*count)++;
 
 	  if(*count==num)
 	    {
 	      num+=100;
 	      *klist=xrealloc(*klist,sizeof(KEYDB_SEARCH_DESC)*num);
 	    }
 	}
     }
 
   if (gpg_err_code (rc) == GPG_ERR_NOT_FOUND)
     rc = 0;
 
  leave:
   if(rc)
     {
       xfree(*klist);
       *klist = NULL;
     }
   xfree(desc);
   keydb_release(kdbhd);
   release_kbnode(keyblock);
 
   return rc;
 }
 
 /* Note this is different than the original HKP refresh.  It allows
    usernames to refresh only part of the keyring. */
 
 gpg_error_t
 keyserver_refresh (ctrl_t ctrl, strlist_t users)
 {
   gpg_error_t err;
   int count, numdesc;
   int fakev3 = 0;
   KEYDB_SEARCH_DESC *desc;
   unsigned int options=opt.keyserver_options.import_options;
 
   /* We switch merge-only on during a refresh, as 'refresh' should
      never import new keys, even if their keyids match. */
   opt.keyserver_options.import_options|=IMPORT_MERGE_ONLY;
 
   /* Similarly, we switch on fast-import, since refresh may make
      multiple import sets (due to preferred keyserver URLs).  We don't
      want each set to rebuild the trustdb.  Instead we do it once at
      the end here. */
   opt.keyserver_options.import_options|=IMPORT_FAST;
 
   /* If refresh_add_fake_v3_keyids is on and it's a HKP or MAILTO
      scheme, then enable fake v3 keyid generation.  Note that this
      works only with a keyserver configured. gpg.conf
      (i.e. opt.keyserver); however that method of configuring a
      keyserver is deprecated and in any case it is questionable
      whether we should keep on supporting these ancient and broken
      keyservers.  */
   if((opt.keyserver_options.options&KEYSERVER_ADD_FAKE_V3) && opt.keyserver
      && (ascii_strcasecmp(opt.keyserver->scheme,"hkp")==0 ||
 	 ascii_strcasecmp(opt.keyserver->scheme,"mailto")==0))
     fakev3=1;
 
   err = keyidlist (ctrl, users, &desc, &numdesc, fakev3);
   if (err)
     return err;
 
   count=numdesc;
   if(count>0)
     {
       int i;
 
       /* Try to handle preferred keyserver keys first */
       for(i=0;i<numdesc;i++)
 	{
 	  if(desc[i].skipfncvalue)
 	    {
 	      struct keyserver_spec *keyserver=desc[i].skipfncvalue;
 
               if (!opt.quiet)
                 log_info (_("refreshing %d key from %s\n"), 1, keyserver->uri);
 
 	      /* We use the keyserver structure we parsed out before.
 		 Note that a preferred keyserver without a scheme://
 		 will be interpreted as hkp:// */
 	      err = keyserver_get (ctrl, &desc[i], 1, keyserver, 0, NULL, NULL);
 	      if (err)
 		log_info(_("WARNING: unable to refresh key %s"
 			   " via %s: %s\n"),keystr_from_desc(&desc[i]),
 			 keyserver->uri,gpg_strerror (err));
 	      else
 		{
 		  /* We got it, so mark it as NONE so we don't try and
 		     get it again from the regular keyserver. */
 
 		  desc[i].mode=KEYDB_SEARCH_MODE_NONE;
 		  count--;
 		}
 
 	      free_keyserver_spec(keyserver);
 	    }
 	}
     }
 
   if(count>0)
     {
       char *tmpuri;
 
       err = gpg_dirmngr_ks_list (ctrl, &tmpuri);
       if (!err)
         {
           if (!opt.quiet)
             {
               log_info (ngettext("refreshing %d key from %s\n",
                                  "refreshing %d keys from %s\n",
                                  count), count, tmpuri);
             }
           xfree (tmpuri);
 
           err = keyserver_get (ctrl, desc, numdesc, NULL, 0, NULL, NULL);
         }
     }
 
   xfree(desc);
 
   opt.keyserver_options.import_options=options;
 
   /* If the original options didn't have fast import, and the trustdb
      is dirty, rebuild. */
   if(!(opt.keyserver_options.import_options&IMPORT_FAST))
     check_or_update_trustdb (ctrl);
 
   return err;
 }
 
 
 /* Search for keys on the keyservers.  The patterns are given in the
    string list TOKENS.  */
 gpg_error_t
 keyserver_search (ctrl_t ctrl, strlist_t tokens)
 {
   gpg_error_t err;
   char *searchstr;
   struct search_line_handler_parm_s parm;
 
   memset (&parm, 0, sizeof parm);
 
   if (!tokens)
     return 0;  /* Return success if no patterns are given.  */
 
   /* Write global options */
 
   /* for(temp=opt.keyserver_options.other;temp;temp=temp->next) */
   /*   es_fprintf(spawn->tochild,"OPTION %s\n",temp->d); */
 
   /* Write per-keyserver options */
 
   /* for(temp=keyserver->options;temp;temp=temp->next) */
   /*   es_fprintf(spawn->tochild,"OPTION %s\n",temp->d); */
 
   {
     membuf_t mb;
     strlist_t item;
 
     init_membuf (&mb, 1024);
     for (item = tokens; item; item = item->next)
     {
       if (item != tokens)
         put_membuf (&mb, " ", 1);
       put_membuf_str (&mb, item->d);
     }
     put_membuf (&mb, "", 1); /* Append Nul.  */
     searchstr = get_membuf (&mb, NULL);
     if (!searchstr)
       {
         err = gpg_error_from_syserror ();
         goto leave;
       }
   }
   /* FIXME: Enable the next line */
   /* log_info (_("searching for \"%s\" from %s\n"), searchstr, keyserver->uri); */
 
   parm.ctrl = ctrl;
   if (searchstr)
     parm.searchstr_disp = utf8_to_native (searchstr, strlen (searchstr), 0);
 
   err = gpg_dirmngr_ks_search (ctrl, searchstr, search_line_handler, &parm);
 
   if (parm.not_found || gpg_err_code (err) == GPG_ERR_NO_DATA)
     {
       if (parm.searchstr_disp)
         log_info (_("key \"%s\" not found on keyserver\n"),
                   parm.searchstr_disp);
       else
         log_info (_("key not found on keyserver\n"));
     }
 
   if (gpg_err_code (err) == GPG_ERR_NO_DATA)
     err = gpg_error (GPG_ERR_NOT_FOUND);
   else if (err)
     log_error ("error searching keyserver: %s\n", gpg_strerror (err));
 
   /* switch(ret) */
   /*   { */
   /*   case KEYSERVER_SCHEME_NOT_FOUND: */
   /*     log_error(_("no handler for keyserver scheme '%s'\n"), */
   /*   	    opt.keyserver->scheme); */
   /*     break; */
 
   /*   case KEYSERVER_NOT_SUPPORTED: */
   /*     log_error(_("action '%s' not supported with keyserver " */
   /*   	      "scheme '%s'\n"), "search", opt.keyserver->scheme); */
   /*     break; */
 
   /*   case KEYSERVER_TIMEOUT: */
   /*     log_error(_("keyserver timed out\n")); */
   /*     break; */
 
   /*   case KEYSERVER_INTERNAL_ERROR: */
   /*   default: */
   /*     log_error(_("keyserver internal error\n")); */
   /*     break; */
   /*   } */
 
   /* return gpg_error (GPG_ERR_KEYSERVER); */
 
 
  leave:
   xfree (parm.desc);
   xfree (parm.searchstr_disp);
   xfree(searchstr);
 
   return err;
 }
 
 /* Helper for keyserver_get.  Here we only receive a chunk of the
    description to be processed in one batch.  This is required due to
    the limited number of patterns the dirmngr interface (KS_GET) can
    grok and to limit the amount of temporary required memory.  */
 static gpg_error_t
 keyserver_get_chunk (ctrl_t ctrl, KEYDB_SEARCH_DESC *desc, int ndesc,
                      int *r_ndesc_used,
                      import_stats_t stats_handle,
                      struct keyserver_spec *override_keyserver,
                      unsigned int flags,
                      unsigned char **r_fpr, size_t *r_fprlen)
 
 {
   gpg_error_t err = 0;
   char **pattern;
   int idx, npat, npat_fpr;
   estream_t datastream;
   char *source = NULL;
   size_t linelen;  /* Estimated linelen for KS_GET.  */
   size_t n;
   int only_fprs;
 
 #define MAX_KS_GET_LINELEN 950  /* Somewhat lower than the real limit.  */
 
   *r_ndesc_used = 0;
 
   /* Create an array filled with a search pattern for each key.  The
      array is delimited by a NULL entry.  */
   pattern = xtrycalloc (ndesc+1, sizeof *pattern);
   if (!pattern)
     return gpg_error_from_syserror ();
 
   /* Note that we break the loop as soon as our estimation of the to
      be used line length reaches the limit.  But we do this only if we
      have processed at least one search requests so that an overlong
      single request will be rejected only later by gpg_dirmngr_ks_get
      but we are sure that R_NDESC_USED has been updated.  This avoids
      a possible indefinite loop.  */
   linelen = 24; /* "KS_GET --quick --ldap --" */
   for (npat=npat_fpr=0, idx=0; idx < ndesc; idx++)
     {
       int quiet = 0;
 
       if (desc[idx].mode == KEYDB_SEARCH_MODE_FPR)
         {
           n = 1+2+2*desc[idx].fprlen;
           if (idx && linelen + n > MAX_KS_GET_LINELEN)
             break; /* Declare end of this chunk.  */
           linelen += n;
 
           pattern[npat] = xtrymalloc (n);
           if (!pattern[npat])
             err = gpg_error_from_syserror ();
           else
             {
               strcpy (pattern[npat], "0x");
               bin2hex (desc[idx].u.fpr, desc[idx].fprlen, pattern[npat]+2);
               npat++;
               if (desc[idx].fprlen == 20 || desc[idx].fprlen == 32)
                 npat_fpr++;
             }
         }
       else if(desc[idx].mode == KEYDB_SEARCH_MODE_LONG_KID)
         {
           n = 1+2+16;
           if (idx && linelen + n > MAX_KS_GET_LINELEN)
             break; /* Declare end of this chunk.  */
           linelen += n;
 
           pattern[npat] = xtryasprintf ("0x%08lX%08lX",
                                         (ulong)desc[idx].u.kid[0],
                                         (ulong)desc[idx].u.kid[1]);
           if (!pattern[npat])
             err = gpg_error_from_syserror ();
           else
             npat++;
         }
       else if(desc[idx].mode == KEYDB_SEARCH_MODE_SHORT_KID)
         {
           n = 1+2+8;
           if (idx && linelen + n > MAX_KS_GET_LINELEN)
             break; /* Declare end of this chunk.  */
           linelen += n;
 
           pattern[npat] = xtryasprintf ("0x%08lX", (ulong)desc[idx].u.kid[1]);
           if (!pattern[npat])
             err = gpg_error_from_syserror ();
           else
             npat++;
         }
       else if(desc[idx].mode == KEYDB_SEARCH_MODE_EXACT)
         {
           /* The Dirmngr also uses classify_user_id to detect the type
              of the search string.  By adding the '=' prefix we force
              Dirmngr's KS_GET to consider this an exact search string.
              (In gpg 1.4 and gpg 2.0 the keyserver helpers used the
              KS_GETNAME command to indicate this.)  */
 
           n = 1+1+strlen (desc[idx].u.name);
           if (idx && linelen + n > MAX_KS_GET_LINELEN)
             break; /* Declare end of this chunk.  */
           linelen += n;
 
           pattern[npat] = strconcat ("=", desc[idx].u.name, NULL);
           if (!pattern[npat])
             err = gpg_error_from_syserror ();
           else
             {
               npat++;
               quiet = 1;
             }
         }
       else if(desc[idx].mode == KEYDB_SEARCH_MODE_MAIL)
         {
           n = 1 + strlen (desc[idx].u.name) + 1 + 1;
           if (idx && linelen + n > MAX_KS_GET_LINELEN)
             break; /* Declare end of this chunk.  */
           linelen += n;
 
           if (desc[idx].u.name[0] == '<')
             pattern[npat] = xtrystrdup (desc[idx].u.name);
           else
             pattern[npat] = strconcat ("<", desc[idx].u.name, ">", NULL);
           if (!pattern[npat])
             err = gpg_error_from_syserror ();
           else
             {
               npat++;
               quiet = 1;
             }
         }
       else if (desc[idx].mode == KEYDB_SEARCH_MODE_NONE)
         continue;
       else
         BUG();
 
       if (err)
         {
           for (idx=0; idx < npat; idx++)
             xfree (pattern[idx]);
           xfree (pattern);
           return err;
         }
 
       if (!quiet && override_keyserver)
         {
           if (override_keyserver->host)
             log_info (_("requesting key %s from %s server %s\n"),
                       keystr_from_desc (&desc[idx]),
                       override_keyserver->scheme, override_keyserver->host);
           else
             log_info (_("requesting key %s from %s\n"),
                       keystr_from_desc (&desc[idx]), override_keyserver->uri);
         }
     }
 
   /* Remember how many of the search items were considered.  Note that
      this is different from NPAT.  */
   *r_ndesc_used = idx;
 
   only_fprs = (npat && npat == npat_fpr);
 
   err = gpg_dirmngr_ks_get (ctrl, pattern, override_keyserver, flags,
                             &datastream, &source);
   for (idx=0; idx < npat; idx++)
     xfree (pattern[idx]);
   xfree (pattern);
   if (opt.verbose && source)
     log_info ("data source: %s\n", source);
 
 
 
   if (!err)
     {
       struct ks_retrieval_screener_arg_s screenerarg;
       unsigned int options;
 
       /* FIXME: Check whether this comment should be moved to dirmngr.
 
          Slurp up all the key data.  In the future, it might be nice
          to look for KEY foo OUTOFBAND and FAILED indicators.  It's
          harmless to ignore them, but ignoring them does make gpg
          complain about "no valid OpenPGP data found".  One way to do
          this could be to continue parsing this line-by-line and make
          a temp iobuf for each key.  Note that we don't allow the
          import of secret keys from a keyserver.  Keyservers should
          never accept or send them but we better protect against rogue
          keyservers. */
 
       /* For LDAP servers we reset IMPORT_SELF_SIGS_ONLY and
        * IMPORT_CLEAN unless they have been set explicitly.  */
       options = (opt.keyserver_options.import_options | IMPORT_NO_SECKEY);
       if (source && (!strncmp (source, "ldap:", 5)
                      || !strncmp (source, "ldaps:", 6)))
         {
           if (!opt.flags.expl_import_self_sigs_only)
             options &= ~IMPORT_SELF_SIGS_ONLY;
           if (!opt.flags.expl_import_clean)
             options &= ~IMPORT_CLEAN;
         }
 
       screenerarg.desc = desc;
       screenerarg.ndesc = *r_ndesc_used;
       import_keys_es_stream (ctrl, datastream, stats_handle,
                              r_fpr, r_fprlen, options,
                              keyserver_retrieval_screener, &screenerarg,
                              only_fprs? KEYORG_KS : 0,
                              source);
     }
   es_fclose (datastream);
   xfree (source);
 
   return err;
 }
 
 
 /* Retrieve a key from a keyserver.  The search pattern are in
    (DESC,NDESC).  Allowed search modes are keyid, fingerprint, and
    exact searches.  OVERRIDE_KEYSERVER gives an optional override
    keyserver. If (R_FPR,R_FPRLEN) are not NULL, they may return the
    fingerprint of a single imported key.  If the FLAG bit
    KEYSERVER_IMPORT_FLAG_QUICK is set, dirmngr is advised to use a
    shorter timeout. */
 static gpg_error_t
 keyserver_get (ctrl_t ctrl, KEYDB_SEARCH_DESC *desc, int ndesc,
                struct keyserver_spec *override_keyserver, unsigned int flags,
                unsigned char **r_fpr, size_t *r_fprlen)
 {
   gpg_error_t err;
   import_stats_t stats_handle;
   int ndesc_used;
   int any_good = 0;
 
   stats_handle = import_new_stats_handle();
 
   for (;;)
     {
       err = keyserver_get_chunk (ctrl, desc, ndesc, &ndesc_used, stats_handle,
                                  override_keyserver, flags, r_fpr, r_fprlen);
       if (!err)
         any_good = 1;
       if (err || ndesc_used >= ndesc)
         break; /* Error or all processed.  */
       /* Prepare for the next chunk.  */
       desc += ndesc_used;
       ndesc -= ndesc_used;
     }
 
   if (any_good)
     import_print_stats (stats_handle);
 
   import_release_stats_handle (stats_handle);
   return err;
 }
 
 
 /* Send all keys specified by KEYSPECS to the configured keyserver.  */
 static gpg_error_t
 keyserver_put (ctrl_t ctrl, strlist_t keyspecs)
 
 {
   gpg_error_t err;
   strlist_t kspec;
   char *ksurl;
 
   if (!keyspecs)
     return 0;  /* Return success if the list is empty.  */
 
   if (gpg_dirmngr_ks_list (ctrl, &ksurl))
     {
       log_error (_("no keyserver known\n"));
       return gpg_error (GPG_ERR_NO_KEYSERVER);
     }
 
   for (kspec = keyspecs; kspec; kspec = kspec->next)
     {
       void *data;
       size_t datalen;
       kbnode_t keyblock;
 
       err = export_pubkey_buffer (ctrl, kspec->d,
                                   opt.keyserver_options.export_options,
                                   NULL, 0, NULL,
                                   &keyblock, &data, &datalen);
       if (err)
         log_error (_("skipped \"%s\": %s\n"), kspec->d, gpg_strerror (err));
       else
         {
           if (!opt.quiet)
             log_info (_("sending key %s to %s\n"),
                       keystr (keyblock->pkt->pkt.public_key->keyid),
                       ksurl?ksurl:"[?]");
 
           err = gpg_dirmngr_ks_put (ctrl, data, datalen, keyblock);
           release_kbnode (keyblock);
           xfree (data);
           if (err)
             {
               write_status_error ("keyserver_send", err);
               log_error (_("keyserver send failed: %s\n"), gpg_strerror (err));
             }
         }
     }
 
   xfree (ksurl);
 
   return err;
 
 }
 
 
 /* Loop over all URLs in STRLIST and fetch the key at that URL.  Note
    that the fetch operation ignores the configured keyservers and
    instead directly retrieves the keys.  */
 int
 keyserver_fetch (ctrl_t ctrl, strlist_t urilist, int origin)
 {
   gpg_error_t err;
   strlist_t sl;
   estream_t datastream;
   unsigned int save_options = opt.keyserver_options.import_options;
 
   /* Switch on fast-import, since fetch can handle more than one
      import and we don't want each set to rebuild the trustdb.
      Instead we do it once at the end. */
   opt.keyserver_options.import_options |= IMPORT_FAST;
 
   for (sl=urilist; sl; sl=sl->next)
     {
       if (!opt.quiet)
         log_info (_("requesting key from '%s'\n"), sl->d);
 
       err = gpg_dirmngr_ks_fetch (ctrl, sl->d, &datastream);
       if (!err)
         {
           import_stats_t stats_handle;
 
           stats_handle = import_new_stats_handle();
           import_keys_es_stream (ctrl, datastream, stats_handle, NULL, NULL,
                                  opt.keyserver_options.import_options,
                                  NULL, NULL, origin, sl->d);
 
           import_print_stats (stats_handle);
           import_release_stats_handle (stats_handle);
         }
       else
         log_info (_("WARNING: unable to fetch URI %s: %s\n"),
                   sl->d, gpg_strerror (err));
       es_fclose (datastream);
     }
 
   opt.keyserver_options.import_options = save_options;
 
   /* If the original options didn't have fast import, and the trustdb
      is dirty, rebuild. */
   if (!(opt.keyserver_options.import_options&IMPORT_FAST))
     check_or_update_trustdb (ctrl);
 
   return 0;
 }
 
 
 /* Import key in a CERT or pointed to by a CERT.  In DANE_MODE fetch
    the certificate using the DANE method.  */
 int
 keyserver_import_cert (ctrl_t ctrl, const char *name, int dane_mode,
                        unsigned char **fpr,size_t *fpr_len)
 {
   gpg_error_t err;
   char *look,*url;
   estream_t key;
 
   look = xstrdup(name);
 
   if (!dane_mode)
     {
       char *domain = strrchr (look,'@');
       if (domain)
         *domain='.';
     }
 
   err = gpg_dirmngr_dns_cert (ctrl, look, dane_mode? NULL : "*",
                               &key, fpr, fpr_len, &url);
   if (err)
     ;
   else if (key)
     {
       int armor_status=opt.no_armor;
       import_filter_t save_filt;
 
       /* CERTs and DANE records are always in binary format */
       opt.no_armor=1;
       if (dane_mode)
         {
           save_filt = save_and_clear_import_filter ();
           if (!save_filt)
             err = gpg_error_from_syserror ();
           else
             {
               char *filtstr = es_bsprintf ("keep-uid=mbox = %s", look);
               err = filtstr? 0 : gpg_error_from_syserror ();
               if (!err)
                 err = parse_and_set_import_filter (filtstr);
               xfree (filtstr);
               if (!err)
                 err = import_keys_es_stream (ctrl, key, NULL, fpr, fpr_len,
                                              IMPORT_NO_SECKEY,
                                              NULL, NULL, KEYORG_DANE, NULL);
               restore_import_filter (save_filt);
             }
         }
       else
         {
           err = import_keys_es_stream (ctrl, key, NULL, fpr, fpr_len,
                                        (opt.keyserver_options.import_options
                                         | IMPORT_NO_SECKEY),
                                        NULL, NULL, 0, NULL);
         }
 
       opt.no_armor=armor_status;
 
       es_fclose (key);
       key = NULL;
     }
   else if (*fpr)
     {
       /* We only consider the IPGP type if a fingerprint was provided.
 	 This lets us select the right key regardless of what a URL
 	 points to, or get the key from a keyserver. */
       if(url)
 	{
 	  struct keyserver_spec *spec;
 
 	  spec = parse_keyserver_uri (url, 1);
 	  if(spec)
 	    {
 	      err = keyserver_import_fprint (ctrl, *fpr, *fpr_len, spec, 0);
 	      free_keyserver_spec(spec);
 	    }
 	}
       else if (keyserver_any_configured (ctrl))
 	{
 	  /* If only a fingerprint is provided, try and fetch it from
 	     the configured keyserver. */
 
 	  err = keyserver_import_fprint (ctrl,
                                          *fpr, *fpr_len, opt.keyserver, 0);
 	}
       else
 	log_info(_("no keyserver known\n"));
 
       /* Give a better string here? "CERT fingerprint for \"%s\"
 	 found, but no keyserver" " known (use option
 	 --keyserver)\n" ? */
 
     }
 
   xfree(url);
   xfree(look);
 
   return err;
 }
 
 
 /* Import a key using the Web Key Directory protocol.  */
 gpg_error_t
 keyserver_import_wkd (ctrl_t ctrl, const char *name, unsigned int flags,
                       unsigned char **fpr, size_t *fpr_len)
 {
   gpg_error_t err;
   char *mbox;
   estream_t key;
   char *url = NULL;
 
   /* We want to work on the mbox.  That is what dirmngr will do anyway
    * and we need the mbox for the import filter anyway.  */
   mbox = mailbox_from_userid (name, 0);
   if (!mbox)
     {
       err = gpg_error_from_syserror ();
       if (gpg_err_code (err) == GPG_ERR_EINVAL)
         err = gpg_error (GPG_ERR_INV_USER_ID);
       return err;
     }
 
   err = gpg_dirmngr_wkd_get (ctrl, mbox, flags, &key, &url);
   if (err)
     ;
   else if (key)
     {
       int armor_status = opt.no_armor;
       import_filter_t save_filt;
 
       /* Keys returned via WKD are in binary format.  However, we
        * relax that requirement and allow also for armored data.  */
       opt.no_armor = 0;
       save_filt = save_and_clear_import_filter ();
       if (!save_filt)
         err = gpg_error_from_syserror ();
       else
         {
           char *filtstr = es_bsprintf ("keep-uid=mbox = %s", mbox);
           err = filtstr? 0 : gpg_error_from_syserror ();
           if (!err)
             err = parse_and_set_import_filter (filtstr);
           xfree (filtstr);
           if (!err)
             err = import_keys_es_stream (ctrl, key, NULL, fpr, fpr_len,
                                          IMPORT_NO_SECKEY,
                                          NULL, NULL, KEYORG_WKD, url);
 
         }
 
       restore_import_filter (save_filt);
       opt.no_armor = armor_status;
 
       es_fclose (key);
       key = NULL;
     }
 
   xfree (url);
   xfree (mbox);
   return err;
 }
 
 
 /* Import a key by name using LDAP */
 int
 keyserver_import_ldap (ctrl_t ctrl,
                        const char *name, unsigned char **fpr, size_t *fprlen)
 {
   (void)ctrl;
   (void)name;
   (void)fpr;
   (void)fprlen;
   return gpg_error (GPG_ERR_NOT_IMPLEMENTED); /*FIXME*/
 #if 0
   char *domain;
   struct keyserver_spec *keyserver;
   strlist_t list=NULL;
   int rc,hostlen=1;
   struct srventry *srvlist=NULL;
   int srvcount,i;
   char srvname[MAXDNAME];
 
   /* Parse out the domain */
   domain=strrchr(name,'@');
   if(!domain)
     return GPG_ERR_GENERAL;
 
   domain++;
 
   keyserver=xmalloc_clear(sizeof(struct keyserver_spec));
   keyserver->scheme=xstrdup("ldap");
   keyserver->host=xmalloc(1);
   keyserver->host[0]='\0';
 
   snprintf(srvname,MAXDNAME,"_pgpkey-ldap._tcp.%s",domain);
 
   FIXME("network related - move to dirmngr or drop the code");
   srvcount=getsrv(srvname,&srvlist);
 
   for(i=0;i<srvcount;i++)
     {
       hostlen+=strlen(srvlist[i].target)+1;
       keyserver->host=xrealloc(keyserver->host,hostlen);
 
       strcat(keyserver->host,srvlist[i].target);
 
       if(srvlist[i].port!=389)
 	{
 	  char port[7];
 
 	  hostlen+=6; /* a colon, plus 5 digits (unsigned 16-bit value) */
 	  keyserver->host=xrealloc(keyserver->host,hostlen);
 
 	  snprintf(port,7,":%u",srvlist[i].port);
 	  strcat(keyserver->host,port);
 	}
 
       strcat(keyserver->host," ");
     }
 
   free(srvlist);
 
   /* If all else fails, do the PGP Universal trick of
      ldap://keys.(domain) */
 
   hostlen+=5+strlen(domain);
   keyserver->host=xrealloc(keyserver->host,hostlen);
   strcat(keyserver->host,"keys.");
   strcat(keyserver->host,domain);
 
   append_to_strlist(&list,name);
 
   rc = gpg_error (GPG_ERR_NOT_IMPLEMENTED); /*FIXME*/
        /* keyserver_work (ctrl, KS_GETNAME, list, NULL, */
        /*                 0, fpr, fpr_len, keyserver); */
 
   free_strlist(list);
 
   free_keyserver_spec(keyserver);
 
   return rc;
 #endif
 }
diff --git a/g10/revoke.c b/g10/revoke.c
index c0a003b6f..d6cbf93cb 100644
--- a/g10/revoke.c
+++ b/g10/revoke.c
@@ -1,909 +1,913 @@
 /* revoke.c - Create recovation certificates.
  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003,
  *               2004 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 <ctype.h>
 
 #include "gpg.h"
 #include "options.h"
 #include "packet.h"
 #include "../common/status.h"
 #include "keydb.h"
 #include "../common/util.h"
 #include "main.h"
 #include "../common/ttyio.h"
 #include "../common/i18n.h"
 #include "call-agent.h"
 
 struct revocation_reason_info {
     int code;
     char *desc;
 };
 
 
 int
 revocation_reason_build_cb( PKT_signature *sig, void *opaque )
 {
     struct revocation_reason_info *reason = opaque;
     char *ud = NULL;
     byte *buffer;
     size_t buflen = 1;
 
     if(!reason)
       return 0;
 
     if( reason->desc ) {
 	ud = native_to_utf8( reason->desc );
 	buflen += strlen(ud);
     }
     buffer = xmalloc( buflen );
     *buffer = reason->code;
     if( ud ) {
 	memcpy(buffer+1, ud, strlen(ud) );
 	xfree( ud );
     }
 
     build_sig_subpkt( sig, SIGSUBPKT_REVOC_REASON, buffer, buflen );
     xfree( buffer );
     return 0;
 }
 
 /* Outputs a minimal pk (as defined by 2440) from a keyblock.  A
    minimal pk consists of the public key packet and a user ID.  We try
    and pick a user ID that has a uid signature, and include it if
    possible. */
 static int
 export_minimal_pk(IOBUF out,KBNODE keyblock,
 		  PKT_signature *revsig,PKT_signature *revkey)
 {
   KBNODE node;
   PACKET pkt;
   PKT_user_id *uid=NULL;
   PKT_signature *selfsig=NULL;
   u32 keyid[2];
   int rc;
 
   node=find_kbnode(keyblock,PKT_PUBLIC_KEY);
   if(!node)
     {
       log_error("key incomplete\n");
       return GPG_ERR_GENERAL;
     }
 
   keyid_from_pk(node->pkt->pkt.public_key,keyid);
 
   pkt=*node->pkt;
   rc=build_packet(out,&pkt);
   if(rc)
     {
       log_error(_("build_packet failed: %s\n"), gpg_strerror (rc) );
       return rc;
     }
 
   init_packet(&pkt);
   pkt.pkttype=PKT_SIGNATURE;
 
   /* the revocation itself, if any.  2440 likes this to come first. */
   if(revsig)
     {
       pkt.pkt.signature=revsig;
       rc=build_packet(out,&pkt);
       if(rc)
 	{
 	  log_error("build_packet failed: %s\n", gpg_strerror (rc) );
 	  return rc;
 	}
     }
 
   /* If a revkey in a 1F sig is present, include it too */
   if(revkey)
     {
       pkt.pkt.signature=revkey;
       rc=build_packet(out,&pkt);
       if(rc)
 	{
 	  log_error(_("build_packet failed: %s\n"), gpg_strerror (rc) );
 	  return rc;
 	}
     }
 
   while(!selfsig)
     {
       KBNODE signode;
 
       node=find_next_kbnode(node,PKT_USER_ID);
       if(!node)
 	{
 	  /* We're out of user IDs - none were self-signed. */
 	  if(uid)
 	    break;
 	  else
 	    {
 	      log_error(_("key %s has no user IDs\n"),keystr(keyid));
 	      return GPG_ERR_GENERAL;
 	    }
 	}
 
       if(node->pkt->pkt.user_id->attrib_data)
 	continue;
 
       uid=node->pkt->pkt.user_id;
       signode=node;
 
       while((signode=find_next_kbnode(signode,PKT_SIGNATURE)))
 	{
 	  if(keyid[0]==signode->pkt->pkt.signature->keyid[0] &&
 	     keyid[1]==signode->pkt->pkt.signature->keyid[1] &&
 	     IS_UID_SIG(signode->pkt->pkt.signature))
 	    {
 	      selfsig=signode->pkt->pkt.signature;
 	      break;
 	    }
 	}
     }
 
   pkt.pkttype=PKT_USER_ID;
   pkt.pkt.user_id=uid;
 
   rc=build_packet(out,&pkt);
   if(rc)
     {
       log_error(_("build_packet failed: %s\n"), gpg_strerror (rc) );
       return rc;
     }
 
   if(selfsig)
     {
       pkt.pkttype=PKT_SIGNATURE;
       pkt.pkt.signature=selfsig;
 
       rc=build_packet(out,&pkt);
       if(rc)
 	{
 	  log_error(_("build_packet failed: %s\n"), gpg_strerror (rc) );
 	  return rc;
 	}
     }
 
   return 0;
 }
 
 /****************
  * Generate a revocation certificate for UNAME via a designated revoker
  */
 int
 gen_desig_revoke (ctrl_t ctrl, const char *uname, strlist_t locusr)
 {
     int rc = 0;
     armor_filter_context_t *afx;
     PKT_public_key *pk = NULL;
     PKT_public_key *pk2 = NULL;
     PKT_signature *sig = NULL;
     IOBUF out = NULL;
     struct revocation_reason_info *reason = NULL;
     KEYDB_HANDLE kdbhd;
     KEYDB_SEARCH_DESC desc;
     KBNODE keyblock=NULL,node;
     u32 keyid[2];
     int i,any=0;
     SK_LIST sk_list=NULL;
 
     if( opt.batch )
       {
 	log_error(_("can't do this in batch mode\n"));
 	return GPG_ERR_GENERAL;
       }
 
     afx = new_armor_context ();
 
     kdbhd = keydb_new (ctrl);
     if (!kdbhd)
       {
         rc = gpg_error_from_syserror ();
         goto leave;
       }
     rc = classify_user_id (uname, &desc, 1);
     if (!rc)
       rc = keydb_search (kdbhd, &desc, 1, NULL);
     if (rc) {
 	log_error (_("key \"%s\" not found: %s\n"),uname, gpg_strerror (rc));
 	goto leave;
     }
 
     rc = keydb_get_keyblock (kdbhd, &keyblock );
     if( rc ) {
 	log_error (_("error reading keyblock: %s\n"), gpg_strerror (rc) );
 	goto leave;
     }
 
     /* To parse the revkeys */
     merge_keys_and_selfsig (ctrl, keyblock);
 
     /* get the key from the keyblock */
     node = find_kbnode( keyblock, PKT_PUBLIC_KEY );
     if( !node )
       BUG ();
 
     pk=node->pkt->pkt.public_key;
 
     keyid_from_pk(pk,keyid);
 
     if(locusr)
       {
 	rc = build_sk_list (ctrl, locusr, &sk_list, PUBKEY_USAGE_CERT);
 	if(rc)
 	  goto leave;
       }
 
     /* Are we a designated revoker for this key? */
 
     if(!pk->revkey && pk->numrevkeys)
       BUG();
 
     for(i=0;i<pk->numrevkeys;i++)
       {
 	SK_LIST list;
 
         free_public_key (pk2);
         pk2 = NULL;
 
 	if(sk_list)
 	  {
 	    for(list=sk_list;list;list=list->next)
 	      {
 		byte fpr[MAX_FINGERPRINT_LEN];
 		size_t fprlen;
 
 		fingerprint_from_pk (list->pk, fpr, &fprlen);
 
 		/* Don't get involved with keys that don't have a v4
 		 * or v5 fingerprint */
 		if (fprlen != 20 && fprlen != 32)
 		  continue;
 
 		if (!memcmp(fpr,pk->revkey[i].fpr, fprlen))
 		  break;
 	      }
 
 	    if (list)
 	      pk2 = copy_public_key (NULL, list->pk);
 	    else
 	      continue;
 	  }
 	else
 	  {
 	    pk2 = xmalloc_clear (sizeof *pk2);
 	    rc = get_pubkey_byfprint (ctrl, pk2, NULL,
                                       pk->revkey[i].fpr, pk->revkey[i].fprlen);
 	  }
 
 	/* We have the revocation key.  */
 	if(!rc)
 	  {
 	    PKT_signature *revkey = NULL;
 
 	    any = 1;
 
             print_key_info (ctrl, NULL, 0, pk, 0);
 	    tty_printf ("\n");
 
 	    tty_printf (_("To be revoked by:\n"));
             print_key_info (ctrl, NULL, 0, pk2, 1);
 
 	    if(pk->revkey[i].class&0x40)
 	      tty_printf(_("(This is a sensitive revocation key)\n"));
 	    tty_printf("\n");
 
 	    if (!agent_probe_secret_key (ctrl, pk2))
 	      {
 		tty_printf (_("Secret key is not available.\n"));
 		continue;
 	      }
 
 	    if( !cpr_get_answer_is_yes("gen_desig_revoke.okay",
          _("Create a designated revocation certificate for this key? (y/N) ")))
 	      continue;
 
 	    /* get the reason for the revocation (this is always v4) */
 	    reason = ask_revocation_reason( 1, 0, 1 );
 	    if( !reason )
 	      continue;
 
 	    if( !opt.armor )
 	      tty_printf(_("ASCII armored output forced.\n"));
 
 	    if( (rc = open_outfile (-1, NULL, 0, 1, &out )) )
 	      goto leave;
 
 	    afx->what = 1;
 	    afx->hdrlines = "Comment: A designated revocation certificate"
 	      " should follow\n";
 	    push_armor_filter (afx, out);
 
 	    /* create it */
 	    rc = make_keysig_packet (ctrl, &sig, pk, NULL, NULL, pk2, 0x20,
 				     0, 0,
 				     revocation_reason_build_cb, reason,
                                      NULL);
 	    if( rc ) {
 	      log_error(_("make_keysig_packet failed: %s\n"), gpg_strerror (rc));
 	      goto leave;
 	    }
 
 	    /* Spit out a minimal pk as well, since otherwise there is
                no way to know which key to attach this revocation to.
                Also include the direct key signature that contains
                this revocation key.  We're allowed to include
                sensitive revocation keys along with a revocation, as
                this may be the only time the recipient has seen it.
                Note that this means that if we have multiple different
                sensitive revocation keys in a given direct key
                signature, we're going to include them all here.  This
                is annoying, but the good outweighs the bad, since
                without including this a sensitive revoker can't really
                do their job.  People should not include multiple
                sensitive revocation keys in one signature: 2440 says
                "Note that it may be appropriate to isolate this
                subpacket within a separate signature so that it is not
                combined with other subpackets that need to be
                exported." -dms */
 
 	    while(!revkey)
 	      {
 		KBNODE signode;
 
 		signode=find_next_kbnode(node,PKT_SIGNATURE);
 		if(!signode)
 		  break;
 
 		node=signode;
 
 		if(keyid[0]==signode->pkt->pkt.signature->keyid[0] &&
 		   keyid[1]==signode->pkt->pkt.signature->keyid[1] &&
 		   IS_KEY_SIG(signode->pkt->pkt.signature))
 		  {
 		    int j;
 
 		    for(j=0;j<signode->pkt->pkt.signature->numrevkeys;j++)
 		      {
 			if (pk->revkey[i].class
                                == signode->pkt->pkt.signature->revkey[j].class
                             && pk->revkey[i].algid
                                 == signode->pkt->pkt.signature->revkey[j].algid
                             && pk->revkey[i].fprlen
                                == signode->pkt->pkt.signature->revkey[j].fprlen
                             && !memcmp
                                  (pk->revkey[i].fpr,
                                   signode->pkt->pkt.signature->revkey[j].fpr,
                                   pk->revkey[i].fprlen))
 			  {
 			    revkey = signode->pkt->pkt.signature;
 			    break;
 			  }
 		      }
 		  }
 	      }
 
 	    if(!revkey)
 	      BUG();
 
 	    rc=export_minimal_pk(out,keyblock,sig,revkey);
 	    if(rc)
 	      goto leave;
 
 	    /* and issue a usage notice */
 	    tty_printf(_("Revocation certificate created.\n"));
 	    break;
 	  }
       }
 
     if(!any)
       log_error(_("no revocation keys found for \"%s\"\n"),uname);
 
   leave:
     free_public_key (pk);
     free_public_key (pk2);
     if( sig )
 	free_seckey_enc( sig );
 
     release_sk_list(sk_list);
 
     if( rc )
 	iobuf_cancel(out);
     else
 	iobuf_close(out);
     release_revocation_reason_info( reason );
     release_armor_context (afx);
+    keydb_release (kdbhd);
     return rc;
 }
 
 
 /* Common core to create the revocation. FILENAME may be NULL to write
    to stdout or the filename given by --output.  REASON describes the
    revocation reason.  PSK is the public primary key - we expect that
    a corresponding secret key is available.  KEYBLOCK is the entire
    KEYBLOCK which is used in PGP mode to write a minimal key and not
    just the naked revocation signature; it may be NULL.  If LEADINTEXT
    is not NULL, it is written right before the (armored) output.*/
 static int
 create_revocation (ctrl_t ctrl,
                    const char *filename,
                    struct revocation_reason_info *reason,
                    PKT_public_key *psk,
                    kbnode_t keyblock,
                    const char *leadintext, int suffix,
                    const char *cache_nonce)
 {
   int rc;
   iobuf_t out = NULL;
   armor_filter_context_t *afx;
   PKT_signature *sig = NULL;
   PACKET pkt;
 
   afx = new_armor_context ();
 
   if ((rc = open_outfile (-1, filename, suffix, 1, &out)))
     goto leave;
 
   if (leadintext )
     iobuf_writestr (out, leadintext);
 
   afx->what = 1;
   afx->hdrlines = "Comment: This is a revocation certificate\n";
   push_armor_filter (afx, out);
 
   rc = make_keysig_packet (ctrl, &sig, psk, NULL, NULL, psk, 0x20,
                            0, 0,
                            revocation_reason_build_cb, reason, cache_nonce);
   if (rc)
     {
       log_error (_("make_keysig_packet failed: %s\n"), gpg_strerror (rc));
       goto leave;
     }
 
   if (keyblock && (PGP7 || PGP8))
     {
       /* Use a minimal pk for PGPx mode, since PGP can't import bare
          revocation certificates. */
       rc = export_minimal_pk (out, keyblock, sig, NULL);
       if (rc)
         goto leave;
     }
   else
     {
       init_packet (&pkt);
       pkt.pkttype = PKT_SIGNATURE;
       pkt.pkt.signature = sig;
 
       rc = build_packet (out, &pkt);
       if (rc)
         {
           log_error (_("build_packet failed: %s\n"), gpg_strerror (rc));
           goto leave;
         }
     }
 
  leave:
   if (sig)
     free_seckey_enc (sig);
   if (rc)
     iobuf_cancel (out);
   else
     iobuf_close (out);
   release_armor_context (afx);
   return rc;
 }
 
 
 /* This function is used to generate a standard revocation certificate
    by gpg's interactive key generation function.  The certificate is
    stored at a dedicated place in a slightly modified form to avoid an
    accidental import.  PSK is the primary key; a corresponding secret
    key must be available.  CACHE_NONCE is optional but can be used to
    help gpg-agent to avoid an extra passphrase prompt. */
 int
 gen_standard_revoke (ctrl_t ctrl, PKT_public_key *psk, const char *cache_nonce)
 {
   int rc;
   estream_t memfp;
   struct revocation_reason_info reason;
   char *dir, *tmpstr, *fname;
   void *leadin;
   size_t len;
   u32 keyid[2];
   int kl;
   char *orig_codeset;
   char *old_outfile;
 
   dir = get_openpgp_revocdir (gnupg_homedir ());
   tmpstr = hexfingerprint (psk, NULL, 0);
   if (!tmpstr)
     {
       rc = gpg_error_from_syserror ();
       xfree (dir);
       return rc;
     }
   fname = strconcat (dir, DIRSEP_S, tmpstr, NULL);
   if (!fname)
     {
       rc = gpg_error_from_syserror ();
       xfree (tmpstr);
       xfree (dir);
       return rc;
     }
   xfree (tmpstr);
   xfree (dir);
 
   keyid_from_pk (psk, keyid);
 
   memfp = es_fopenmem (0, "r+");
   if (!memfp)
     log_fatal ("error creating memory stream\n");
 
   orig_codeset = i18n_switchto_utf8 ();
 
   es_fprintf (memfp, "%s\n\n",
               _("This is a revocation certificate for the OpenPGP key:"));
 
   print_key_line (ctrl, memfp, psk, 0);
 
   if (opt.keyid_format != KF_NONE)
     print_fingerprint (ctrl, memfp, psk, 3);
 
   kl = opt.keyid_format == KF_NONE? 0 : keystrlen ();
 
   tmpstr = get_user_id (ctrl, keyid, &len, NULL);
   es_fprintf (memfp, "uid%*s%.*s\n\n",
               kl + 10, "",
               (int)len, tmpstr);
   xfree (tmpstr);
 
   es_fprintf (memfp, "%s\n\n%s\n\n%s\n\n:",
      _("A revocation certificate is a kind of \"kill switch\" to publicly\n"
        "declare that a key shall not anymore be used.  It is not possible\n"
        "to retract such a revocation certificate once it has been published."),
      _("Use it to revoke this key in case of a compromise or loss of\n"
        "the secret key.  However, if the secret key is still accessible,\n"
        "it is better to generate a new revocation certificate and give\n"
        "a reason for the revocation.  For details see the description of\n"
        "of the gpg command \"--generate-revocation\" in the "
        "GnuPG manual."),
      _("To avoid an accidental use of this file, a colon has been inserted\n"
        "before the 5 dashes below.  Remove this colon with a text editor\n"
        "before importing and publishing this revocation certificate."));
 
   es_putc (0, memfp);
 
   i18n_switchback (orig_codeset);
 
   if (es_fclose_snatch (memfp, &leadin, NULL))
     log_fatal ("error snatching memory stream\n");
 
   reason.code = 0x00; /* No particular reason.  */
   reason.desc = NULL;
   old_outfile = opt.outfile;
   opt.outfile = NULL;
   rc = create_revocation (ctrl,
                           fname, &reason, psk, NULL, leadin, 3, cache_nonce);
   opt.outfile = old_outfile;
   if (!rc && !opt.quiet)
     log_info (_("revocation certificate stored as '%s.rev'\n"), fname);
 
   xfree (leadin);
   xfree (fname);
 
   return rc;
 }
 
 
 
 /****************
  * Generate a revocation certificate for UNAME
  */
 int
 gen_revoke (ctrl_t ctrl, const char *uname)
 {
   int rc = 0;
   PKT_public_key *psk;
   u32 keyid[2];
   kbnode_t keyblock = NULL;
   kbnode_t node;
   KEYDB_HANDLE kdbhd;
   struct revocation_reason_info *reason = NULL;
   KEYDB_SEARCH_DESC desc;
 
   if( opt.batch )
     {
       log_error(_("can't do this in batch mode\n"));
       return GPG_ERR_GENERAL;
     }
 
   /* Search the userid; we don't want the whole getkey stuff here.  */
   kdbhd = keydb_new (ctrl);
   if (!kdbhd)
     {
       rc = gpg_error_from_syserror ();
       goto leave;
     }
   rc = classify_user_id (uname, &desc, 1);
   if (!rc)
     rc = keydb_search (kdbhd, &desc, 1, NULL);
   if (rc)
     {
       if (gpg_err_code (rc) == GPG_ERR_NOT_FOUND)
         log_error (_("secret key \"%s\" not found\n"), uname);
       else
         log_error (_("secret key \"%s\" not found: %s\n"),
                    uname, gpg_strerror (rc));
       goto leave;
     }
 
   rc = keydb_get_keyblock (kdbhd, &keyblock );
   if (rc)
     {
       log_error (_("error reading keyblock: %s\n"), gpg_strerror (rc) );
       goto leave;
     }
 
   rc = keydb_search (kdbhd, &desc, 1, NULL);
   if (gpg_err_code (rc) == GPG_ERR_NOT_FOUND)
     {
       /* Not ambiguous.  */
     }
   else if (rc == 0)
     {
       /* Ambiguous.  */
       /* TRANSLATORS: The %s prints a key specification which
          for example has been given at the command line.  Several lines
          lines with secret key infos are printed after this message.  */
       log_error (_("'%s' matches multiple secret keys:\n"), uname);
 
       print_key_info_log (ctrl, GPGRT_LOGLVL_ERROR, 2,
                           keyblock->pkt->pkt.public_key, 1);
       release_kbnode (keyblock);
 
       rc = keydb_get_keyblock (kdbhd, &keyblock);
       while (! rc)
         {
           print_key_info_log (ctrl, GPGRT_LOGLVL_INFO, 2,
                               keyblock->pkt->pkt.public_key, 1);
           release_kbnode (keyblock);
           keyblock = NULL;
 
           rc = keydb_search (kdbhd, &desc, 1, NULL);
           if (! rc)
             rc = keydb_get_keyblock (kdbhd, &keyblock);
         }
 
       rc = GPG_ERR_AMBIGUOUS_NAME;
 
       goto leave;
     }
   else
     {
       log_error (_("error searching the keyring: %s\n"), gpg_strerror (rc));
       goto leave;
     }
 
   /* Get the keyid from the keyblock.  */
   node = find_kbnode (keyblock, PKT_PUBLIC_KEY);
   if (!node)
     BUG ();
 
   psk = node->pkt->pkt.public_key;
   if (!agent_probe_secret_key (NULL, psk))
     {
       rc = gpg_error (GPG_ERR_NO_SECKEY);
       log_error (_("secret key \"%s\" not found: %s\n"),
                  uname, gpg_strerror (rc));
       goto leave;
     }
 
   keyid_from_pk (psk, keyid );
   print_key_info (ctrl, NULL, 0, psk, 1);
 
   tty_printf("\n");
   if (!cpr_get_answer_is_yes ("gen_revoke.okay",
                 _("Create a revocation certificate for this key? (y/N) ")))
     {
       rc = 0;
       goto leave;
     }
 
   /* Get the reason for the revocation.  */
   reason = ask_revocation_reason (1, 0, 1);
   if (!reason)
     {
       /* User decided to cancel.  */
       rc = 0;
       goto leave;
     }
 
   if (!opt.armor)
     tty_printf (_("ASCII armored output forced.\n"));
 
   rc = create_revocation (ctrl, NULL, reason, psk, keyblock, NULL, 0, NULL);
   if (rc)
     goto leave;
 
   /* and issue a usage notice */
   tty_printf (_(
 "Revocation certificate created.\n\n"
 "Please move it to a medium which you can hide away; if Mallory gets\n"
 "access to this certificate he can use it to make your key unusable.\n"
 "It is smart to print this certificate and store it away, just in case\n"
 "your media become unreadable.  But have some caution:  The print system of\n"
 "your machine might store the data and make it available to others!\n"));
 
  leave:
   release_kbnode (keyblock);
   keydb_release (kdbhd);
   release_revocation_reason_info( reason );
   return rc;
 }
 
 
 
 struct revocation_reason_info *
 ask_revocation_reason( int key_rev, int cert_rev, int hint )
 {
     int code=-1;
     char *description = NULL;
     struct revocation_reason_info *reason;
     const char *text_0 = _("No reason specified");
     const char *text_1 = _("Key has been compromised");
     const char *text_2 = _("Key is superseded");
     const char *text_3 = _("Key is no longer used");
     const char *text_4 = _("User ID is no longer valid");
     const char *code_text = NULL;
 
     do {
         code=-1;
 	xfree(description);
 	description = NULL;
 
 	tty_printf(_("Please select the reason for the revocation:\n"));
 	tty_printf(    "  0 = %s\n", text_0 );
 	if( key_rev )
 	    tty_printf("  1 = %s\n", text_1 );
 	if( key_rev )
 	    tty_printf("  2 = %s\n", text_2 );
 	if( key_rev )
 	    tty_printf("  3 = %s\n", text_3 );
 	if( cert_rev )
 	    tty_printf("  4 = %s\n", text_4 );
 	tty_printf(    "  Q = %s\n", _("Cancel") );
 	if( hint )
 	    tty_printf(_("(Probably you want to select %d here)\n"), hint );
 
 	while(code==-1) {
 	    int n;
 	    char *answer = cpr_get("ask_revocation_reason.code",
 						_("Your decision? "));
 	    trim_spaces( answer );
 	    cpr_kill_prompt();
 	    if( *answer == 'q' || *answer == 'Q')
-	      return NULL; /* cancel */
+              {
+                xfree (answer);
+                return NULL; /* cancel */
+              }
 	    if( hint && !*answer )
 		n = hint;
 	    else if(!digitp( answer ) )
  	        n = -1;
 	    else
 		n = atoi(answer);
 	    xfree(answer);
 	    if( n == 0 ) {
 	        code = 0x00; /* no particular reason */
 		code_text = text_0;
 	    }
 	    else if( key_rev && n == 1 ) {
 		code = 0x02; /* key has been compromised */
 		code_text = text_1;
 	    }
 	    else if( key_rev && n == 2 ) {
 		code = 0x01; /* key is superseded */
 		code_text = text_2;
 	    }
 	    else if( key_rev && n == 3 ) {
 		code = 0x03; /* key is no longer used */
 		code_text = text_3;
 	    }
 	    else if( cert_rev && n == 4 ) {
 		code = 0x20; /* uid is no longer valid */
 		code_text = text_4;
 	    }
 	    else
 		tty_printf(_("Invalid selection.\n"));
 	}
 
 	tty_printf(_("Enter an optional description; "
 		     "end it with an empty line:\n") );
 	for(;;) {
 	    char *answer = cpr_get("ask_revocation_reason.text", "> " );
 	    trim_trailing_ws( answer, strlen(answer) );
 	    cpr_kill_prompt();
 	    if( !*answer ) {
 		xfree(answer);
 		break;
 	    }
 
 	    {
 		char *p = make_printable_string( answer, strlen(answer), 0 );
 		xfree(answer);
 		answer = p;
 	    }
 
 	    if( !description )
 		description = xstrdup(answer);
 	    else {
 		char *p = xmalloc( strlen(description) + strlen(answer) + 2 );
 		strcpy(stpcpy(stpcpy( p, description),"\n"),answer);
 		xfree(description);
 		description = p;
 	    }
 	    xfree(answer);
 	}
 
 	tty_printf(_("Reason for revocation: %s\n"), code_text );
 	if( !description )
 	    tty_printf(_("(No description given)\n") );
 	else
 	    tty_printf("%s\n", description );
 
     } while( !cpr_get_answer_is_yes("ask_revocation_reason.okay",
 					    _("Is this okay? (y/N) "))  );
 
     reason = xmalloc( sizeof *reason );
     reason->code = code;
     reason->desc = description;
     return reason;
 }
 
 struct revocation_reason_info *
 get_default_uid_revocation_reason(void)
 {
   struct revocation_reason_info *reason;
   reason = xmalloc( sizeof *reason );
   reason->code = 0x20; /* uid is no longer valid */
   reason->desc = strdup(""); /* no text */
   return reason;
 }
 
 struct revocation_reason_info *
 get_default_sig_revocation_reason(void)
 {
   struct revocation_reason_info *reason;
   reason = xmalloc( sizeof *reason );
   reason->code = 0; /* No specific reason given. */
   reason->desc = strdup(""); /* no text */
   return reason;
 }
 
 void
 release_revocation_reason_info( struct revocation_reason_info *reason )
 {
     if( reason ) {
 	xfree( reason->desc );
 	xfree( reason );
     }
 }
diff --git a/g10/tofu.c b/g10/tofu.c
index f49083844..83786a08d 100644
--- a/g10/tofu.c
+++ b/g10/tofu.c
@@ -1,4037 +1,4041 @@
 /* tofu.c - TOFU trust model.
  * Copyright (C) 2015, 2016 g10 Code GmbH
  *
  * 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/>.
  */
 
 /* TODO:
 
    - Format the fingerprints nicely when printing (similar to gpg
      --list-keys)
  */
 
 #include <config.h>
 #include <stdio.h>
 #include <sys/stat.h>
 #include <stdarg.h>
 #include <sqlite3.h>
 #include <time.h>
 
 #include "gpg.h"
 #include "../common/types.h"
 #include "../common/logging.h"
 #include "../common/stringhelp.h"
 #include "options.h"
 #include "../common/mbox-util.h"
 #include "../common/i18n.h"
 #include "../common/ttyio.h"
 #include "trustdb.h"
 #include "../common/mkdir_p.h"
 #include "gpgsql.h"
 #include "../common/status.h"
 
 #include "tofu.h"
 
 
 #define CONTROL_L ('L' - 'A' + 1)
 
 /* Number of days with signed / ecnrypted messages required to
  * indicate that enough history is available for basic trust.  */
 #define BASIC_TRUST_THRESHOLD  4
 /* Number of days with signed / encrypted messages required to
  * indicate that a lot of history is available.  */
 #define FULL_TRUST_THRESHOLD  21
 
 
 /* A struct with data pertaining to the tofu DB.  There is one such
    struct per session and it is cached in session's ctrl structure.
    To initialize this or get the current singleton, call opendbs().
    There is no need to explicitly release it; cleanup is done when the
    CTRL object is released.  */
 struct tofu_dbs_s
 {
   sqlite3 *db;
   char *want_lock_file;
   time_t want_lock_file_ctime;
 
   struct
   {
     sqlite3_stmt *savepoint_batch;
     sqlite3_stmt *savepoint_batch_commit;
 
     sqlite3_stmt *record_binding_get_old_policy;
     sqlite3_stmt *record_binding_update;
     sqlite3_stmt *get_policy_select_policy_and_conflict;
     sqlite3_stmt *get_trust_bindings_with_this_email;
     sqlite3_stmt *get_trust_gather_other_user_ids;
     sqlite3_stmt *get_trust_gather_signature_stats;
     sqlite3_stmt *get_trust_gather_encryption_stats;
     sqlite3_stmt *register_already_seen;
     sqlite3_stmt *register_signature;
     sqlite3_stmt *register_encryption;
   } s;
 
   int in_batch_transaction;
   int in_transaction;
   time_t batch_update_started;
 };
 
 
 #define STRINGIFY(s) STRINGIFY2(s)
 #define STRINGIFY2(s) #s
 
 /* The grouping parameters when collecting signature statistics.  */
 
 /* If a message is signed a couple of hours in the future, just assume
    some clock skew.  */
 #define TIME_AGO_FUTURE_IGNORE (2 * 60 * 60)
 /* Days.  */
 #define TIME_AGO_UNIT_SMALL (24 * 60 * 60)
 #define TIME_AGO_SMALL_THRESHOLD (7 * TIME_AGO_UNIT_SMALL)
 /* Months.  */
 #define TIME_AGO_UNIT_MEDIUM (30 * 24 * 60 * 60)
 #define TIME_AGO_MEDIUM_THRESHOLD (2 * TIME_AGO_UNIT_MEDIUM)
 /* Years.  */
 #define TIME_AGO_UNIT_LARGE (365 * 24 * 60 * 60)
 #define TIME_AGO_LARGE_THRESHOLD (2 * TIME_AGO_UNIT_LARGE)
 
 /* Local prototypes.  */
 static gpg_error_t end_transaction (ctrl_t ctrl, int only_batch);
 static char *email_from_user_id (const char *user_id);
 static int show_statistics (tofu_dbs_t dbs,
                             const char *fingerprint, const char *email,
                             enum tofu_policy policy,
                             estream_t outfp, int only_status_fd, time_t now);
 
 const char *
 tofu_policy_str (enum tofu_policy policy)
 {
   switch (policy)
     {
     case TOFU_POLICY_NONE: return "none";
     case TOFU_POLICY_AUTO: return "auto";
     case TOFU_POLICY_GOOD: return "good";
     case TOFU_POLICY_UNKNOWN: return "unknown";
     case TOFU_POLICY_BAD: return "bad";
     case TOFU_POLICY_ASK: return "ask";
     default: return "???";
     }
 }
 
 /* Convert a binding policy (e.g., TOFU_POLICY_BAD) to a trust level
    (e.g., TRUST_BAD) in light of the current configuration.  */
 int
 tofu_policy_to_trust_level (enum tofu_policy policy)
 {
   if (policy == TOFU_POLICY_AUTO)
     /* If POLICY is AUTO, fallback to OPT.TOFU_DEFAULT_POLICY.  */
     policy = opt.tofu_default_policy;
 
   switch (policy)
     {
     case TOFU_POLICY_AUTO:
       /* If POLICY and OPT.TOFU_DEFAULT_POLICY are both AUTO, default
 	 to marginal trust.  */
       return TRUST_MARGINAL;
     case TOFU_POLICY_GOOD:
       return TRUST_FULLY;
     case TOFU_POLICY_UNKNOWN:
       return TRUST_UNKNOWN;
     case TOFU_POLICY_BAD:
       return TRUST_NEVER;
     case TOFU_POLICY_ASK:
       return TRUST_UNKNOWN;
     default:
       log_bug ("Bad value for trust policy: %d\n",
 	       opt.tofu_default_policy);
       return 0;
     }
 }
 
 
 
 /* Start a transaction on DB.  If ONLY_BATCH is set, then this will
    start a batch transaction if we haven't started a batch transaction
    and one has been requested.  */
 static gpg_error_t
 begin_transaction (ctrl_t ctrl, int only_batch)
 {
   tofu_dbs_t dbs = ctrl->tofu.dbs;
   int rc;
   char *err = NULL;
 
   log_assert (dbs);
 
   /* If we've been in batch update mode for a while (on average, more
    * than 500 ms), to prevent starving other gpg processes, we drop
    * and retake the batch lock.
    *
    * Note: gnupg_get_time has a one second resolution, if we wanted a
    * higher resolution, we could use npth_clock_gettime.  */
   if (/* No real transactions.  */
       dbs->in_transaction == 0
       /* There is an open batch transaction.  */
       && dbs->in_batch_transaction
       /* And some time has gone by since it was started.  */
       && dbs->batch_update_started != gnupg_get_time ())
     {
       struct stat statbuf;
 
       /* If we are in a batch update, then batch updates better have
          been enabled.  */
       log_assert (ctrl->tofu.batch_updated_wanted);
 
       /* Check if another process wants to run.  (We just ignore any
        * stat failure.  A waiter might have to wait a bit longer, but
        * otherwise there should be no impact.)  */
       if (gnupg_stat (dbs->want_lock_file, &statbuf) == 0
           && statbuf.st_ctime != dbs->want_lock_file_ctime)
         {
           end_transaction (ctrl, 2);
 
           /* Yield to allow another process a chance to run.  Note:
            * testing suggests that anything less than a 100ms tends to
            * not result in the other process getting the lock.  */
           gnupg_usleep (100000);
         }
       else
         dbs->batch_update_started = gnupg_get_time ();
     }
 
   if (/* We don't have an open batch transaction.  */
       !dbs->in_batch_transaction
       && (/* Batch mode is enabled or we are starting a new transaction.  */
           ctrl->tofu.batch_updated_wanted || dbs->in_transaction == 0))
     {
       struct stat statbuf;
 
       /* We are in batch mode, but we don't have an open batch
        * transaction.  Since the batch save point must be the outer
        * save point, it must be taken before the inner save point.  */
       log_assert (dbs->in_transaction == 0);
 
       rc = gpgsql_stepx (dbs->db, &dbs->s.savepoint_batch,
                           NULL, NULL, &err,
                           "begin immediate transaction;", GPGSQL_ARG_END);
       if (rc)
         {
           log_error (_("error beginning transaction on TOFU database: %s\n"),
                      err);
           sqlite3_free (err);
           return gpg_error (GPG_ERR_GENERAL);
         }
 
       dbs->in_batch_transaction = 1;
       dbs->batch_update_started = gnupg_get_time ();
 
       if (gnupg_stat (dbs->want_lock_file, &statbuf) == 0)
         dbs->want_lock_file_ctime = statbuf.st_ctime;
     }
 
   if (only_batch)
     return 0;
 
   log_assert (dbs->in_transaction >= 0);
   dbs->in_transaction ++;
 
   rc = gpgsql_exec_printf (dbs->db, NULL, NULL, &err,
                            "savepoint inner%d;",
                            dbs->in_transaction);
   if (rc)
     {
       log_error (_("error beginning transaction on TOFU database: %s\n"),
                  err);
       sqlite3_free (err);
       return gpg_error (GPG_ERR_GENERAL);
     }
 
   return 0;
 }
 
 
 /* Commit a transaction.  If ONLY_BATCH is 1, then this only ends the
  * batch transaction if we have left batch mode.  If ONLY_BATCH is 2,
  * this commits any open batch transaction even if we are still in
  * batch mode.  */
 static gpg_error_t
 end_transaction (ctrl_t ctrl, int only_batch)
 {
   tofu_dbs_t dbs = ctrl->tofu.dbs;
   int rc;
   char *err = NULL;
 
   if (only_batch || (! only_batch && dbs->in_transaction == 1))
     {
       if (!dbs)
         return 0;  /* Shortcut to allow for easier cleanup code.  */
 
       /* If we are releasing the batch transaction, then we better not
          be in a normal transaction.  */
       if (only_batch)
         log_assert (dbs->in_transaction == 0);
 
       if (/* Batch mode disabled?  */
           (!ctrl->tofu.batch_updated_wanted || only_batch == 2)
           /* But, we still have an open batch transaction?  */
           && dbs->in_batch_transaction)
         {
           /* The batch transaction is still in open, but we've left
            * batch mode.  */
           dbs->in_batch_transaction = 0;
           dbs->in_transaction = 0;
 
           rc = gpgsql_stepx (dbs->db, &dbs->s.savepoint_batch_commit,
                              NULL, NULL, &err,
                              "commit transaction;", GPGSQL_ARG_END);
           if (rc)
             {
               log_error (_("error committing transaction on TOFU database: %s\n"),
                          err);
               sqlite3_free (err);
               return gpg_error (GPG_ERR_GENERAL);
             }
 
           return 0;
         }
 
       if (only_batch)
         return 0;
     }
 
   log_assert (dbs);
   log_assert (dbs->in_transaction > 0);
 
   rc = gpgsql_exec_printf (dbs->db, NULL, NULL, &err,
                            "release inner%d;", dbs->in_transaction);
 
   dbs->in_transaction --;
 
   if (rc)
     {
       log_error (_("error committing transaction on TOFU database: %s\n"),
                  err);
       sqlite3_free (err);
       return gpg_error (GPG_ERR_GENERAL);
     }
 
   return 0;
 }
 
 
 static gpg_error_t
 rollback_transaction (ctrl_t ctrl)
 {
   tofu_dbs_t dbs = ctrl->tofu.dbs;
   int rc;
   char *err = NULL;
 
   log_assert (dbs);
   log_assert (dbs->in_transaction > 0);
 
   /* Be careful to not undo any progress made by closed transactions in
      batch mode.  */
   rc = gpgsql_exec_printf (dbs->db, NULL, NULL, &err,
                            "rollback to inner%d;",
                            dbs->in_transaction);
 
   dbs->in_transaction --;
 
   if (rc)
     {
       log_error (_("error rolling back transaction on TOFU database: %s\n"),
                  err);
       sqlite3_free (err);
       return gpg_error (GPG_ERR_GENERAL);
     }
 
   return 0;
 }
 
 void
 tofu_begin_batch_update (ctrl_t ctrl)
 {
   ctrl->tofu.batch_updated_wanted ++;
 }
 
 void
 tofu_end_batch_update (ctrl_t ctrl)
 {
   log_assert (ctrl->tofu.batch_updated_wanted > 0);
   ctrl->tofu.batch_updated_wanted --;
   end_transaction (ctrl, 1);
 }
 
 /* Suspend any extant batch transaction (it is safe to call this even
    no batch transaction has been started).  Note: you cannot suspend a
    batch transaction if you are in a normal transaction.  The batch
    transaction can be resumed explicitly by calling
    tofu_resume_batch_transaction or implicitly by starting a normal
    transaction.  */
 static void
 tofu_suspend_batch_transaction (ctrl_t ctrl)
 {
   end_transaction (ctrl, 2);
 }
 
 /* Resume a batch transaction if there is no extant batch transaction
    and one has been requested using tofu_begin_batch_transaction.  */
 static void
 tofu_resume_batch_transaction (ctrl_t ctrl)
 {
   begin_transaction (ctrl, 1);
 }
 
 
 
 /* Wrapper around strtol which prints a warning in case of a
  * conversion error.  On success the converted value is stored at
  * R_VALUE and 0 is returned; on error FALLBACK is stored at R_VALUE
  * and an error code is returned.  */
 static gpg_error_t
 string_to_long (long *r_value, const char *string, long fallback, int line)
 {
   gpg_error_t err;
   char *tail = NULL;
 
   gpg_err_set_errno (0);
   *r_value = strtol (string, &tail, 0);
   if (errno || !(!strcmp (tail, ".0") || !*tail))
     {
       err = errno? gpg_error_from_errno (errno) : gpg_error (GPG_ERR_BAD_DATA);
       log_debug ("%s:%d: strtol failed for TOFU DB data; returned string"
                  " (string='%.10s%s'; tail='%.10s%s'): %s\n",
                  __FILE__, line,
                  string, string && strlen(string) > 10 ? "..." : "",
                  tail, tail && strlen(tail) > 10 ? "..." : "",
                  gpg_strerror (err));
       *r_value = fallback;
     }
   else
     err = 0;
 
   return err;
 }
 
 
 /* Wrapper around strtoul which prints a warning in case of a
  * conversion error.  On success the converted value is stored at
  * R_VALUE and 0 is returned; on error FALLBACK is stored at R_VALUE
  * and an error code is returned.  */
 static gpg_error_t
 string_to_ulong (unsigned long *r_value, const char *string,
                  unsigned long fallback, int line)
 {
   gpg_error_t err;
   char *tail = NULL;
 
   gpg_err_set_errno (0);
   *r_value = strtoul (string, &tail, 0);
   if (errno || !(!strcmp (tail, ".0") || !*tail))
     {
       err = errno? gpg_error_from_errno (errno) : gpg_error (GPG_ERR_BAD_DATA);
       log_debug ("%s:%d: strtoul failed for TOFU DB data; returned string"
                  " (string='%.10s%s'; tail='%.10s%s'): %s\n",
                  __FILE__, line,
                  string, string && strlen(string) > 10 ? "..." : "",
                  tail, tail && strlen(tail) > 10 ? "..." : "",
                  gpg_strerror (err));
       *r_value = fallback;
     }
   else
     err = 0;
 
   return err;
 }
 
 
 
 /* Collect results of a select count (*) ...; style query.  Aborts if
    the argument is not a valid integer (or real of the form X.0).  */
 static int
 get_single_unsigned_long_cb (void *cookie, int argc, char **argv,
 			     char **azColName)
 {
   unsigned long int *count = cookie;
 
   (void) azColName;
 
   log_assert (argc == 1);
 
   if (string_to_ulong (count, argv[0], 0, __LINE__))
     return 1; /* Abort.  */
   return 0;
 }
 
 static int
 get_single_unsigned_long_cb2 (void *cookie, int argc, char **argv,
 			     char **azColName, sqlite3_stmt *stmt)
 {
   (void) stmt;
   return get_single_unsigned_long_cb (cookie, argc, argv, azColName);
 }
 
 /* We expect a single integer column whose name is "version".  COOKIE
    must point to an int.  This function always aborts.  On error or a
    if the version is bad, sets *VERSION to -1.  */
 static int
 version_check_cb (void *cookie, int argc, char **argv, char **azColName)
 {
   int *version = cookie;
 
   if (argc != 1 || strcmp (azColName[0], "version") != 0)
     {
       *version = -1;
       return 1;
     }
 
   if (strcmp (argv[0], "1") == 0)
     *version = 1;
   else
     {
       log_error (_("unsupported TOFU database version: %s\n"), argv[0]);
       *version = -1;
     }
 
   /* Don't run again.  */
   return 1;
 }
 
 static int
 check_utks (sqlite3 *db)
 {
   int rc;
   char *err = NULL;
   struct key_item *utks;
   struct key_item *ki;
   int utk_count;
   char *utks_string = NULL;
   char keyid_str[16+1];
   long utks_unchanged = 0;
 
   /* An early version of the v1 format did not include the list of
    * known ultimately trusted keys.
    *
    * This list is used to detect when the set of ultimately trusted
    * keys changes.  We need to detect this to invalidate the effective
    * policy, which can change if an ultimately trusted key is added or
    * removed.  */
   rc = sqlite3_exec (db,
                      "create table if not exists ultimately_trusted_keys"
                      " (keyid);\n",
                      NULL, NULL, &err);
   if (rc)
     {
       log_error ("error creating 'ultimately_trusted_keys' TOFU table: %s\n",
                  err);
       sqlite3_free (err);
       goto out;
     }
 
 
   utks = tdb_utks ();
   for (ki = utks, utk_count = 0; ki; ki = ki->next, utk_count ++)
     ;
 
   if (utk_count)
     {
       /* Build a list of keyids of the form "XXX","YYY","ZZZ".  */
       int len = (1 + 16 + 1 + 1) * utk_count;
       int o = 0;
 
       utks_string = xmalloc (len);
       *utks_string = 0;
       for (ki = utks, utk_count = 0; ki; ki = ki->next, utk_count ++)
         {
           utks_string[o ++] = '\'';
           format_keyid (ki->kid, KF_LONG,
                         keyid_str, sizeof (keyid_str));
           memcpy (&utks_string[o], keyid_str, 16);
           o += 16;
           utks_string[o ++] = '\'';
           utks_string[o ++] = ',';
         }
       utks_string[o - 1] = 0;
       log_assert (o == len);
     }
 
   rc = gpgsql_exec_printf
     (db, get_single_unsigned_long_cb, &utks_unchanged, &err,
      "select"
      /* Removed UTKs?  (Known UTKs in current UTKs.)  */
      "  ((select count(*) from ultimately_trusted_keys"
      "     where (keyid in (%s))) == %d)"
      " and"
      /* New UTKs?  */
      "  ((select count(*) from ultimately_trusted_keys"
      "     where keyid not in (%s)) == 0);",
      utks_string ? utks_string : "",
      utk_count,
      utks_string ? utks_string : "");
   xfree (utks_string);
   if (rc)
     {
       log_error (_("TOFU DB error"));
       print_further_info ("checking if ultimately trusted keys changed: %s",
                          err);
       sqlite3_free (err);
       goto out;
     }
 
   if (utks_unchanged)
     goto out;
 
   if (DBG_TRUST)
     log_debug ("TOFU: ultimately trusted keys changed.\n");
 
   /* Given that the set of ultimately trusted keys
    * changed, clear any cached policies.  */
   rc = gpgsql_exec_printf
     (db, NULL, NULL, &err,
      "update bindings set effective_policy = %d;",
      TOFU_POLICY_NONE);
   if (rc)
     {
       log_error (_("TOFU DB error"));
       print_further_info ("clearing cached policies: %s", err);
       sqlite3_free (err);
       goto out;
     }
 
   /* Now, update the UTK table.  */
   rc = sqlite3_exec (db,
                      "drop table ultimately_trusted_keys;",
                      NULL, NULL, &err);
   if (rc)
     {
       log_error (_("TOFU DB error"));
       print_further_info ("dropping ultimately_trusted_keys: %s", err);
       sqlite3_free (err);
       goto out;
     }
 
   rc = sqlite3_exec (db,
                      "create table if not exists"
                      " ultimately_trusted_keys (keyid);\n",
                      NULL, NULL, &err);
   if (rc)
     {
       log_error (_("TOFU DB error"));
       print_further_info ("creating ultimately_trusted_keys: %s", err);
       sqlite3_free (err);
       goto out;
     }
 
   for (ki = utks; ki; ki = ki->next)
     {
       format_keyid (ki->kid, KF_LONG,
                     keyid_str, sizeof (keyid_str));
       rc = gpgsql_exec_printf
         (db, NULL, NULL, &err,
          "insert into ultimately_trusted_keys values ('%s');",
          keyid_str);
       if (rc)
         {
           log_error (_("TOFU DB error"));
           print_further_info ("updating ultimately_trusted_keys: %s",
                               err);
           sqlite3_free (err);
           goto out;
         }
     }
 
  out:
   return rc;
 }
 
 /* If the DB is new, initialize it.  Otherwise, check the DB's
    version.
 
    Return 0 if the database is okay and 1 otherwise.  */
 static int
 initdb (sqlite3 *db)
 {
   char *err = NULL;
   int rc;
   unsigned long int count;
   int version = -1;
 
   rc = sqlite3_exec (db, "begin transaction;", NULL, NULL, &err);
   if (rc)
     {
       log_error (_("error beginning transaction on TOFU database: %s\n"),
 		 err);
       sqlite3_free (err);
       return 1;
     }
 
   /* If the DB has no tables, then assume this is a new DB that needs
      to be initialized.  */
   rc = sqlite3_exec (db,
 		     "select count(*) from sqlite_master where type='table';",
 		     get_single_unsigned_long_cb, &count, &err);
   if (rc)
     {
       log_error (_("error reading TOFU database: %s\n"), err);
       print_further_info ("query available tables");
       sqlite3_free (err);
       goto out;
     }
   else if (count != 0)
     /* Assume that the DB is already initialized.  Make sure the
        version is okay.  */
     {
       rc = sqlite3_exec (db, "select version from version;", version_check_cb,
 			 &version, &err);
       if (rc == SQLITE_ABORT && version == 1)
 	/* Happy, happy, joy, joy.  */
 	{
 	  sqlite3_free (err);
           rc = 0;
           goto out;
 	}
       else if (rc == SQLITE_ABORT && version == -1)
 	/* Unsupported version.  */
 	{
 	  /* An error message was already displayed.  */
 	  sqlite3_free (err);
           goto out;
 	}
       else if (rc)
 	/* Some error.  */
 	{
 	  log_error (_("error determining TOFU database's version: %s\n"), err);
 	  sqlite3_free (err);
           goto out;
 	}
       else
         {
           /* Unexpected success.  This can only happen if there are no
              rows.  (select returned 0, but expected ABORT.)  */
 	  log_error (_("error determining TOFU database's version: %s\n"),
                      gpg_strerror (GPG_ERR_NO_DATA));
           rc = 1;
           goto out;
 	}
     }
 
   /* Create the version table.  */
   rc = sqlite3_exec (db,
 		     "create table version (version INTEGER);",
 		     NULL, NULL, &err);
   if (rc)
     {
       log_error (_("error initializing TOFU database: %s\n"), err);
       print_further_info ("create version");
       sqlite3_free (err);
       goto out;
     }
 
   /* Initialize the version table, which contains a single integer
      value.  */
   rc = sqlite3_exec (db,
 		     "insert into version values (1);",
 		     NULL, NULL, &err);
   if (rc)
     {
       log_error (_("error initializing TOFU database: %s\n"), err);
       print_further_info ("insert version");
       sqlite3_free (err);
       goto out;
     }
 
   /* The list of <fingerprint, email> bindings and auxiliary data.
    *
    *  OID is a unique ID identifying this binding (and used by the
    *    signatures table, see below).  Note: OIDs will never be
    *    reused.
    *
    *  FINGERPRINT: The key's fingerprint.
    *
    *  EMAIL: The normalized email address.
    *
    *  USER_ID: The unmodified user id from which EMAIL was extracted.
    *
    *  TIME: The time this binding was first observed.
    *
    *  POLICY: The trust policy (TOFU_POLICY_BAD, etc. as an integer).
    *
    *  CONFLICT is either NULL or a fingerprint.  Assume that we have
    *    a binding <0xdeadbeef, foo@example.com> and then we observe
    *    <0xbaddecaf, foo@example.com>.  There two bindings conflict
    *    (they have the same email address).  When we observe the
    *    latter binding, we warn the user about the conflict and ask
    *    for a policy decision about the new binding.  We also change
    *    the old binding's policy to ask if it was auto.  So that we
    *     know why this occurred, we also set conflict to 0xbaddecaf.
    */
   rc = gpgsql_exec_printf
       (db, NULL, NULL, &err,
        "create table bindings\n"
        " (oid INTEGER PRIMARY KEY AUTOINCREMENT,\n"
        "  fingerprint TEXT, email TEXT, user_id TEXT, time INTEGER,\n"
        "  policy INTEGER CHECK (policy in (%d, %d, %d, %d, %d)),\n"
        "  conflict STRING,\n"
        "  unique (fingerprint, email));\n"
        "create index bindings_fingerprint_email\n"
        " on bindings (fingerprint, email);\n"
        "create index bindings_email on bindings (email);\n",
        TOFU_POLICY_AUTO, TOFU_POLICY_GOOD, TOFU_POLICY_UNKNOWN,
        TOFU_POLICY_BAD, TOFU_POLICY_ASK);
   if (rc)
     {
       log_error (_("error initializing TOFU database: %s\n"), err);
       print_further_info ("create bindings");
       sqlite3_free (err);
       goto out;
     }
 
   /* The signatures that we have observed.
    *
    * BINDING refers to a record in the bindings table, which
    * describes the binding (i.e., this is a foreign key that
    * references bindings.oid).
    *
    * SIG_DIGEST is the digest stored in the signature.
    *
    * SIG_TIME is the timestamp stored in the signature.
    *
    * ORIGIN is a free-form string that describes who fed this
    * signature to GnuPG (e.g., email:claws).
    *
    * TIME is the time this signature was registered.  */
   rc = sqlite3_exec (db,
 			 "create table signatures "
 			 " (binding INTEGER NOT NULL, sig_digest TEXT,"
 			 "  origin TEXT, sig_time INTEGER, time INTEGER,"
 			 "  primary key (binding, sig_digest, origin));",
 			 NULL, NULL, &err);
   if (rc)
     {
       log_error (_("error initializing TOFU database: %s\n"), err);
       print_further_info ("create signatures");
       sqlite3_free (err);
       goto out;
     }
 
  out:
   if (! rc)
     {
       /* Early version of the v1 format did not include the encryption
          table.  Add it.  */
       rc = sqlite3_exec (db,
                          "create table if not exists encryptions"
                          " (binding INTEGER NOT NULL,"
                          "  time INTEGER);"
                          "create index if not exists encryptions_binding"
                          " on encryptions (binding);\n",
                          NULL, NULL, &err);
       if (rc)
         {
 	  log_error ("error creating 'encryptions' TOFU table: %s\n",
 		     err);
           sqlite3_free (err);
         }
     }
   if (! rc)
     {
       /* The effective policy for a binding.  If a key is ultimately
        * trusted, then the effective policy of all of its bindings is
        * good.  Likewise if a key is signed by an ultimately trusted
        * key, etc.  If the effective policy is NONE, then we need to
        * recompute the effective policy.  Otherwise, the effective
        * policy is considered to be up to date, i.e., effective_policy
        * is a cache of the computed policy.  */
       rc = gpgsql_exec_printf
         (db, NULL, NULL, &err,
          "alter table bindings"
          " add column effective_policy INTEGER"
          " DEFAULT %d"
          " CHECK (effective_policy in (%d, %d, %d, %d, %d, %d));",
          TOFU_POLICY_NONE,
          TOFU_POLICY_NONE, TOFU_POLICY_AUTO, TOFU_POLICY_GOOD,
          TOFU_POLICY_UNKNOWN, TOFU_POLICY_BAD, TOFU_POLICY_ASK);
       if (rc)
 	{
           if (rc == SQLITE_ERROR)
             /* Almost certainly "duplicate column name", which we can
              * safely ignore.  */
             rc = 0;
           else
             log_error ("adding column effective_policy to bindings DB: %s\n",
                        err);
 	  sqlite3_free (err);
 	}
     }
 
   if (! rc)
     rc = check_utks (db);
 
   if (rc)
     {
       rc = sqlite3_exec (db, "rollback;", NULL, NULL, &err);
       if (rc)
 	{
 	  log_error (_("error rolling back transaction on TOFU database: %s\n"),
 		     err);
 	  sqlite3_free (err);
 	}
       return 1;
     }
   else
     {
       rc = sqlite3_exec (db, "end transaction;", NULL, NULL, &err);
       if (rc)
 	{
 	  log_error (_("error committing transaction on TOFU database: %s\n"),
 		     err);
 	  sqlite3_free (err);
 	  return 1;
 	}
       return 0;
     }
 }
 
 static int
 busy_handler (void *cookie, int call_count)
 {
   ctrl_t ctrl = cookie;
   tofu_dbs_t dbs = ctrl->tofu.dbs;
 
   (void) call_count;
 
   /* Update the want-lock-file time stamp (specifically, the ctime) so
    * that the current owner knows that we (well, someone) want the
    * lock.  */
   if (dbs)
     {
       /* Note: we don't fail if we can't create the lock file: this
        * process will have to wait a bit longer, but otherwise nothing
        * horrible should happen.  */
 
       estream_t fp;
 
       fp = es_fopen (dbs->want_lock_file, "w");
       if (! fp)
         log_debug ("TOFU: Error opening '%s': %s\n",
                    dbs->want_lock_file, strerror (errno));
       else
         es_fclose (fp);
     }
 
   /* Call again.  */
   return 1;
 }
 
 /* Create a new DB handle.  Returns NULL on error.  */
 /* FIXME: Change to return an error code for better reporting by the
    caller.  */
 static tofu_dbs_t
 opendbs (ctrl_t ctrl)
 {
   char *filename;
   sqlite3 *db;
   int rc;
 
   if (!ctrl->tofu.dbs)
     {
       filename = make_filename (gnupg_homedir (), "tofu.db", NULL);
 
       rc = sqlite3_open (filename, &db);
       if (rc)
         {
           log_error (_("error opening TOFU database '%s': %s\n"),
                      filename, sqlite3_errmsg (db));
           /* Even if an error occurs, DB is guaranteed to be valid.  */
           sqlite3_close (db);
           db = NULL;
         }
 
       /* If a DB is locked wait up to 5 seconds for the lock to be cleared
          before failing.  */
       if (db)
         {
           sqlite3_busy_timeout (db, 5 * 1000);
           sqlite3_busy_handler (db, busy_handler, ctrl);
         }
 
       if (db && initdb (db))
         {
           sqlite3_close (db);
           db = NULL;
         }
 
       if (db)
         {
           ctrl->tofu.dbs = xmalloc_clear (sizeof *ctrl->tofu.dbs);
           ctrl->tofu.dbs->db = db;
           ctrl->tofu.dbs->want_lock_file = xasprintf ("%s-want-lock", filename);
         }
 
       xfree (filename);
     }
   else
     log_assert (ctrl->tofu.dbs->db);
 
   return ctrl->tofu.dbs;
 }
 
 
 /* Release all of the resources associated with the DB handle.  */
 void
 tofu_closedbs (ctrl_t ctrl)
 {
   tofu_dbs_t dbs;
   sqlite3_stmt **statements;
 
   dbs = ctrl->tofu.dbs;
   if (!dbs)
     return;  /* Not initialized.  */
 
   log_assert (dbs->in_transaction == 0);
 
   end_transaction (ctrl, 2);
 
   /* Arghh, that is a surprising use of the struct.  */
   for (statements = (void *) &dbs->s;
        (void *) statements < (void *) &(&dbs->s)[1];
        statements ++)
     sqlite3_finalize (*statements);
 
   sqlite3_close (dbs->db);
   xfree (dbs->want_lock_file);
   xfree (dbs);
   ctrl->tofu.dbs = NULL;
 }
 
 
 /* Collect results of a select min (foo) ...; style query.  Aborts if
    the argument is not a valid integer (or real of the form X.0).  */
 static int
 get_single_long_cb (void *cookie, int argc, char **argv, char **azColName)
 {
   long *count = cookie;
 
   (void) azColName;
 
   log_assert (argc == 1);
 
   if (string_to_long (count, argv[0], 0, __LINE__))
     return 1; /* Abort.  */
 
   return 0;
 }
 
 static int
 get_single_long_cb2 (void *cookie, int argc, char **argv, char **azColName,
                      sqlite3_stmt *stmt)
 {
   (void) stmt;
   return get_single_long_cb (cookie, argc, argv, azColName);
 }
 
 /* Record (or update) a trust policy about a (possibly new)
    binding.
 
    If SHOW_OLD is set, the binding's old policy is displayed.  */
 static gpg_error_t
 record_binding (tofu_dbs_t dbs, const char *fingerprint, const char *email,
 		const char *user_id,
                 enum tofu_policy policy, enum tofu_policy effective_policy,
                 const char *conflict, int set_conflict,
                 int show_old, time_t now)
 {
   char *fingerprint_pp = format_hexfingerprint (fingerprint, NULL, 0);
   gpg_error_t rc;
   char *err = NULL;
 
   if (! (policy == TOFU_POLICY_AUTO
 	 || policy == TOFU_POLICY_GOOD
 	 || policy == TOFU_POLICY_UNKNOWN
 	 || policy == TOFU_POLICY_BAD
 	 || policy == TOFU_POLICY_ASK))
     log_bug ("%s: Bad value for policy (%d)!\n", __func__, policy);
 
 
   if (DBG_TRUST || show_old)
     {
       /* Get the old policy.  Since this is just for informational
        * purposes, there is no need to start a transaction or to die
        * if there is a failure.  */
 
       /* policy_old needs to be a long and not an enum tofu_policy,
          because we pass it by reference to get_single_long_cb2, which
          expects a long.  */
       long policy_old = TOFU_POLICY_NONE;
 
       rc = gpgsql_stepx
 	(dbs->db, &dbs->s.record_binding_get_old_policy,
          get_single_long_cb2, &policy_old, &err,
 	 "select policy from bindings where fingerprint = ? and email = ?",
 	 GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
          GPGSQL_ARG_END);
       if (rc)
 	{
 	  log_debug ("TOFU: Error reading from binding database"
 		     " (reading policy for <key: %s, user id: %s>): %s\n",
 		     fingerprint, email, err);
 	  sqlite3_free (err);
 	}
 
       if (policy_old != TOFU_POLICY_NONE)
         (show_old ? log_info : log_debug)
           ("Changing TOFU trust policy for binding"
            " <key: %s, user id: %s> from %s to %s.\n",
            fingerprint, show_old ? user_id : email,
            tofu_policy_str (policy_old),
            tofu_policy_str (policy));
       else
         (show_old ? log_info : log_debug)
           ("Setting TOFU trust policy for new binding"
            " <key: %s, user id: %s> to %s.\n",
            fingerprint, show_old ? user_id : email,
            tofu_policy_str (policy));
     }
 
   if (opt.dry_run)
     {
       log_info ("TOFU database update skipped due to --dry-run\n");
       rc = 0;
       goto leave;
     }
 
   rc = gpgsql_stepx
     (dbs->db, &dbs->s.record_binding_update, NULL, NULL, &err,
      "insert or replace into bindings\n"
      " (oid, fingerprint, email, user_id, time,"
      "  policy, conflict, effective_policy)\n"
      " values (\n"
      /* If we don't explicitly reuse the OID, then SQLite will
       * reallocate a new one.  We just need to search for the OID
       * based on the fingerprint and email since they are unique.  */
      "  (select oid from bindings where fingerprint = ? and email = ?),\n"
      "  ?, ?, ?, ?, ?,"
      /* If SET_CONFLICT is 0, then preserve conflict's current value.  */
      "  case ?"
      "    when 0 then"
      "      (select conflict from bindings where fingerprint = ? and email = ?)"
      "    else ?"
      "  end,"
      "  ?);",
      /* oid subquery.  */
      GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
      /* values 2 through 6.  */
      GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
      GPGSQL_ARG_STRING, user_id,
      GPGSQL_ARG_LONG_LONG, (long long) now,
      GPGSQL_ARG_INT, (int) policy,
      /* conflict subquery.  */
      GPGSQL_ARG_INT, set_conflict ? 1 : 0,
      GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
      GPGSQL_ARG_STRING, conflict ? conflict : "",
      GPGSQL_ARG_INT, (int) effective_policy,
      GPGSQL_ARG_END);
   if (rc)
     {
       log_error (_("error updating TOFU database: %s\n"), err);
       print_further_info (" insert bindings <key: %s, user id: %s> = %s",
                           fingerprint, email, tofu_policy_str (policy));
       sqlite3_free (err);
       goto leave;
     }
 
  leave:
   xfree (fingerprint_pp);
   return rc;
 }
 
 
 /* Collect the strings returned by a query in a simple string list.
    Any NULL values are converted to the empty string.
 
    If a result has 3 rows and each row contains two columns, then the
    results are added to the list as follows (the value is parentheses
    is the 1-based index in the final list):
 
      row 1, col 2 (6)
      row 1, col 1 (5)
      row 2, col 2 (4)
      row 2, col 1 (3)
      row 3, col 2 (2)
      row 3, col 1 (1)
 
    This is because add_to_strlist pushes the results onto the front of
    the list.  The end result is that the rows are backwards, but the
    columns are in the expected order.  */
 static int
 strings_collect_cb (void *cookie, int argc, char **argv, char **azColName)
 {
   int i;
   strlist_t *strlist = cookie;
 
   (void) azColName;
 
   for (i = argc - 1; i >= 0; i --)
     add_to_strlist (strlist, argv[i] ? argv[i] : "");
 
   return 0;
 }
 
 static int
 strings_collect_cb2 (void *cookie, int argc, char **argv, char **azColName,
                      sqlite3_stmt *stmt)
 {
   (void) stmt;
   return strings_collect_cb (cookie, argc, argv, azColName);
 
 }
 
 /* Auxiliary data structure to collect statistics about
    signatures.  */
 struct signature_stats
 {
   struct signature_stats *next;
 
   /* The user-assigned policy for this binding.  */
   enum tofu_policy policy;
 
   /* How long ago the signature was created (rounded to a multiple of
      TIME_AGO_UNIT_SMALL, etc.).  */
   long time_ago;
   /* Number of signatures during this time.  */
   unsigned long count;
 
   /* If the corresponding key/user id has been expired / revoked.  */
   int is_expired;
   int is_revoked;
 
   /* The key that generated this signature.  */
   char fingerprint[1];
 };
 
 static void
 signature_stats_free (struct signature_stats *stats)
 {
   while (stats)
     {
       struct signature_stats *next = stats->next;
       xfree (stats);
       stats = next;
     }
 }
 
 static void
 signature_stats_prepend (struct signature_stats **statsp,
 			 const char *fingerprint,
 			 enum tofu_policy policy,
 			 long time_ago,
 			 unsigned long count)
 {
   struct signature_stats *stats =
     xmalloc_clear (sizeof (*stats) + strlen (fingerprint));
 
   stats->next = *statsp;
   *statsp = stats;
 
   strcpy (stats->fingerprint, fingerprint);
   stats->policy = policy;
   stats->time_ago = time_ago;
   stats->count = count;
 }
 
 
 /* Process rows that contain the four columns:
 
      <fingerprint, policy, time ago, count>.  */
 static int
 signature_stats_collect_cb (void *cookie, int argc, char **argv,
 			    char **azColName, sqlite3_stmt *stmt)
 {
   struct signature_stats **statsp = cookie;
   int i = 0;
   enum tofu_policy policy;
   long time_ago;
   unsigned long count;
   long along;
 
   (void) azColName;
   (void) stmt;
 
   i ++;
 
   if (string_to_long (&along, argv[i], 0, __LINE__))
     return 1;  /* Abort */
   policy = along;
   i ++;
 
   if (! argv[i])
     time_ago = 0;
   else
     {
       if (string_to_long (&time_ago, argv[i], 0, __LINE__))
         return 1; /* Abort.  */
     }
   i ++;
 
   /* If time_ago is NULL, then we had no messages, but we still have a
      single row, which count(*) turns into 1.  */
   if (! argv[i - 1])
     count = 0;
   else
     {
       if (string_to_ulong (&count, argv[i], 0, __LINE__))
         return 1; /* Abort */
     }
   i ++;
 
   log_assert (argc == i);
 
   signature_stats_prepend (statsp, argv[0], policy, time_ago, count);
 
   return 0;
 }
 
 /* Format the first part of a conflict message and return that as a
  * malloced string. Returns NULL on error. */
 static char *
 format_conflict_msg_part1 (int policy, strlist_t conflict_set,
                            const char *email)
 {
   estream_t fp;
   char *fingerprint;
   char *tmpstr, *text;
 
   log_assert (conflict_set);
   fingerprint = conflict_set->d;
 
   fp = es_fopenmem (0, "rw,samethread");
   if (!fp)
     log_fatal ("error creating memory stream: %s\n",
                gpg_strerror (gpg_error_from_syserror()));
 
   if (policy == TOFU_POLICY_NONE)
     {
       es_fprintf (fp,
                   _("This is the first time the email address \"%s\" is "
                     "being used with key %s."),
                   email, fingerprint);
       es_fputs ("  ", fp);
     }
   else if (policy == TOFU_POLICY_ASK && conflict_set->next)
     {
       int conflicts = strlist_length (conflict_set);
       es_fprintf
         (fp, ngettext("The email address \"%s\" is associated with %d key!",
                       "The email address \"%s\" is associated with %d keys!",
                       conflicts),
          email, conflicts);
       if (opt.verbose)
         es_fprintf (fp,
                     _("  Since this binding's policy was 'auto', it has been "
                       "changed to 'ask'."));
       es_fputs ("  ", fp);
     }
 
   es_fprintf (fp,
               _("Please indicate whether this email address should"
                 " be associated with key %s or whether you think someone"
                 " is impersonating \"%s\"."),
               fingerprint, email);
   es_fputc ('\n', fp);
 
   es_fputc (0, fp);
   if (es_fclose_snatch (fp, (void **)&tmpstr, NULL))
     log_fatal ("error snatching memory stream\n");
   text = format_text (tmpstr, 72, 80);
   es_free (tmpstr);
 
   return text;
 }
 
 
 /* Return 1 if A signed B and B signed A.  */
 static int
 cross_sigs (const char *email, kbnode_t a, kbnode_t b)
 {
   int i;
 
   PKT_public_key *a_pk = a->pkt->pkt.public_key;
   PKT_public_key *b_pk = b->pkt->pkt.public_key;
 
   char a_keyid[33];
   char b_keyid[33];
 
   if (DBG_TRUST)
     {
       format_keyid (pk_main_keyid (a_pk),
                     KF_LONG, a_keyid, sizeof (a_keyid));
       format_keyid (pk_main_keyid (b_pk),
                     KF_LONG, b_keyid, sizeof (b_keyid));
     }
 
   for (i = 0; i < 2; i ++)
     {
       /* See if SIGNER signed SIGNEE.  */
 
       kbnode_t signer = i == 0 ? a : b;
       kbnode_t signee = i == 0 ? b : a;
 
       PKT_public_key *signer_pk = signer->pkt->pkt.public_key;
       u32 *signer_kid = pk_main_keyid (signer_pk);
       kbnode_t n;
 
       int saw_email = 0;
 
       /* Iterate over SIGNEE's keyblock and see if there is a valid
          signature from SIGNER.  */
       for (n = signee; n; n = n->next)
         {
           PKT_signature *sig;
 
           if (n->pkt->pkttype == PKT_USER_ID)
             {
               if (saw_email)
                 /* We're done: we've processed all signatures on the
                    user id.  */
                 break;
               else
                 {
                   /* See if this is the matching user id.  */
                   PKT_user_id *user_id = n->pkt->pkt.user_id;
                   char *email2 = email_from_user_id (user_id->name);
 
                   if (strcmp (email, email2) == 0)
                     saw_email = 1;
 
                   xfree (email2);
                 }
             }
 
           if (! saw_email)
             continue;
 
           if (n->pkt->pkttype != PKT_SIGNATURE)
             continue;
 
           sig = n->pkt->pkt.signature;
 
           if (! (sig->sig_class == 0x10
                  || sig->sig_class == 0x11
                  || sig->sig_class == 0x12
                  || sig->sig_class == 0x13))
             /* Not a signature over a user id.  */
             continue;
 
           /* SIG is on SIGNEE's keyblock.  If SIG was generated by the
              signer, then it's a match.  */
           if (keyid_cmp (sig->keyid, signer_kid) == 0)
             /* Match!  */
             break;
         }
       if (! n)
         /* We didn't find a signature from signer over signee.  */
         {
           if (DBG_TRUST)
             log_debug ("No cross sig between %s and %s\n",
                        a_keyid, b_keyid);
           return 0;
         }
     }
 
   /* A signed B and B signed A.  */
   if (DBG_TRUST)
     log_debug ("Cross sig between %s and %s\n",
                a_keyid, b_keyid);
 
   return 1;
 }
 
 /* Return whether the key was signed by an ultimately trusted key.  */
 static int
 signed_by_utk (const char *email, kbnode_t a)
 {
   kbnode_t n;
   int saw_email = 0;
 
   for (n = a; n; n = n->next)
     {
       PKT_signature *sig;
 
       if (n->pkt->pkttype == PKT_USER_ID)
         {
           if (saw_email)
             /* We're done: we've processed all signatures on the
                user id.  */
             break;
           else
             {
               /* See if this is the matching user id.  */
               PKT_user_id *user_id = n->pkt->pkt.user_id;
               char *email2 = email_from_user_id (user_id->name);
 
               if (strcmp (email, email2) == 0)
                 saw_email = 1;
 
               xfree (email2);
             }
         }
 
       if (! saw_email)
         continue;
 
       if (n->pkt->pkttype != PKT_SIGNATURE)
         continue;
 
       sig = n->pkt->pkt.signature;
 
       if (! (sig->sig_class == 0x10
              || sig->sig_class == 0x11
              || sig->sig_class == 0x12
              || sig->sig_class == 0x13))
         /* Not a signature over a user id.  */
         continue;
 
       /* SIG is on SIGNEE's keyblock.  If SIG was generated by the
          signer, then it's a match.  */
       if (tdb_keyid_is_utk (sig->keyid))
         {
           /* Match!  */
           if (DBG_TRUST)
             log_debug ("TOFU: %s is signed by an ultimately trusted key.\n",
                        pk_keyid_str (a->pkt->pkt.public_key));
 
           return 1;
         }
     }
 
   if (DBG_TRUST)
     log_debug ("TOFU: %s is NOT signed by an ultimately trusted key.\n",
                pk_keyid_str (a->pkt->pkt.public_key));
 
   return 0;
 }
 
 
 enum
   {
     BINDING_NEW = 1 << 0,
     BINDING_CONFLICT = 1 << 1,
     BINDING_EXPIRED = 1 << 2,
     BINDING_REVOKED = 1 << 3
   };
 
 
 /* Ask the user about the binding.  There are three ways we could end
  * up here:
  *
  *   - This is a new binding and there is a conflict
  *     (policy == TOFU_POLICY_NONE && conflict_set_count > 1),
  *
  *   - This is a new binding and opt.tofu_default_policy is set to
  *     ask.  (policy == TOFU_POLICY_NONE && opt.tofu_default_policy ==
  *     TOFU_POLICY_ASK), or,
  *
  *   - The policy is ask (the user deferred last time) (policy ==
  *     TOFU_POLICY_ASK).
  *
  * Note: this function must not be called while in a transaction!
  *
  * CONFLICT_SET includes all of the conflicting bindings
  * with FINGERPRINT first.  FLAGS is a bit-wise or of
  * BINDING_NEW, etc.
  */
 static void
 ask_about_binding (ctrl_t ctrl,
                    enum tofu_policy *policy,
                    int *trust_level,
                    strlist_t conflict_set,
                    const char *fingerprint,
                    const char *email,
                    const char *user_id,
                    time_t now)
 {
   tofu_dbs_t dbs;
   strlist_t iter;
   int conflict_set_count = strlist_length (conflict_set);
   char *sqerr = NULL;
   int rc;
   estream_t fp;
   strlist_t other_user_ids = NULL;
   struct signature_stats *stats = NULL;
   struct signature_stats *stats_iter = NULL;
   char *prompt = NULL;
   const char *choices;
 
   dbs = ctrl->tofu.dbs;
   log_assert (dbs);
   log_assert (dbs->in_transaction == 0);
 
   fp = es_fopenmem (0, "rw,samethread");
   if (!fp)
     log_fatal ("error creating memory stream: %s\n",
                gpg_strerror (gpg_error_from_syserror()));
 
   {
     char *text = format_conflict_msg_part1 (*policy, conflict_set, email);
     if (!text) /* FIXME: Return the error all the way up.  */
       log_fatal ("format failed: %s\n",
                  gpg_strerror (gpg_error_from_syserror()));
 
     es_fputs (text, fp);
     es_fputc ('\n', fp);
     xfree (text);
   }
 
   begin_transaction (ctrl, 0);
 
   /* Find other user ids associated with this key and whether the
    * bindings are marked as good or bad.  */
   rc = gpgsql_stepx
     (dbs->db, &dbs->s.get_trust_gather_other_user_ids,
      strings_collect_cb2, &other_user_ids, &sqerr,
      "select user_id, policy from bindings where fingerprint = ?;",
      GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_END);
   if (rc)
     {
       log_error (_("error gathering other user IDs: %s\n"), sqerr);
       sqlite3_free (sqerr);
       sqerr = NULL;
       rc = gpg_error (GPG_ERR_GENERAL);
     }
 
   if (other_user_ids)
     {
       strlist_t strlist_iter;
 
       es_fprintf (fp, _("This key's user IDs:\n"));
       for (strlist_iter = other_user_ids;
            strlist_iter;
            strlist_iter = strlist_iter->next)
         {
           char *other_user_id = strlist_iter->d;
           char *other_thing;
           enum tofu_policy other_policy;
 
           log_assert (strlist_iter->next);
           strlist_iter = strlist_iter->next;
           other_thing = strlist_iter->d;
 
           other_policy = atoi (other_thing);
 
           es_fprintf (fp, "  %s (", other_user_id);
           es_fprintf (fp, _("policy: %s"), tofu_policy_str (other_policy));
           es_fprintf (fp, ")\n");
         }
       es_fprintf (fp, "\n");
 
       free_strlist (other_user_ids);
     }
 
   /* Get the stats for all the keys in CONFLICT_SET.  */
   strlist_rev (&conflict_set);
   for (iter = conflict_set; iter && ! rc; iter = iter->next)
     {
 #define STATS_SQL(table, time, sign)                         \
          "select fingerprint, policy, time_ago, count(*)\n" \
          " from\n" \
          "  (select bindings.*,\n" \
          "     "sign" case\n" \
          "       when delta ISNULL then 1\n" \
          /* From the future (but if its just a couple of hours in the \
           * future don't turn it into a warning)?  Or should we use \
           * small, medium or large units?  (Note: whatever we do, we \
           * keep the value in seconds.  Then when we group, everything \
           * that rounds to the same number of seconds is grouped.)  */ \
          "      when delta < -("STRINGIFY (TIME_AGO_FUTURE_IGNORE)") then 2\n" \
          "      when delta < ("STRINGIFY (TIME_AGO_SMALL_THRESHOLD)")\n" \
          "       then 3\n" \
          "      when delta < ("STRINGIFY (TIME_AGO_MEDIUM_THRESHOLD)")\n" \
          "       then 4\n" \
          "      when delta < ("STRINGIFY (TIME_AGO_LARGE_THRESHOLD)")\n" \
          "       then 5\n" \
          "      else 6\n" \
          "     end time_ago,\n" \
          "    delta time_ago_raw\n" \
          "   from bindings\n" \
          "   left join\n" \
          "     (select *,\n" \
          "        cast(? - " time " as real) delta\n" \
          "       from " table ") ss\n" \
          "    on ss.binding = bindings.oid)\n" \
          " where email = ? and fingerprint = ?\n" \
          " group by time_ago\n" \
          /* Make sure the current key is first.  */ \
          " order by time_ago desc;\n"
 
       /* Use the time when we saw the signature, not when the
          signature was created as that can be forged.  */
       rc = gpgsql_stepx
         (dbs->db, &dbs->s.get_trust_gather_signature_stats,
          signature_stats_collect_cb, &stats, &sqerr,
          STATS_SQL ("signatures", "time", ""),
          GPGSQL_ARG_LONG_LONG, (long long) now,
          GPGSQL_ARG_STRING, email,
          GPGSQL_ARG_STRING, iter->d,
          GPGSQL_ARG_END);
       if (rc)
         {
+          sqlite3_free (sqerr);
+          sqerr = NULL;
           rc = gpg_error (GPG_ERR_GENERAL);
           break;
         }
 
       if (!stats || strcmp (iter->d, stats->fingerprint) != 0)
         /* No stats for this binding.  Add a dummy entry.  */
         signature_stats_prepend (&stats, iter->d, TOFU_POLICY_AUTO, 1, 1);
 
       rc = gpgsql_stepx
         (dbs->db, &dbs->s.get_trust_gather_encryption_stats,
          signature_stats_collect_cb, &stats, &sqerr,
          STATS_SQL ("encryptions", "time", "-"),
          GPGSQL_ARG_LONG_LONG, (long long) now,
          GPGSQL_ARG_STRING, email,
          GPGSQL_ARG_STRING, iter->d,
          GPGSQL_ARG_END);
       if (rc)
         {
           rc = gpg_error (GPG_ERR_GENERAL);
           break;
         }
 
 #undef STATS_SQL
 
       if (!stats || strcmp (iter->d, stats->fingerprint) != 0
           || stats->time_ago > 0)
         /* No stats for this binding.  Add a dummy entry.  */
         signature_stats_prepend (&stats, iter->d, TOFU_POLICY_AUTO, -1, 1);
     }
   end_transaction (ctrl, 0);
   strlist_rev (&conflict_set);
   if (rc)
     {
       strlist_t strlist_iter;
 
       log_error (_("error gathering signature stats: %s\n"), sqerr);
       sqlite3_free (sqerr);
       sqerr = NULL;
 
       es_fprintf (fp, ngettext("The email address \"%s\" is"
                                " associated with %d key:\n",
                                "The email address \"%s\" is"
                                " associated with %d keys:\n",
                                conflict_set_count),
                   email, conflict_set_count);
       for (strlist_iter = conflict_set;
            strlist_iter;
            strlist_iter = strlist_iter->next)
         es_fprintf (fp, "  %s\n", strlist_iter->d);
     }
   else
     {
       char *key = NULL;
       strlist_t binding;
       int seen_in_past = 0;
       int encrypted = 1;
 
       es_fprintf (fp, _("Statistics for keys"
                         " with the email address \"%s\":\n"),
                   email);
       for (stats_iter = stats; stats_iter; stats_iter = stats_iter->next)
         {
 #if 0
           log_debug ("%s: time_ago: %ld; count: %ld\n",
                      stats_iter->fingerprint,
                      stats_iter->time_ago,
                      stats_iter->count);
 #endif
 
           if (stats_iter->time_ago > 0 && encrypted)
             {
               /* We've change from the encrypted stats to the verified
                * stats.  Reset SEEN_IN_PAST.  */
               encrypted = 0;
               seen_in_past = 0;
             }
 
           if (! key || strcmp (key, stats_iter->fingerprint))
             {
               int this_key;
               char *key_pp;
 
               key = stats_iter->fingerprint;
               this_key = strcmp (key, fingerprint) == 0;
               key_pp = format_hexfingerprint (key, NULL, 0);
               es_fprintf (fp, "  %s (", key_pp);
 
               /* Find the associated binding.  */
               for (binding = conflict_set;
                    binding;
                    binding = binding->next)
                 if (strcmp (key, binding->d) == 0)
                   break;
               log_assert (binding);
 
               if ((binding->flags & BINDING_REVOKED))
                 {
                   es_fprintf (fp, _("revoked"));
                   es_fprintf (fp, ", ");
                 }
               else if ((binding->flags & BINDING_EXPIRED))
                 {
                   es_fprintf (fp, _("expired"));
                   es_fprintf (fp, ", ");
                 }
 
               if (this_key)
                 es_fprintf (fp, _("this key"));
               else
                 es_fprintf (fp, _("policy: %s"),
                             tofu_policy_str (stats_iter->policy));
               es_fputs ("):\n", fp);
               xfree (key_pp);
 
               seen_in_past = 0;
 
               show_statistics (dbs, stats_iter->fingerprint, email,
                                TOFU_POLICY_ASK, NULL, 1, now);
             }
 
           if (labs(stats_iter->time_ago) == 1)
             {
               /* The 1 in this case is the NULL entry.  */
               log_assert (stats_iter->count == 1);
               stats_iter->count = 0;
             }
           seen_in_past += stats_iter->count;
 
           es_fputs ("    ", fp);
 
           if (!stats_iter->count)
             {
               if (stats_iter->time_ago > 0)
                 es_fprintf (fp, ngettext("Verified %d message.",
                                          "Verified %d messages.",
                                          seen_in_past), seen_in_past);
               else
                 es_fprintf (fp, ngettext("Encrypted %d message.",
                                          "Encrypted %d messages.",
                                          seen_in_past), seen_in_past);
             }
           else if (labs(stats_iter->time_ago) == 2)
             {
               if (stats_iter->time_ago > 0)
                 es_fprintf (fp, ngettext("Verified %d message in the future.",
                                          "Verified %d messages in the future.",
                                          seen_in_past), seen_in_past);
               else
                 es_fprintf (fp, ngettext("Encrypted %d message in the future.",
                                          "Encrypted %d messages in the future.",
                                          seen_in_past), seen_in_past);
               /* Reset it.  */
               seen_in_past = 0;
             }
           else
             {
               if (labs(stats_iter->time_ago) == 3)
                 {
                   int days = 1 + stats_iter->time_ago / TIME_AGO_UNIT_SMALL;
                   if (stats_iter->time_ago > 0)
                     es_fprintf
                       (fp,
                        ngettext("Messages verified over the past %d day: %d.",
                                 "Messages verified over the past %d days: %d.",
                                 days), days, seen_in_past);
                   else
                     es_fprintf
                       (fp,
                        ngettext("Messages encrypted over the past %d day: %d.",
                                 "Messages encrypted over the past %d days: %d.",
                                 days), days, seen_in_past);
                 }
               else if (labs(stats_iter->time_ago) == 4)
                 {
                   int months = 1 + stats_iter->time_ago / TIME_AGO_UNIT_MEDIUM;
                   if (stats_iter->time_ago > 0)
                     es_fprintf
                       (fp,
                        ngettext("Messages verified over the past %d month: %d.",
                                 "Messages verified over the past %d months: %d.",
                                 months), months, seen_in_past);
                   else
                     es_fprintf
                       (fp,
                        ngettext("Messages encrypted over the past %d month: %d.",
                                 "Messages encrypted over the past %d months: %d.",
                                 months), months, seen_in_past);
                 }
               else if (labs(stats_iter->time_ago) == 5)
                 {
                   int years = 1 + stats_iter->time_ago / TIME_AGO_UNIT_LARGE;
                   if (stats_iter->time_ago > 0)
                     es_fprintf
                       (fp,
                        ngettext("Messages verified over the past %d year: %d.",
                                 "Messages verified over the past %d years: %d.",
                                 years), years, seen_in_past);
                   else
                     es_fprintf
                       (fp,
                        ngettext("Messages encrypted over the past %d year: %d.",
                                 "Messages encrypted over the past %d years: %d.",
                                 years), years, seen_in_past);
                 }
               else if (labs(stats_iter->time_ago) == 6)
                 {
                   if (stats_iter->time_ago > 0)
                     es_fprintf
                       (fp, _("Messages verified in the past: %d."),
                        seen_in_past);
                   else
                     es_fprintf
                       (fp, _("Messages encrypted in the past: %d."),
                        seen_in_past);
                 }
               else
                 log_assert (! "Broken SQL.\n");
             }
           es_fputs ("\n", fp);
         }
     }
 
   if (conflict_set_count > 1 || (conflict_set->flags & BINDING_CONFLICT))
     {
       /* This is a conflict.  */
 
       /* TRANSLATORS: Please translate the text found in the source
        * file below.  We don't directly internationalize that text so
        * that we can tweak it without breaking translations.  */
       const char *text = _("TOFU detected a binding conflict");
       char *textbuf;
       if (!strcmp (text, "TOFU detected a binding conflict"))
         {
           /* No translation.  Use the English text.  */
           text =
             "Normally, an email address is associated with a single key.  "
             "However, people sometimes generate a new key if "
             "their key is too old or they think it might be compromised.  "
             "Alternatively, a new key may indicate a man-in-the-middle "
             "attack!  Before accepting this association, you should talk to or "
             "call the person to make sure this new key is legitimate.";
         }
       textbuf = format_text (text, 72, 80);
       es_fprintf (fp, "\n%s\n", textbuf? textbuf : "[OUT OF CORE!]");
       xfree (textbuf);
     }
 
   es_fputc ('\n', fp);
 
   /* Add a NUL terminator.  */
   es_fputc (0, fp);
   if (es_fclose_snatch (fp, (void **) &prompt, NULL))
     log_fatal ("error snatching memory stream\n");
 
   /* I think showing the large message once is sufficient.  If we
    * would move it right before the cpr_get many lines will scroll
    * away and the user might not realize that he merely entered a
    * wrong choice (because he does not see that either).  As a small
    * benefit we allow C-L to redisplay everything.  */
   tty_printf ("%s", prompt);
 
   /* Suspend any transaction: it could take a while until the user
      responds.  */
   tofu_suspend_batch_transaction (ctrl);
   while (1)
     {
       char *response;
 
       /* TRANSLATORS: Two letters (normally the lower and upper case
        * version of the hotkey) for each of the five choices.  If
        * there is only one choice in your language, repeat it.  */
       choices = _("gG" "aA" "uU" "rR" "bB");
       if (strlen (choices) != 10)
         log_bug ("Bad TOFU conflict translation!  Please report.");
 
       response = cpr_get
         ("tofu.conflict",
          _("(G)ood, (A)ccept once, (U)nknown, (R)eject once, (B)ad? "));
       trim_spaces (response);
       cpr_kill_prompt ();
       if (*response == CONTROL_L)
         tty_printf ("%s", prompt);
       else if (!response[0])
         /* Default to unknown.  Don't save it.  */
         {
+          xfree (response);
           tty_printf (_("Defaulting to unknown.\n"));
           *policy = TOFU_POLICY_UNKNOWN;
           break;
         }
       else if (!response[1])
         {
           char *choice = strchr (choices, *response);
 
           if (choice)
             {
               int c = ((size_t) choice - (size_t) choices) / 2;
+              xfree (response);
 
               switch (c)
                 {
                 case 0: /* Good.  */
                   *policy = TOFU_POLICY_GOOD;
                   *trust_level = tofu_policy_to_trust_level (*policy);
                   break;
                 case 1: /* Accept once.  */
                   *policy = TOFU_POLICY_ASK;
                   *trust_level = tofu_policy_to_trust_level (TOFU_POLICY_GOOD);
                   break;
                 case 2: /* Unknown.  */
                   *policy = TOFU_POLICY_UNKNOWN;
                   *trust_level = tofu_policy_to_trust_level (*policy);
                   break;
                 case 3: /* Reject once.  */
                   *policy = TOFU_POLICY_ASK;
                   *trust_level = tofu_policy_to_trust_level (TOFU_POLICY_BAD);
                   break;
                 case 4: /* Bad.  */
                   *policy = TOFU_POLICY_BAD;
                   *trust_level = tofu_policy_to_trust_level (*policy);
                   break;
                 default:
                   log_bug ("c should be between 0 and 4 but it is %d!", c);
                 }
 
               if (record_binding (dbs, fingerprint, email, user_id,
                                   *policy, TOFU_POLICY_NONE, NULL, 0, 0, now))
                 {
                   /* If there's an error registering the
                    * binding, don't save the signature.  */
                   *trust_level = _tofu_GET_TRUST_ERROR;
                 }
               break;
             }
         }
       xfree (response);
     }
 
   tofu_resume_batch_transaction (ctrl);
 
   xfree (prompt);
 
   signature_stats_free (stats);
 }
 
 /* Return the set of keys that conflict with the binding <fingerprint,
    email> (including the binding itself, which will be first in the
    list).  For each returned key also sets BINDING_NEW, etc.  */
 static strlist_t
 build_conflict_set (ctrl_t ctrl, tofu_dbs_t dbs,
                     PKT_public_key *pk, const char *fingerprint,
                     const char *email)
 {
   gpg_error_t rc;
   char *sqerr;
   strlist_t conflict_set = NULL;
   int conflict_set_count;
   strlist_t iter;
   kbnode_t *kb_all;
   KEYDB_HANDLE hd;
   int i;
 
   /* Get the fingerprints of any bindings that share the email address
    * and whether the bindings have a known conflict.
    *
    * Note: if the binding in question is in the DB, it will also be
    * returned.  Thus, if the result set is empty, then <email,
    * fingerprint> is a new binding.  */
   rc = gpgsql_stepx
     (dbs->db, &dbs->s.get_trust_bindings_with_this_email,
      strings_collect_cb2, &conflict_set, &sqerr,
      "select"
      /* A binding should only appear once, but try not to break in the
       * case of corruption.  */
      "  fingerprint || case sum(conflict NOTNULL) when 0 then '' else '!' end"
      " from bindings where email = ?"
      "  group by fingerprint"
      /* Make sure the current key comes first in the result list (if
         it is present).  */
      "  order by fingerprint = ? asc, fingerprint desc;",
      GPGSQL_ARG_STRING, email,
      GPGSQL_ARG_STRING, fingerprint,
      GPGSQL_ARG_END);
   if (rc)
     {
       log_error (_("error reading TOFU database: %s\n"), sqerr);
       print_further_info ("listing fingerprints");
       sqlite3_free (sqerr);
       rc = gpg_error (GPG_ERR_GENERAL);
       return NULL;
     }
 
   /* Set BINDING_CONFLICT if the binding has a known conflict.  This
    * allows us to distinguish between bindings where the user
    * explicitly set the policy to ask and bindings where we set the
    * policy to ask due to a conflict.  */
   for (iter = conflict_set; iter; iter = iter->next)
     {
       /* Fixme: Why the check against N+1?  */
       int l = strlen (iter->d);
       if (!(l == 2 * 20
             || l == 2 * 20 + 1
             || l == 2 * 32
             || l == 2 * 32 + 1))
         {
           log_error (_("TOFU db corruption detected.\n"));
           print_further_info ("fingerprint '%s' is %d characters long",
                               iter->d, l);
         }
 
       if (l >= 1 && iter->d[l - 1] == '!')
         {
           iter->flags |= BINDING_CONFLICT;
           /* Remove the !.  */
           iter->d[l - 1] = 0;
         }
     }
 
   /* If the current binding has not yet been recorded, add it to the
    * list.  (The order by above ensures that if it is present, it will
    * be first.)  */
   if (! (conflict_set && strcmp (conflict_set->d, fingerprint) == 0))
     {
       add_to_strlist (&conflict_set, fingerprint);
       conflict_set->flags |= BINDING_NEW;
     }
 
   conflict_set_count = strlist_length (conflict_set);
 
   /* Eliminate false conflicts.  */
 
   if (conflict_set_count == 1)
     /* We only have a single key.  There are no false conflicts to
        eliminate.  But, we do need to set the flags.  */
     {
       if (pk->has_expired)
         conflict_set->flags |= BINDING_EXPIRED;
       if (pk->flags.revoked)
         conflict_set->flags |= BINDING_REVOKED;
 
       return conflict_set;
     }
 
   /* If two keys have cross signatures, then they are controlled by
    * the same person and thus are not in conflict.  */
   kb_all = xcalloc (sizeof (kb_all[0]), conflict_set_count);
   hd = keydb_new (ctrl);
   for (i = 0, iter = conflict_set;
        i < conflict_set_count;
        i ++, iter = iter->next)
     {
       char *fp = iter->d;
       KEYDB_SEARCH_DESC desc;
       kbnode_t kb;
       PKT_public_key *binding_pk;
       kbnode_t n;
       int found_user_id;
 
       rc = keydb_search_reset (hd);
       if (rc)
         {
           log_error ("resetting keydb failed: %s\n", gpg_strerror (rc));
           continue;
         }
 
       rc = classify_user_id (fp, &desc, 0);
       if (rc)
         {
           log_error (_("error parsing key specification '%s': %s\n"),
                      fp, gpg_strerror (rc));
           continue;
         }
 
       rc = keydb_search (hd, &desc, 1, NULL);
       if (rc)
         {
           /* Note: it is entirely possible that we don't have the key
              corresponding to an entry in the TOFU DB.  This can
              happen if we merge two TOFU DBs, but not the key
              rings.  */
           log_info (_("key \"%s\" not found: %s\n"),
                     fp, gpg_strerror (rc));
           continue;
         }
 
       rc = keydb_get_keyblock (hd, &kb);
       if (rc)
         {
           log_error (_("error reading keyblock: %s\n"),
                      gpg_strerror (rc));
           print_further_info ("fingerprint: %s", fp);
           continue;
         }
 
       merge_keys_and_selfsig (ctrl, kb);
 
       log_assert (kb->pkt->pkttype == PKT_PUBLIC_KEY);
 
       kb_all[i] = kb;
 
       /* Since we have the key block, use this opportunity to figure
        * out if the binding is expired or revoked.  */
       binding_pk = kb->pkt->pkt.public_key;
 
       /* The binding is always expired/revoked if the key is
        * expired/revoked.  */
       if (binding_pk->has_expired)
         iter->flags |= BINDING_EXPIRED;
       if (binding_pk->flags.revoked)
         iter->flags |= BINDING_REVOKED;
 
       /* The binding is also expired/revoked if the user id is
        * expired/revoked.  */
       n = kb;
       found_user_id = 0;
       while ((n = find_next_kbnode (n, PKT_USER_ID)) && ! found_user_id)
         {
           PKT_user_id *user_id2 = n->pkt->pkt.user_id;
           char *email2;
 
           if (user_id2->attrib_data)
             continue;
 
           email2 = email_from_user_id (user_id2->name);
 
           if (strcmp (email, email2) == 0)
             {
               found_user_id = 1;
 
               if (user_id2->flags.revoked)
                 iter->flags |= BINDING_REVOKED;
               if (user_id2->flags.expired)
                 iter->flags |= BINDING_EXPIRED;
             }
 
           xfree (email2);
         }
 
       if (! found_user_id)
         {
           log_info (_("TOFU db corruption detected.\n"));
           print_further_info ("user id '%s' not on key block '%s'",
                               email, fingerprint);
         }
     }
   keydb_release (hd);
 
   /* Now that we have the key blocks, check for cross sigs.  */
   {
     int j;
     strlist_t *prevp;
     strlist_t iter_next;
     int *die;
 
     log_assert (conflict_set_count > 0);
     die = xtrycalloc (conflict_set_count, sizeof *die);
     if (!die)
       {
         /*err = gpg_error_from_syserror ();*/
         xoutofcore (); /* Fixme: Let the function return an error.  */
       }
 
     for (i = 0; i < conflict_set_count; i ++)
       {
         /* Look for cross sigs between this key (i == 0) or a key
          * that has cross sigs with i == 0 (i.e., transitively) */
         if (! (i == 0 || die[i]))
           continue;
 
         for (j = i + 1; j < conflict_set_count; j ++)
           /* Be careful: we might not have a key block for a key.  */
           if (kb_all[i] && kb_all[j] && cross_sigs (email, kb_all[i], kb_all[j]))
             die[j] = 1;
       }
 
     /* Free unconflicting bindings (and all of the key blocks).  */
     for (iter = conflict_set, prevp = &conflict_set, i = 0;
          iter;
          iter = iter_next, i ++)
       {
         iter_next = iter->next;
 
         release_kbnode (kb_all[i]);
 
         if (die[i])
           {
             *prevp = iter_next;
             iter->next = NULL;
             free_strlist (iter);
             conflict_set_count --;
           }
         else
           {
             prevp = &iter->next;
           }
       }
 
     /* We shouldn't have removed the head.  */
     log_assert (conflict_set);
     log_assert (conflict_set_count >= 1);
     xfree (die);
   }
   xfree (kb_all);
 
   if (DBG_TRUST)
     {
       log_debug ("binding <key: %s, email: %s> conflicts:\n",
                  fingerprint, email);
       for (iter = conflict_set; iter; iter = iter->next)
         {
           log_debug ("  %s:%s%s%s%s\n",
                      iter->d,
                      (iter->flags & BINDING_NEW) ? " new" : "",
                      (iter->flags & BINDING_CONFLICT) ? " known_conflict" : "",
                      (iter->flags & BINDING_EXPIRED) ? " expired" : "",
                      (iter->flags & BINDING_REVOKED) ? " revoked" : "");
         }
     }
 
   return conflict_set;
 }
 
 
 /* Return the effective policy for the binding <FINGERPRINT, EMAIL>
  * (email has already been normalized).  Returns
  * _tofu_GET_POLICY_ERROR if an error occurs.  Returns any conflict
  * information in *CONFLICT_SETP if CONFLICT_SETP is not NULL and the
  * returned policy is TOFU_POLICY_ASK (consequently, if there is a
  * conflict, but the user set the policy to good *CONFLICT_SETP will
  * empty).  Note: as per build_conflict_set, which is used to build
  * the conflict information, the conflict information includes the
  * current user id as the first element of the linked list.
  *
  * This function registers the binding in the bindings table if it has
  * not yet been registered.
  */
 static enum tofu_policy
 get_policy (ctrl_t ctrl, tofu_dbs_t dbs, PKT_public_key *pk,
             const char *fingerprint, const char *user_id, const char *email,
 	    strlist_t *conflict_setp, time_t now)
 {
   int rc;
   char *err = NULL;
   strlist_t results = NULL;
   enum tofu_policy policy = _tofu_GET_POLICY_ERROR;
   enum tofu_policy effective_policy_orig = TOFU_POLICY_NONE;
   enum tofu_policy effective_policy = _tofu_GET_POLICY_ERROR;
   long along;
   char *conflict_orig = NULL;
   char *conflict = NULL;
   strlist_t conflict_set = NULL;
   int conflict_set_count;
 
   /* Check if the <FINGERPRINT, EMAIL> binding is known
      (TOFU_POLICY_NONE cannot appear in the DB.  Thus, if POLICY is
      still TOFU_POLICY_NONE after executing the query, then the
      result set was empty.)  */
   rc = gpgsql_stepx (dbs->db, &dbs->s.get_policy_select_policy_and_conflict,
                       strings_collect_cb2, &results, &err,
                       "select policy, conflict, effective_policy from bindings\n"
                       " where fingerprint = ? and email = ?",
                       GPGSQL_ARG_STRING, fingerprint,
                       GPGSQL_ARG_STRING, email,
                       GPGSQL_ARG_END);
   if (rc)
     {
       log_error (_("error reading TOFU database: %s\n"), err);
       print_further_info ("reading the policy");
       sqlite3_free (err);
       rc = gpg_error (GPG_ERR_GENERAL);
       goto out;
     }
 
   if (strlist_length (results) == 0)
     {
       /* No results.  Use the defaults.  */
       policy = TOFU_POLICY_NONE;
       effective_policy = TOFU_POLICY_NONE;
     }
   else if (strlist_length (results) == 3)
     {
       /* Parse and sanity check the results.  */
 
       if (string_to_long (&along, results->d, 0, __LINE__))
         {
           log_error (_("error reading TOFU database: %s\n"),
                      gpg_strerror (GPG_ERR_BAD_DATA));
           print_further_info ("bad value for policy: %s", results->d);
           goto out;
         }
       policy = along;
 
       if (! (policy == TOFU_POLICY_AUTO
              || policy == TOFU_POLICY_GOOD
              || policy == TOFU_POLICY_UNKNOWN
              || policy == TOFU_POLICY_BAD
              || policy == TOFU_POLICY_ASK))
         {
           log_error (_("error reading TOFU database: %s\n"),
                      gpg_strerror (GPG_ERR_DB_CORRUPTED));
           print_further_info ("invalid value for policy (%d)", policy);
           effective_policy = _tofu_GET_POLICY_ERROR;
           goto out;
         }
 
       if (*results->next->d)
         conflict = xstrdup (results->next->d);
 
       if (string_to_long (&along, results->next->next->d, 0, __LINE__))
         {
           log_error (_("error reading TOFU database: %s\n"),
                      gpg_strerror (GPG_ERR_BAD_DATA));
           print_further_info ("bad value for effective policy: %s",
                               results->next->next->d);
           goto out;
         }
       effective_policy = along;
 
       if (! (effective_policy == TOFU_POLICY_NONE
              || effective_policy == TOFU_POLICY_AUTO
              || effective_policy == TOFU_POLICY_GOOD
              || effective_policy == TOFU_POLICY_UNKNOWN
              || effective_policy == TOFU_POLICY_BAD
              || effective_policy == TOFU_POLICY_ASK))
         {
           log_error (_("error reading TOFU database: %s\n"),
                      gpg_strerror (GPG_ERR_DB_CORRUPTED));
           print_further_info ("invalid value for effective_policy (%d)",
                               effective_policy);
           effective_policy = _tofu_GET_POLICY_ERROR;
           goto out;
         }
     }
   else
     {
       /* The result has the wrong form.  */
 
       log_error (_("error reading TOFU database: %s\n"),
                  gpg_strerror (GPG_ERR_BAD_DATA));
       print_further_info ("reading policy: expected 3 columns, got %d\n",
                           strlist_length (results));
       goto out;
     }
 
   /* Save the effective policy and conflict so we know if we changed
    * them.  */
   effective_policy_orig = effective_policy;
   conflict_orig = conflict;
 
   /* Unless there is a conflict, if the effective policy is cached,
    * just return it.  The reason we don't do this when there is a
    * conflict is because of the following scenario: assume A and B
    * conflict and B has signed A's key.  Now, later we import A's
    * signature on B.  We need to recheck A, but the signature was on
    * B, i.e., when B changes, we invalidate B's effective policy, but
    * we also need to invalidate A's effective policy.  Instead, we
    * assume that conflicts are rare and don't optimize for them, which
    * would complicate the code.  */
   if (effective_policy != TOFU_POLICY_NONE && !conflict)
     goto out;
 
   /* If the user explicitly set the policy, then respect that.  */
   if (policy != TOFU_POLICY_AUTO && policy != TOFU_POLICY_NONE)
     {
       effective_policy = policy;
       goto out;
     }
 
   /* Unless proven wrong, assume the effective policy is 'auto'.  */
   effective_policy = TOFU_POLICY_AUTO;
 
   /* See if the key is ultimately trusted.  */
   {
     u32 kid[2];
 
     keyid_from_pk (pk, kid);
     if (tdb_keyid_is_utk (kid))
       {
         effective_policy = TOFU_POLICY_GOOD;
         goto out;
       }
   }
 
   /* See if the key is signed by an ultimately trusted key.  */
   {
     int fingerprint_raw_len = strlen (fingerprint) / 2;
     char fingerprint_raw[MAX_FINGERPRINT_LEN];
     int len = 0;
 
     /* FIXME(fingerprint) */
     if (fingerprint_raw_len != 20 /*sizeof fingerprint_raw */
         || ((len = hex2bin (fingerprint,
                             fingerprint_raw, fingerprint_raw_len))
             != strlen (fingerprint)))
       {
         if (DBG_TRUST)
           log_debug ("TOFU: Bad fingerprint: %s (len: %zu, parsed: %d)\n",
                      fingerprint, strlen (fingerprint), len);
       }
     else
       {
         int lookup_err;
         kbnode_t kb;
 
         lookup_err = get_pubkey_byfprint (ctrl, NULL, &kb,
                                           fingerprint_raw,
                                           fingerprint_raw_len);
         if (lookup_err)
           {
             if (DBG_TRUST)
               log_debug ("TOFU: Looking up %s: %s\n",
                          fingerprint, gpg_strerror (lookup_err));
           }
         else
           {
             int is_signed_by_utk = signed_by_utk (email, kb);
             release_kbnode (kb);
             if (is_signed_by_utk)
               {
                 effective_policy = TOFU_POLICY_GOOD;
                 goto out;
               }
           }
       }
   }
 
   /* Check for any conflicts / see if a previously discovered conflict
    * disappeared.  The latter can happen if the conflicting bindings
    * are now cross signed, for instance.  */
 
   conflict_set = build_conflict_set (ctrl, dbs, pk, fingerprint, email);
   conflict_set_count = strlist_length (conflict_set);
   if (conflict_set_count == 0)
     {
       /* build_conflict_set should always at least return the current
          binding.  Something went wrong.  */
       effective_policy = _tofu_GET_POLICY_ERROR;
       goto out;
     }
 
   if (conflict_set_count == 1
       && (conflict_set->flags & BINDING_NEW))
     {
       /* We've never observed a binding with this email address and we
        * have a default policy, which is not to ask the user.  */
 
       /* If we've seen this binding, then we've seen this email and
        * policy couldn't possibly be TOFU_POLICY_NONE.  */
       log_assert (policy == TOFU_POLICY_NONE);
 
       if (DBG_TRUST)
 	log_debug ("TOFU: New binding <key: %s, user id: %s>, no conflict.\n",
 		   fingerprint, email);
 
       effective_policy = TOFU_POLICY_AUTO;
       goto out;
     }
 
   if (conflict_set_count == 1
       && (conflict_set->flags & BINDING_CONFLICT))
     {
       /* No known conflicts now, but there was a conflict.  This means
        * at some point, there was a conflict and we changed this
        * binding's policy to ask and set the conflicting key.  The
        * conflict can go away if there is not a cross sig between the
        * two keys.  In this case, just silently clear the conflict and
        * reset the policy to auto.  */
 
       if (DBG_TRUST)
         log_debug ("TOFU: binding <key: %s, user id: %s> had a conflict, but it's been resolved (probably via  cross sig).\n",
                    fingerprint, email);
 
       effective_policy = TOFU_POLICY_AUTO;
       conflict = NULL;
 
       goto out;
     }
 
   if (conflict_set_count == 1)
     {
       /* No conflicts and never marked as conflicting.  */
 
       log_assert (!conflict);
 
       effective_policy = TOFU_POLICY_AUTO;
 
       goto out;
     }
 
   /* There is a conflicting key.  */
   log_assert (conflict_set_count > 1);
   effective_policy = TOFU_POLICY_ASK;
   conflict = xstrdup (conflict_set->next->d);
 
  out:
   log_assert (policy == _tofu_GET_POLICY_ERROR
               || policy == TOFU_POLICY_NONE
               || policy == TOFU_POLICY_AUTO
               || policy == TOFU_POLICY_GOOD
               || policy == TOFU_POLICY_UNKNOWN
               || policy == TOFU_POLICY_BAD
               || policy == TOFU_POLICY_ASK);
   /* Everything but NONE.  */
   log_assert (effective_policy == _tofu_GET_POLICY_ERROR
               || effective_policy == TOFU_POLICY_AUTO
               || effective_policy == TOFU_POLICY_GOOD
               || effective_policy == TOFU_POLICY_UNKNOWN
               || effective_policy == TOFU_POLICY_BAD
               || effective_policy == TOFU_POLICY_ASK);
 
   if (effective_policy != TOFU_POLICY_ASK && conflict)
     conflict = NULL;
 
   /* If we don't have a record of this binding, its effective policy
    * changed, or conflict changed, update the DB.  */
   if (effective_policy != _tofu_GET_POLICY_ERROR
       && (/* New binding.  */
           policy == TOFU_POLICY_NONE
           /* effective_policy changed.  */
           || effective_policy != effective_policy_orig
           /* conflict changed.  */
           || (conflict != conflict_orig
               && (!conflict || !conflict_orig
                   || strcmp (conflict, conflict_orig) != 0))))
     {
       if (record_binding (dbs, fingerprint, email, user_id,
                           policy == TOFU_POLICY_NONE ? TOFU_POLICY_AUTO : policy,
                           effective_policy, conflict, 1, 0, now) != 0)
         log_error ("error setting TOFU binding's policy"
                      " to %s\n", tofu_policy_str (policy));
     }
 
   /* If the caller wants the set of conflicts, return it.  */
   if (effective_policy == TOFU_POLICY_ASK && conflict_setp)
     {
       if (! conflict_set)
         conflict_set = build_conflict_set (ctrl, dbs, pk, fingerprint, email);
       *conflict_setp = conflict_set;
     }
   else
     {
       free_strlist (conflict_set);
 
       if (conflict_setp)
         *conflict_setp = NULL;
     }
 
   xfree (conflict_orig);
   if (conflict != conflict_orig)
     xfree (conflict);
   free_strlist (results);
 
   return effective_policy;
 }
 
 
 /* Return the trust level (TRUST_NEVER, etc.) for the binding
  * <FINGERPRINT, EMAIL> (email is already normalized).  If no policy
  * is registered, returns TOFU_POLICY_NONE.  If an error occurs,
  * returns _tofu_GET_TRUST_ERROR.
  *
  * PK is the public key object for FINGERPRINT.
  *
  * USER_ID is the unadulterated user id.
  *
  * If MAY_ASK is set, then we may interact with the user.  This is
  * necessary if there is a conflict or the binding's policy is
  * TOFU_POLICY_ASK.  In the case of a conflict, we set the new
  * conflicting binding's policy to TOFU_POLICY_ASK.  In either case,
  * we return TRUST_UNDEFINED.  Note: if MAY_ASK is set, then this
  * function must not be called while in a transaction!  */
 static enum tofu_policy
 get_trust (ctrl_t ctrl, PKT_public_key *pk,
            const char *fingerprint, const char *email,
            const char *user_id, int may_ask,
            enum tofu_policy *policyp, strlist_t *conflict_setp,
            time_t now)
 {
   tofu_dbs_t dbs = ctrl->tofu.dbs;
   int in_transaction = 0;
   enum tofu_policy policy;
   int rc;
   char *sqerr = NULL;
   strlist_t conflict_set = NULL;
   int trust_level = TRUST_UNKNOWN;
   strlist_t iter;
 
   log_assert (dbs);
 
   if (may_ask)
     log_assert (dbs->in_transaction == 0);
 
   if (opt.batch)
     may_ask = 0;
 
   log_assert (pk_is_primary (pk));
 
   /* Make sure _tofu_GET_TRUST_ERROR isn't equal to any of the trust
      levels.  */
   log_assert (_tofu_GET_TRUST_ERROR != TRUST_UNKNOWN
               && _tofu_GET_TRUST_ERROR != TRUST_EXPIRED
               && _tofu_GET_TRUST_ERROR != TRUST_UNDEFINED
               && _tofu_GET_TRUST_ERROR != TRUST_NEVER
               && _tofu_GET_TRUST_ERROR != TRUST_MARGINAL
               && _tofu_GET_TRUST_ERROR != TRUST_FULLY
               && _tofu_GET_TRUST_ERROR != TRUST_ULTIMATE);
 
   begin_transaction (ctrl, 0);
   in_transaction = 1;
 
   /* We need to call get_policy even if the key is ultimately trusted
    * to make sure the binding has been registered.  */
   policy = get_policy (ctrl, dbs, pk, fingerprint, user_id, email,
                        &conflict_set, now);
 
   if (policy == TOFU_POLICY_ASK)
     /* The conflict set should always contain at least one element:
      * the current key.  */
     log_assert (conflict_set);
   else
     /* If the policy is not TOFU_POLICY_ASK, then conflict_set will be
      * NULL.  */
     log_assert (! conflict_set);
 
   /* If the key is ultimately trusted, there is nothing to do.  */
   {
     u32 kid[2];
 
     keyid_from_pk (pk, kid);
     if (tdb_keyid_is_utk (kid))
       {
         trust_level = TRUST_ULTIMATE;
         policy = TOFU_POLICY_GOOD;
         goto out;
       }
   }
 
   if (policy == TOFU_POLICY_AUTO)
     {
       policy = opt.tofu_default_policy;
       if (DBG_TRUST)
 	log_debug ("TOFU: binding <key: %s, user id: %s>'s policy is"
                    " auto (default: %s).\n",
 		   fingerprint, email,
 		   tofu_policy_str (opt.tofu_default_policy));
 
       if (policy == TOFU_POLICY_ASK)
         /* The default policy is ASK, but there is no conflict (policy
          * was 'auto').  In this case, we need to make sure the
          * conflict set includes at least the current user id.  */
         {
           add_to_strlist (&conflict_set, fingerprint);
         }
     }
   switch (policy)
     {
     case TOFU_POLICY_AUTO:
     case TOFU_POLICY_GOOD:
     case TOFU_POLICY_UNKNOWN:
     case TOFU_POLICY_BAD:
       /* The saved judgement is auto -> auto, good, unknown or bad.
        * We don't need to ask the user anything.  */
       if (DBG_TRUST)
 	log_debug ("TOFU: Known binding <key: %s, user id: %s>'s policy: %s\n",
 		   fingerprint, email, tofu_policy_str (policy));
       trust_level = tofu_policy_to_trust_level (policy);
       goto out;
 
     case TOFU_POLICY_ASK:
       /* We need to ask the user what to do.  */
       break;
 
     case _tofu_GET_POLICY_ERROR:
       trust_level = _tofu_GET_TRUST_ERROR;
       goto out;
 
     default:
       log_bug ("%s: Impossible value for policy (%d)\n", __func__, policy);
     }
 
 
   /* We get here if:
    *
    *   1. The saved policy is auto and the default policy is ask
    *      (get_policy() == TOFU_POLICY_AUTO
    *       && opt.tofu_default_policy == TOFU_POLICY_ASK)
    *
    *   2. The saved policy is ask (either last time the user selected
    *      accept once or reject once or there was a conflict and this
    *      binding's policy was changed from auto to ask)
    *      (policy == TOFU_POLICY_ASK).
    */
   log_assert (policy == TOFU_POLICY_ASK);
 
   if (may_ask)
     {
       /* We can't be in a normal transaction in ask_about_binding.  */
       end_transaction (ctrl, 0);
       in_transaction = 0;
 
       /* If we get here, we need to ask the user about the binding.  */
       ask_about_binding (ctrl,
                          &policy,
                          &trust_level,
                          conflict_set,
                          fingerprint,
                          email,
                          user_id,
                          now);
     }
   else
     {
       trust_level = TRUST_UNDEFINED;
     }
 
   /* Mark any conflicting bindings that have an automatic policy as
    * now requiring confirmation.  Note: we do this after we ask for
    * confirmation so that when the current policy is printed, it is
    * correct.  */
   if (! in_transaction)
     {
       begin_transaction (ctrl, 0);
       in_transaction = 1;
     }
 
   /* The conflict set should always contain at least one element:
    * the current key.  */
   log_assert (conflict_set);
 
   for (iter = conflict_set->next; iter; iter = iter->next)
     {
       /* We don't immediately set the effective policy to 'ask,
          because  */
       rc = gpgsql_exec_printf
         (dbs->db, NULL, NULL, &sqerr,
          "update bindings set effective_policy = %d, conflict = %Q"
          " where email = %Q and fingerprint = %Q and effective_policy != %d;",
          TOFU_POLICY_NONE, fingerprint,
          email, iter->d, TOFU_POLICY_ASK);
       if (rc)
         {
           log_error (_("error changing TOFU policy: %s\n"), sqerr);
           print_further_info ("binding: <key: %s, user id: %s>",
                               fingerprint, user_id);
           sqlite3_free (sqerr);
           sqerr = NULL;
           rc = gpg_error (GPG_ERR_GENERAL);
         }
       else if (DBG_TRUST)
         log_debug ("Set %s to conflict with %s\n",
                    iter->d, fingerprint);
     }
 
  out:
   if (in_transaction)
     end_transaction (ctrl, 0);
 
   if (policyp)
     *policyp = policy;
 
   if (conflict_setp)
     *conflict_setp = conflict_set;
   else
     free_strlist (conflict_set);
 
   return trust_level;
 }
 
 
 /* Return a malloced string of the form
  *    "7~months"
  * The caller should replace all '~' in the returned string by a space
  * and also free the returned string.
  *
  * This is actually a bad hack which may not work correctly with all
  * languages.
  */
 static char *
 time_ago_str (long long int t)
 {
   /* It would be nice to use a macro to do this, but gettext
      works on the unpreprocessed code.  */
 #define MIN_SECS (60)
 #define HOUR_SECS (60 * MIN_SECS)
 #define DAY_SECS (24 * HOUR_SECS)
 #define WEEK_SECS (7 * DAY_SECS)
 #define MONTH_SECS (30 * DAY_SECS)
 #define YEAR_SECS (365 * DAY_SECS)
 
   if (t > 2 * YEAR_SECS)
     {
       long long int c = t / YEAR_SECS;
       return xtryasprintf (ngettext("%lld~year", "%lld~years", c), c);
     }
   if (t > 2 * MONTH_SECS)
     {
       long long int c = t / MONTH_SECS;
       return xtryasprintf (ngettext("%lld~month", "%lld~months", c), c);
     }
   if (t > 2 * WEEK_SECS)
     {
       long long int c = t / WEEK_SECS;
       return xtryasprintf (ngettext("%lld~week", "%lld~weeks", c), c);
     }
   if (t > 2 * DAY_SECS)
     {
       long long int c = t / DAY_SECS;
       return xtryasprintf (ngettext("%lld~day", "%lld~days", c), c);
     }
   if (t > 2 * HOUR_SECS)
     {
       long long int c = t / HOUR_SECS;
       return xtryasprintf (ngettext("%lld~hour", "%lld~hours", c), c);
     }
   if (t > 2 * MIN_SECS)
     {
       long long int c = t / MIN_SECS;
       return xtryasprintf (ngettext("%lld~minute", "%lld~minutes", c), c);
     }
   return xtryasprintf (ngettext("%lld~second", "%lld~seconds", t), t);
 }
 
 
 /* If FP is NULL, write TOFU_STATS status line.  If FP is not NULL
  * write a "tfs" record to that stream. */
 static void
 write_stats_status (estream_t fp,
                     enum tofu_policy policy,
                     unsigned long signature_count,
                     unsigned long signature_first_seen,
                     unsigned long signature_most_recent,
                     unsigned long signature_days,
                     unsigned long encryption_count,
                     unsigned long encryption_first_done,
                     unsigned long encryption_most_recent,
                     unsigned long encryption_days)
 {
   int summary;
   int validity;
   unsigned long days_sq;
 
   /* Use the euclidean distance (m = sqrt(a^2 + b^2)) rather then the
      sum of the magnitudes (m = a + b) to ensure a balance between
      verified signatures and encrypted messages.  */
   days_sq = signature_days * signature_days + encryption_days * encryption_days;
 
   if (days_sq < 1)
     validity = 1; /* Key without history.  */
   else if (days_sq < (2 * BASIC_TRUST_THRESHOLD) * (2 * BASIC_TRUST_THRESHOLD))
     validity = 2; /* Key with too little history.  */
   else if (days_sq < (2 * FULL_TRUST_THRESHOLD) * (2 * FULL_TRUST_THRESHOLD))
     validity = 3; /* Key with enough history for basic trust.  */
   else
     validity = 4; /* Key with a lot of history.  */
 
   if (policy == TOFU_POLICY_ASK)
     summary = 0; /* Key requires attention.  */
   else
     summary = validity;
 
   if (fp)
     {
       es_fprintf (fp, "tfs:1:%d:%lu:%lu:%s:%lu:%lu:%lu:%lu:%d:%lu:%lu:\n",
                   summary, signature_count, encryption_count,
                   tofu_policy_str (policy),
                   signature_first_seen, signature_most_recent,
                   encryption_first_done, encryption_most_recent,
                   validity, signature_days, encryption_days);
     }
   else
     {
       write_status_printf (STATUS_TOFU_STATS,
                            "%d %lu %lu %s %lu %lu %lu %lu %d %lu %lu",
                            summary,
                            signature_count,
                            encryption_count,
                            tofu_policy_str (policy),
                            signature_first_seen,
                            signature_most_recent,
                            encryption_first_done,
                            encryption_most_recent,
                            validity,
                            signature_days, encryption_days);
     }
 }
 
 /* Note: If OUTFP is not NULL, this function merely prints a "tfs" record
  * to OUTFP.
  *
  * POLICY is the key's policy (as returned by get_policy).
  *
  * Returns 0 if ONLY_STATUS_FD is set.  Otherwise, returns whether
  * the caller should call show_warning after iterating over all user
  * ids.
  */
 static int
 show_statistics (tofu_dbs_t dbs,
                  const char *fingerprint, const char *email,
                  enum tofu_policy policy,
 		 estream_t outfp, int only_status_fd, time_t now)
 {
   char *fingerprint_pp;
   int rc;
   strlist_t strlist = NULL;
   char *err = NULL;
 
   unsigned long signature_first_seen = 0;
   unsigned long signature_most_recent = 0;
   unsigned long signature_count = 0;
   unsigned long signature_days = 0;
   unsigned long encryption_first_done = 0;
   unsigned long encryption_most_recent = 0;
   unsigned long encryption_count = 0;
   unsigned long encryption_days = 0;
 
   int show_warning = 0;
 
   if (only_status_fd && ! is_status_enabled ())
     return 0;
 
   fingerprint_pp = format_hexfingerprint (fingerprint, NULL, 0);
 
   /* Get the signature stats.  */
   rc = gpgsql_exec_printf
     (dbs->db, strings_collect_cb, &strlist, &err,
      "select count (*), coalesce (min (signatures.time), 0),\n"
      "  coalesce (max (signatures.time), 0)\n"
      " from signatures\n"
      " left join bindings on signatures.binding = bindings.oid\n"
      " where fingerprint = %Q and email = %Q;",
      fingerprint, email);
   if (rc)
     {
       log_error (_("error reading TOFU database: %s\n"), err);
       print_further_info ("getting signature statistics");
       sqlite3_free (err);
       rc = gpg_error (GPG_ERR_GENERAL);
       goto out;
     }
   rc = gpgsql_exec_printf
     (dbs->db, strings_collect_cb, &strlist, &err,
      "select count (*) from\n"
      "  (select round(signatures.time / (24 * 60 * 60)) day\n"
      "    from signatures\n"
      "    left join bindings on signatures.binding = bindings.oid\n"
      "    where fingerprint = %Q and email = %Q\n"
      "    group by day);",
      fingerprint, email);
   if (rc)
     {
       log_error (_("error reading TOFU database: %s\n"), err);
       print_further_info ("getting signature statistics (by day)");
       sqlite3_free (err);
       rc = gpg_error (GPG_ERR_GENERAL);
       goto out;
     }
 
   if (strlist)
     {
       /* We expect exactly 4 elements.  */
       log_assert (strlist->next);
       log_assert (strlist->next->next);
       log_assert (strlist->next->next->next);
       log_assert (! strlist->next->next->next->next);
 
       string_to_ulong (&signature_days, strlist->d, -1, __LINE__);
       string_to_ulong (&signature_count, strlist->next->d, -1, __LINE__);
       string_to_ulong (&signature_first_seen,
                        strlist->next->next->d, -1, __LINE__);
       string_to_ulong (&signature_most_recent,
                        strlist->next->next->next->d, -1, __LINE__);
 
       free_strlist (strlist);
       strlist = NULL;
     }
 
   /* Get the encryption stats.  */
   rc = gpgsql_exec_printf
     (dbs->db, strings_collect_cb, &strlist, &err,
      "select count (*), coalesce (min (encryptions.time), 0),\n"
      "  coalesce (max (encryptions.time), 0)\n"
      " from encryptions\n"
      " left join bindings on encryptions.binding = bindings.oid\n"
      " where fingerprint = %Q and email = %Q;",
      fingerprint, email);
   if (rc)
     {
       log_error (_("error reading TOFU database: %s\n"), err);
       print_further_info ("getting encryption statistics");
       sqlite3_free (err);
       rc = gpg_error (GPG_ERR_GENERAL);
       goto out;
     }
   rc = gpgsql_exec_printf
     (dbs->db, strings_collect_cb, &strlist, &err,
      "select count (*) from\n"
      "  (select round(encryptions.time / (24 * 60 * 60)) day\n"
      "    from encryptions\n"
      "    left join bindings on encryptions.binding = bindings.oid\n"
      "    where fingerprint = %Q and email = %Q\n"
      "    group by day);",
      fingerprint, email);
   if (rc)
     {
       log_error (_("error reading TOFU database: %s\n"), err);
       print_further_info ("getting encryption statistics (by day)");
       sqlite3_free (err);
       rc = gpg_error (GPG_ERR_GENERAL);
       goto out;
     }
 
   if (strlist)
     {
       /* We expect exactly 4 elements.  */
       log_assert (strlist->next);
       log_assert (strlist->next->next);
       log_assert (strlist->next->next->next);
       log_assert (! strlist->next->next->next->next);
 
       string_to_ulong (&encryption_days, strlist->d, -1, __LINE__);
       string_to_ulong (&encryption_count, strlist->next->d, -1, __LINE__);
       string_to_ulong (&encryption_first_done,
                        strlist->next->next->d, -1, __LINE__);
       string_to_ulong (&encryption_most_recent,
                        strlist->next->next->next->d, -1, __LINE__);
 
       free_strlist (strlist);
       strlist = NULL;
     }
 
   if (!outfp)
     write_status_text_and_buffer (STATUS_TOFU_USER, fingerprint,
                                   email, strlen (email), 0);
 
   write_stats_status (outfp, policy,
                       signature_count,
                       signature_first_seen,
                       signature_most_recent,
                       signature_days,
                       encryption_count,
                       encryption_first_done,
                       encryption_most_recent,
                       encryption_days);
 
   if (!outfp && !only_status_fd)
     {
       estream_t fp;
       char *msg;
 
       fp = es_fopenmem (0, "rw,samethread");
       if (! fp)
         log_fatal ("error creating memory stream: %s\n",
                    gpg_strerror (gpg_error_from_syserror()));
 
       if (signature_count == 0 && encryption_count == 0)
         {
           es_fprintf (fp,
                       _("%s: Verified 0~signatures and encrypted 0~messages."),
                       email);
         }
       else
         {
           if (signature_count == 0)
             es_fprintf (fp, _("%s: Verified 0 signatures."), email);
           else
             {
               /* Note: Translation not possible with that wording.  */
               char *ago_str = time_ago_str (now - signature_first_seen);
               es_fprintf
                 (fp, "%s: Verified %ld~signatures in the past %s.",
                  email, signature_count, ago_str);
               xfree (ago_str);
             }
 
           es_fputs ("  ", fp);
 
           if (encryption_count == 0)
             es_fprintf (fp, _("Encrypted 0 messages."));
           else
             {
               char *ago_str = time_ago_str (now - encryption_first_done);
 
               /* Note: Translation not possible with this kind of
                * composition.  */
               es_fprintf (fp, "Encrypted %ld~messages in the past %s.",
                           encryption_count, ago_str);
               xfree (ago_str);
             }
         }
 
       if (opt.verbose)
         {
           es_fputs ("  ", fp);
           es_fprintf (fp, _("(policy: %s)"), tofu_policy_str (policy));
         }
       es_fputs ("\n", fp);
 
 
       {
         char *tmpmsg, *p;
         es_fputc (0, fp);
         if (es_fclose_snatch (fp, (void **) &tmpmsg, NULL))
           log_fatal ("error snatching memory stream\n");
         msg = format_text (tmpmsg, 72, 80);
         if (!msg) /* FIXME: Return the error all the way up.  */
           log_fatal ("format failed: %s\n",
                      gpg_strerror (gpg_error_from_syserror()));
         es_free (tmpmsg);
 
         /* Print a status line but suppress the trailing LF.
          * Spaces are not percent escaped. */
         if (*msg)
           write_status_buffer (STATUS_TOFU_STATS_LONG,
                                msg, strlen (msg)-1, -1);
 
         /* Remove the non-breaking space markers.  */
         for (p=msg; *p; p++)
           if (*p == '~')
             *p = ' ';
       }
 
       log_string (GPGRT_LOGLVL_INFO, msg);
       xfree (msg);
 
       if (policy == TOFU_POLICY_AUTO)
         {
           if (signature_count == 0)
             log_info (_("Warning: we have yet to see"
                         " a message signed using this key and user id!\n"));
           else if (signature_count == 1)
             log_info (_("Warning: we've only seen one message"
                         " signed using this key and user id!\n"));
 
           if (encryption_count == 0)
             log_info (_("Warning: you have yet to encrypt"
                         " a message to this key!\n"));
           else if (encryption_count == 1)
             log_info (_("Warning: you have only encrypted"
                         " one message to this key!\n"));
 
           /* Cf. write_stats_status  */
           if ((encryption_count * encryption_count
 	       + signature_count * signature_count)
 	      < ((2 * BASIC_TRUST_THRESHOLD) * (2 * BASIC_TRUST_THRESHOLD)))
             show_warning = 1;
         }
     }
 
  out:
   xfree (fingerprint_pp);
 
   return show_warning;
 }
 
 static void
 show_warning (const char *fingerprint, strlist_t user_id_list)
 {
   char *set_policy_command;
   char *text;
   char *tmpmsg;
 
   set_policy_command =
     xasprintf ("gpg --tofu-policy bad %s", fingerprint);
 
   tmpmsg = xasprintf
     (ngettext
      ("Warning: if you think you've seen more signatures "
       "by this key and user id, then this key might be a "
       "forgery!  Carefully examine the email address for small "
       "variations.  If the key is suspect, then use\n"
       "  %s\n"
       "to mark it as being bad.\n",
       "Warning: if you think you've seen more signatures "
       "by this key and these user ids, then this key might be a "
       "forgery!  Carefully examine the email addresses for small "
       "variations.  If the key is suspect, then use\n"
       "  %s\n"
       "to mark it as being bad.\n",
       strlist_length (user_id_list)),
      set_policy_command);
 
   text = format_text (tmpmsg, 72, 80);
   if (!text) /* FIXME: Return the error all the way up.  */
     log_fatal ("format failed: %s\n",
                gpg_strerror (gpg_error_from_syserror()));
   xfree (tmpmsg);
   log_string (GPGRT_LOGLVL_INFO, text);
   xfree (text);
 
   es_free (set_policy_command);
 }
 
 
 /* Extract the email address from a user id and normalize it.  If the
    user id doesn't contain an email address, then we use the whole
    user_id and normalize that.  The returned string must be freed.  */
 static char *
 email_from_user_id (const char *user_id)
 {
   char *email = mailbox_from_userid (user_id, 0);
   if (! email)
     {
       /* Hmm, no email address was provided or we are out of core.  Just
          take the lower-case version of the whole user id.  It could be
          a hostname, for instance.  */
       email = ascii_strlwr (xstrdup (user_id));
     }
 
   return email;
 }
 
 /* Register the signature with the bindings <fingerprint, USER_ID>,
    for each USER_ID in USER_ID_LIST.  The fingerprint is taken from
    the primary key packet PK.
 
    SIG_DIGEST_BIN is the binary representation of the message's
    digest.  SIG_DIGEST_BIN_LEN is its length.
 
    SIG_TIME is the time that the signature was generated.
 
    ORIGIN is a free-formed string describing the origin of the
    signature.  If this was from an email and the Claws MUA was used,
    then this should be something like: "email:claws".  If this is
    NULL, the default is simply "unknown".
 
    If MAY_ASK is 1, then this function may interact with the user.
    This is necessary if there is a conflict or the binding's policy is
    TOFU_POLICY_ASK.
 
    This function returns 0 on success and an error code if an error
    occurred.  */
 gpg_error_t
 tofu_register_signature (ctrl_t ctrl,
                          PKT_public_key *pk, strlist_t user_id_list,
                          const byte *sig_digest_bin, int sig_digest_bin_len,
                          time_t sig_time, const char *origin)
 {
   time_t now = gnupg_get_time ();
   gpg_error_t rc;
   tofu_dbs_t dbs;
   char *fingerprint = NULL;
   strlist_t user_id;
   char *email = NULL;
   char *sqlerr = NULL;
   char *sig_digest = NULL;
   unsigned long c;
 
   dbs = opendbs (ctrl);
   if (! dbs)
     {
       rc = gpg_error (GPG_ERR_GENERAL);
       log_error (_("error opening TOFU database: %s\n"),
                  gpg_strerror (rc));
       return rc;
     }
 
   /* We do a query and then an insert.  Make sure they are atomic
      by wrapping them in a transaction.  */
   rc = begin_transaction (ctrl, 0);
   if (rc)
     return rc;
 
   log_assert (pk_is_primary (pk));
 
   sig_digest = make_radix64_string (sig_digest_bin, sig_digest_bin_len);
   if (!sig_digest)
     {
       rc = gpg_error_from_syserror ();
       goto leave;
     }
   fingerprint = hexfingerprint (pk, NULL, 0);
   if (!fingerprint)
     {
       rc = gpg_error_from_syserror ();
       goto leave;
     }
 
   if (! origin)
     origin = "unknown";  /* The default origin is simply "unknown".  */
 
   for (user_id = user_id_list; user_id; user_id = user_id->next)
     {
       email = email_from_user_id (user_id->d);
 
       if (DBG_TRUST)
 	log_debug ("TOFU: Registering signature %s with binding"
                    " <key: %s, user id: %s>\n",
 		   sig_digest, fingerprint, email);
 
       /* Make sure the binding exists and record any TOFU
          conflicts.  */
       if (get_trust (ctrl, pk, fingerprint, email, user_id->d,
                      0, NULL, NULL, now)
           == _tofu_GET_TRUST_ERROR)
         {
           rc = gpg_error (GPG_ERR_GENERAL);
           xfree (email);
           break;
         }
 
       /* If we've already seen this signature before, then don't add
          it again.  */
       rc = gpgsql_stepx
         (dbs->db, &dbs->s.register_already_seen,
          get_single_unsigned_long_cb2, &c, &sqlerr,
          "select count (*)\n"
          " from signatures left join bindings\n"
          "  on signatures.binding = bindings.oid\n"
          " where fingerprint = ? and email = ? and sig_time = ?\n"
          "  and sig_digest = ?",
          GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
          GPGSQL_ARG_LONG_LONG, (long long) sig_time,
          GPGSQL_ARG_STRING, sig_digest,
          GPGSQL_ARG_END);
       if (rc)
         {
           log_error (_("error reading TOFU database: %s\n"), sqlerr);
           print_further_info ("checking existence");
           sqlite3_free (sqlerr);
           rc = gpg_error (GPG_ERR_GENERAL);
         }
       else if (c > 1)
         /* Duplicates!  This should not happen.  In particular,
            because <fingerprint, email, sig_time, sig_digest> is the
            primary key!  */
         log_debug ("SIGNATURES DB contains duplicate records"
                    " <key: %s, email: %s, time: 0x%lx, sig: %s,"
                    " origin: %s>."
                    "  Please report.\n",
                    fingerprint, email, (unsigned long) sig_time,
                    sig_digest, origin);
       else if (c == 1)
         {
           if (DBG_TRUST)
             log_debug ("Already observed the signature and binding"
                        " <key: %s, email: %s, time: 0x%lx, sig: %s,"
                        " origin: %s>\n",
                        fingerprint, email, (unsigned long) sig_time,
                        sig_digest, origin);
         }
       else if (opt.dry_run)
         {
           log_info ("TOFU database update skipped due to --dry-run\n");
         }
       else
         /* This is the first time that we've seen this signature and
            binding.  Record it.  */
         {
           if (DBG_TRUST)
             log_debug ("TOFU: Saving signature"
                        " <key: %s, user id: %s, sig: %s>\n",
                        fingerprint, email, sig_digest);
 
           log_assert (c == 0);
 
           rc = gpgsql_stepx
             (dbs->db, &dbs->s.register_signature, NULL, NULL, &sqlerr,
              "insert into signatures\n"
              " (binding, sig_digest, origin, sig_time, time)\n"
              " values\n"
              " ((select oid from bindings\n"
              "    where fingerprint = ? and email = ?),\n"
              "  ?, ?, ?, ?);",
              GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
              GPGSQL_ARG_STRING, sig_digest, GPGSQL_ARG_STRING, origin,
              GPGSQL_ARG_LONG_LONG, (long long) sig_time,
              GPGSQL_ARG_LONG_LONG, (long long) now,
              GPGSQL_ARG_END);
           if (rc)
             {
               log_error (_("error updating TOFU database: %s\n"), sqlerr);
               print_further_info ("insert signatures");
               sqlite3_free (sqlerr);
               rc = gpg_error (GPG_ERR_GENERAL);
             }
         }
 
       xfree (email);
 
       if (rc)
         break;
     }
 
  leave:
   if (rc)
     rollback_transaction (ctrl);
   else
     rc = end_transaction (ctrl, 0);
 
   xfree (fingerprint);
   xfree (sig_digest);
 
   return rc;
 }
 
 gpg_error_t
 tofu_register_encryption (ctrl_t ctrl,
                           PKT_public_key *pk, strlist_t user_id_list,
                           int may_ask)
 {
   time_t now = gnupg_get_time ();
   gpg_error_t rc = 0;
   tofu_dbs_t dbs;
   kbnode_t kb = NULL;
   int free_user_id_list = 0;
   char *fingerprint = NULL;
   strlist_t user_id;
   char *sqlerr = NULL;
   int in_batch = 0;
 
   dbs = opendbs (ctrl);
   if (! dbs)
     {
       rc = gpg_error (GPG_ERR_GENERAL);
       log_error (_("error opening TOFU database: %s\n"),
                  gpg_strerror (rc));
       return rc;
     }
 
   if (/* We need the key block to find the primary key.  */
       ! pk_is_primary (pk)
       /* We need the key block to find all user ids.  */
       || ! user_id_list)
     kb = get_pubkeyblock (ctrl, pk->keyid);
 
   /* Make sure PK is a primary key.  */
   if (! pk_is_primary (pk))
     pk = kb->pkt->pkt.public_key;
 
   if (! user_id_list)
     {
       /* Use all non-revoked user ids.  Do use expired user ids.  */
       kbnode_t n = kb;
 
       while ((n = find_next_kbnode (n, PKT_USER_ID)))
         {
 	  PKT_user_id *uid = n->pkt->pkt.user_id;
 
           if (uid->flags.revoked)
             continue;
 
           add_to_strlist (&user_id_list, uid->name);
         }
 
       free_user_id_list = 1;
 
       if (! user_id_list)
         log_info (_("WARNING: Encrypting to %s, which has no "
                     "non-revoked user ids\n"),
                   keystr (pk->keyid));
     }
 
   fingerprint = hexfingerprint (pk, NULL, 0);
   if (!fingerprint)
     {
       rc = gpg_error_from_syserror ();
       goto leave;
     }
 
   tofu_begin_batch_update (ctrl);
   in_batch = 1;
   tofu_resume_batch_transaction (ctrl);
 
   for (user_id = user_id_list; user_id; user_id = user_id->next)
     {
       char *email = email_from_user_id (user_id->d);
       strlist_t conflict_set = NULL;
       enum tofu_policy policy;
 
       /* Make sure the binding exists and that we recognize any
          conflicts.  */
       int tl = get_trust (ctrl, pk, fingerprint, email, user_id->d,
                           may_ask, &policy, &conflict_set, now);
       if (tl == _tofu_GET_TRUST_ERROR)
         {
           /* An error.  */
           rc = gpg_error (GPG_ERR_GENERAL);
           xfree (email);
           goto leave;
         }
 
 
       /* If there is a conflict and MAY_ASK is true, we need to show
        * the TOFU statistics for the current binding and the
        * conflicting bindings.  But, if we are not in batch mode, then
        * they have already been printed (this is required to make sure
        * the information is available to the caller before cpr_get is
        * called).  */
       if (policy == TOFU_POLICY_ASK && may_ask && opt.batch)
         {
           strlist_t iter;
 
           /* The conflict set should contain at least the current
            * key.  */
           log_assert (conflict_set);
 
           for (iter = conflict_set; iter; iter = iter->next)
             show_statistics (dbs, iter->d, email,
                              TOFU_POLICY_ASK, NULL, 1, now);
         }
 
       free_strlist (conflict_set);
 
       rc = gpgsql_stepx
         (dbs->db, &dbs->s.register_encryption, NULL, NULL, &sqlerr,
          "insert into encryptions\n"
          " (binding, time)\n"
          " values\n"
          " ((select oid from bindings\n"
          "    where fingerprint = ? and email = ?),\n"
          "  ?);",
          GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
          GPGSQL_ARG_LONG_LONG, (long long) now,
          GPGSQL_ARG_END);
       if (rc)
         {
           log_error (_("error updating TOFU database: %s\n"), sqlerr);
           print_further_info ("insert encryption");
           sqlite3_free (sqlerr);
           rc = gpg_error (GPG_ERR_GENERAL);
         }
 
       xfree (email);
     }
 
  leave:
   if (in_batch)
     tofu_end_batch_update (ctrl);
 
   release_kbnode (kb);
   if (free_user_id_list)
     free_strlist (user_id_list);
   xfree (fingerprint);
 
   return rc;
 }
 
 
 /* Combine a trust level returned from the TOFU trust model with a
    trust level returned by the PGP trust model.  This is primarily of
    interest when the trust model is tofu+pgp (TM_TOFU_PGP).
 
    This function ors together the upper bits (the values not covered
    by TRUST_MASK, i.e., TRUST_FLAG_REVOKED, etc.).  */
 int
 tofu_wot_trust_combine (int tofu_base, int wot_base)
 {
   int tofu = tofu_base & TRUST_MASK;
   int wot = wot_base & TRUST_MASK;
   int upper = (tofu_base & ~TRUST_MASK) | (wot_base & ~TRUST_MASK);
 
   log_assert (tofu == TRUST_UNKNOWN
               || tofu == TRUST_EXPIRED
               || tofu == TRUST_UNDEFINED
               || tofu == TRUST_NEVER
               || tofu == TRUST_MARGINAL
               || tofu == TRUST_FULLY
               || tofu == TRUST_ULTIMATE);
   log_assert (wot == TRUST_UNKNOWN
               || wot == TRUST_EXPIRED
               || wot == TRUST_UNDEFINED
               || wot == TRUST_NEVER
               || wot == TRUST_MARGINAL
               || wot == TRUST_FULLY
               || wot == TRUST_ULTIMATE);
 
   /* We first consider negative trust policys.  These trump positive
      trust policies.  */
   if (tofu == TRUST_NEVER || wot == TRUST_NEVER)
     /* TRUST_NEVER trumps everything else.  */
     return upper | TRUST_NEVER;
   if (tofu == TRUST_EXPIRED || wot == TRUST_EXPIRED)
     /* TRUST_EXPIRED trumps everything but TRUST_NEVER.  */
     return upper | TRUST_EXPIRED;
 
   /* Now we only have positive or neutral trust policies.  We take
      the max.  */
   if (tofu == TRUST_ULTIMATE)
     return upper | TRUST_ULTIMATE | TRUST_FLAG_TOFU_BASED;
   if (wot == TRUST_ULTIMATE)
     return upper | TRUST_ULTIMATE;
 
   if (tofu == TRUST_FULLY)
     return upper | TRUST_FULLY | TRUST_FLAG_TOFU_BASED;
   if (wot == TRUST_FULLY)
     return upper | TRUST_FULLY;
 
   if (tofu == TRUST_MARGINAL)
     return upper | TRUST_MARGINAL | TRUST_FLAG_TOFU_BASED;
   if (wot == TRUST_MARGINAL)
     return upper | TRUST_MARGINAL;
 
   if (tofu == TRUST_UNDEFINED)
     return upper | TRUST_UNDEFINED | TRUST_FLAG_TOFU_BASED;
   if (wot == TRUST_UNDEFINED)
     return upper | TRUST_UNDEFINED;
 
   return upper | TRUST_UNKNOWN;
 }
 
 
 /* Write a "tfs" record for a --with-colons listing.  */
 gpg_error_t
 tofu_write_tfs_record (ctrl_t ctrl, estream_t fp,
                        PKT_public_key *pk, const char *user_id)
 {
   time_t now = gnupg_get_time ();
   gpg_error_t err = 0;
   tofu_dbs_t dbs;
   char *fingerprint;
   char *email = NULL;
   enum tofu_policy policy;
 
   if (!*user_id)
     return 0;  /* No TOFU stats possible for an empty ID.  */
 
   dbs = opendbs (ctrl);
   if (!dbs)
     {
       err = gpg_error (GPG_ERR_GENERAL);
       log_error (_("error opening TOFU database: %s\n"), gpg_strerror (err));
       return err;
     }
 
   fingerprint = hexfingerprint (pk, NULL, 0);
   if (!fingerprint)
     {
       err = gpg_error_from_syserror ();
       goto leave;
     }
   email = email_from_user_id (user_id);
   policy = get_policy (ctrl, dbs, pk, fingerprint, user_id, email, NULL, now);
 
   show_statistics (dbs, fingerprint, email, policy, fp, 0, now);
 
  leave:
   xfree (email);
   xfree (fingerprint);
   return err;
 }
 
 
 /* Return the validity (TRUST_NEVER, etc.) of the bindings
    <FINGERPRINT, USER_ID>, for each USER_ID in USER_ID_LIST.  If
    USER_ID_LIST->FLAG is set, then the id is considered to be expired.
 
    PK is the primary key packet.
 
    If MAY_ASK is 1 and the policy is TOFU_POLICY_ASK, then the user
    will be prompted to choose a policy.  If MAY_ASK is 0 and the
    policy is TOFU_POLICY_ASK, then TRUST_UNKNOWN is returned.
 
    Returns TRUST_UNDEFINED if an error occurs.
 
    Fixme: eturn an error code
   */
 int
 tofu_get_validity (ctrl_t ctrl, PKT_public_key *pk, strlist_t user_id_list,
 		   int may_ask)
 {
   time_t now = gnupg_get_time ();
   tofu_dbs_t dbs;
   char *fingerprint = NULL;
   strlist_t user_id;
   int trust_level = TRUST_UNKNOWN;
   int bindings = 0;
   int bindings_valid = 0;
   int need_warning = 0;
   int had_conflict = 0;
 
   dbs = opendbs (ctrl);
   if (! dbs)
     {
       log_error (_("error opening TOFU database: %s\n"),
                  gpg_strerror (GPG_ERR_GENERAL));
       return TRUST_UNDEFINED;
     }
 
   fingerprint = hexfingerprint (pk, NULL, 0);
   if (!fingerprint)
     log_fatal ("%s: malloc failed\n", __func__);
 
   tofu_begin_batch_update (ctrl);
   /* Start the batch transaction now.  */
   tofu_resume_batch_transaction (ctrl);
 
   for (user_id = user_id_list; user_id; user_id = user_id->next, bindings ++)
     {
       char *email = email_from_user_id (user_id->d);
       strlist_t conflict_set = NULL;
       enum tofu_policy policy;
 
       /* Always call get_trust to make sure the binding is
          registered.  */
       int tl = get_trust (ctrl, pk, fingerprint, email, user_id->d,
                           may_ask, &policy, &conflict_set, now);
       if (tl == _tofu_GET_TRUST_ERROR)
         {
           /* An error.  */
           trust_level = TRUST_UNDEFINED;
           xfree (email);
           goto die;
         }
 
       if (DBG_TRUST)
 	log_debug ("TOFU: validity for <key: %s, user id: %s>: %s%s.\n",
 		   fingerprint, email,
                    trust_value_to_string (tl),
                    user_id->flags ? " (but expired)" : "");
 
       if (user_id->flags)
         tl = TRUST_EXPIRED;
 
       if (tl != TRUST_EXPIRED)
         bindings_valid ++;
 
       if (may_ask && tl != TRUST_ULTIMATE && tl != TRUST_EXPIRED)
         {
           /* If policy is ask, then we already printed out the
            * conflict information in ask_about_binding or will do so
            * in a moment.  */
           if (policy != TOFU_POLICY_ASK)
             need_warning |=
               show_statistics (dbs, fingerprint, email, policy, NULL, 0, now);
 
           /* If there is a conflict and MAY_ASK is true, we need to
            * show the TOFU statistics for the current binding and the
            * conflicting bindings.  But, if we are not in batch mode,
            * then they have already been printed (this is required to
            * make sure the information is available to the caller
            * before cpr_get is called).  */
           if (policy == TOFU_POLICY_ASK && opt.batch)
             {
               strlist_t iter;
 
               /* The conflict set should contain at least the current
                * key.  */
               log_assert (conflict_set);
 
               had_conflict = 1;
               for (iter = conflict_set; iter; iter = iter->next)
                 show_statistics (dbs, iter->d, email,
                                  TOFU_POLICY_ASK, NULL, 1, now);
             }
         }
 
       free_strlist (conflict_set);
 
       if (tl == TRUST_NEVER)
         trust_level = TRUST_NEVER;
       else if (tl == TRUST_EXPIRED)
         /* Ignore expired bindings in the trust calculation.  */
         ;
       else if (tl > trust_level)
         {
           /* The expected values: */
           log_assert (tl == TRUST_UNKNOWN || tl == TRUST_UNDEFINED
                       || tl == TRUST_MARGINAL || tl == TRUST_FULLY
                       || tl == TRUST_ULTIMATE);
 
           /* We assume the following ordering:  */
           log_assert (TRUST_UNKNOWN < TRUST_UNDEFINED);
           log_assert (TRUST_UNDEFINED < TRUST_MARGINAL);
           log_assert (TRUST_MARGINAL < TRUST_FULLY);
           log_assert (TRUST_FULLY < TRUST_ULTIMATE);
 
           trust_level = tl;
         }
 
       xfree (email);
     }
 
   if (need_warning && ! had_conflict)
     show_warning (fingerprint, user_id_list);
 
  die:
   tofu_end_batch_update (ctrl);
 
   xfree (fingerprint);
 
   if (bindings_valid == 0)
     {
       if (DBG_TRUST)
         log_debug ("no (of %d) valid bindings."
                    "  Can't get TOFU validity for this set of user ids.\n",
                    bindings);
       return TRUST_NEVER;
     }
 
   return trust_level;
 }
 
 /* Set the policy for all non-revoked user ids in the keyblock KB to
    POLICY.
 
    If no key is available with the specified key id, then this
    function returns GPG_ERR_NO_PUBKEY.
 
    Returns 0 on success and an error code otherwise.  */
 gpg_error_t
 tofu_set_policy (ctrl_t ctrl, kbnode_t kb, enum tofu_policy policy)
 {
   gpg_error_t err = 0;
   time_t now = gnupg_get_time ();
   tofu_dbs_t dbs;
   PKT_public_key *pk;
   char *fingerprint = NULL;
 
   log_assert (kb->pkt->pkttype == PKT_PUBLIC_KEY);
   pk = kb->pkt->pkt.public_key;
 
   dbs = opendbs (ctrl);
   if (! dbs)
     {
       log_error (_("error opening TOFU database: %s\n"),
                  gpg_strerror (GPG_ERR_GENERAL));
       return gpg_error (GPG_ERR_GENERAL);
     }
 
   if (DBG_TRUST)
     log_debug ("Setting TOFU policy for %s to %s\n",
 	       keystr (pk->keyid), tofu_policy_str (policy));
   if (! pk_is_primary (pk))
     log_bug ("%s: Passed a subkey, but expecting a primary key.\n", __func__);
 
   fingerprint = hexfingerprint (pk, NULL, 0);
   if (!fingerprint)
     return gpg_error_from_syserror ();
 
   begin_transaction (ctrl, 0);
 
   for (; kb; kb = kb->next)
     {
       PKT_user_id *user_id;
       char *email;
 
       if (kb->pkt->pkttype != PKT_USER_ID)
 	continue;
 
       user_id = kb->pkt->pkt.user_id;
       if (user_id->flags.revoked)
 	/* Skip revoked user ids.  (Don't skip expired user ids, the
 	   expiry can be changed.)  */
 	continue;
 
       email = email_from_user_id (user_id->name);
 
       err = record_binding (dbs, fingerprint, email, user_id->name,
                             policy, TOFU_POLICY_NONE, NULL, 0, 1, now);
       if (err)
         {
           log_error ("error setting policy for key %s, user id \"%s\": %s",
                      fingerprint, email, gpg_strerror (err));
           xfree (email);
           break;
         }
 
       xfree (email);
     }
 
   if (err)
     rollback_transaction (ctrl);
   else
     end_transaction (ctrl, 0);
 
   xfree (fingerprint);
   return err;
 }
 
 /* Return the TOFU policy for the specified binding in *POLICY.  If no
    policy has been set for the binding, sets *POLICY to
    TOFU_POLICY_NONE.
 
    PK is a primary public key and USER_ID is a user id.
 
    Returns 0 on success and an error code otherwise.  */
 gpg_error_t
 tofu_get_policy (ctrl_t ctrl, PKT_public_key *pk, PKT_user_id *user_id,
 		 enum tofu_policy *policy)
 {
   time_t now = gnupg_get_time ();
   tofu_dbs_t dbs;
   char *fingerprint;
   char *email;
 
   /* Make sure PK is a primary key.  */
   log_assert (pk_is_primary (pk));
 
   dbs = opendbs (ctrl);
   if (! dbs)
     {
       log_error (_("error opening TOFU database: %s\n"),
                  gpg_strerror (GPG_ERR_GENERAL));
       return gpg_error (GPG_ERR_GENERAL);
     }
 
   fingerprint = hexfingerprint (pk, NULL, 0);
   if (!fingerprint)
     return gpg_error_from_syserror ();
 
   email = email_from_user_id (user_id->name);
 
   *policy = get_policy (ctrl, dbs, pk, fingerprint,
                         user_id->name, email, NULL, now);
 
   xfree (email);
   xfree (fingerprint);
   if (*policy == _tofu_GET_POLICY_ERROR)
     return gpg_error (GPG_ERR_GENERAL);
   return 0;
 }
 
 gpg_error_t
 tofu_notice_key_changed (ctrl_t ctrl, kbnode_t kb)
 {
   tofu_dbs_t dbs;
   PKT_public_key *pk;
   char *fingerprint;
   char *sqlerr = NULL;
   int rc;
 
   /* Make sure PK is a primary key.  */
   setup_main_keyids (kb);
   pk = kb->pkt->pkt.public_key;
   log_assert (pk_is_primary (pk));
 
   dbs = opendbs (ctrl);
   if (! dbs)
     {
       log_error (_("error opening TOFU database: %s\n"),
                  gpg_strerror (GPG_ERR_GENERAL));
       return gpg_error (GPG_ERR_GENERAL);
     }
 
   fingerprint = hexfingerprint (pk, NULL, 0);
   if (!fingerprint)
     return gpg_error_from_syserror ();
 
   rc = gpgsql_stepx (dbs->db, NULL, NULL, NULL, &sqlerr,
                      "update bindings set effective_policy = ?"
                      " where fingerprint = ?;",
                      GPGSQL_ARG_INT, (int) TOFU_POLICY_NONE,
                      GPGSQL_ARG_STRING, fingerprint,
                      GPGSQL_ARG_END);
   xfree (fingerprint);
 
   if (rc == _tofu_GET_POLICY_ERROR)
     return gpg_error (GPG_ERR_GENERAL);
   return 0;
 }
diff --git a/g10/trustdb.c b/g10/trustdb.c
index 43bce0769..9ef4644bf 100644
--- a/g10/trustdb.c
+++ b/g10/trustdb.c
@@ -1,2289 +1,2290 @@
 /* trustdb.c
  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
  *               2008, 2012 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 "gpg.h"
 #include "../common/status.h"
 #include "../common/iobuf.h"
 #include "../regexp/jimregexp.h"
 #include "keydb.h"
 #include "../common/util.h"
 #include "options.h"
 #include "packet.h"
 #include "main.h"
 #include "../common/mbox-util.h"
 #include "../common/i18n.h"
 #include "tdbio.h"
 #include "trustdb.h"
 #include "tofu.h"
 #include "key-clean.h"
 
 static u32
 keyid_from_fpr20 (ctrl_t ctrl, const byte *fpr, u32 *keyid)
 {
   u32 dummy_keyid[2];
   int fprlen;
 
   if( !keyid )
     keyid = dummy_keyid;
 
   /* Problem: We do only use fingerprints in the trustdb but
    * we need the keyID here to indetify the key; we can only
    * use that ugly hack to distinguish between 16 and 20
    * bytes fpr - it does not work always so we better change
    * the whole validation code to only work with
    * fingerprints */
   fprlen = (!fpr[16] && !fpr[17] && !fpr[18] && !fpr[19])? 16:20;
 
   if (fprlen != 20)
     {
       /* This is special as we have to lookup the key first.  */
       PKT_public_key pk;
       int rc;
 
       memset (&pk, 0, sizeof pk);
       rc = get_pubkey_byfprint (ctrl, &pk, NULL, fpr, fprlen);
       if (rc)
         {
           log_printhex (fpr, fprlen,
                         "Oops: keyid_from_fingerprint: no pubkey; fpr:");
           keyid[0] = 0;
           keyid[1] = 0;
         }
       else
         keyid_from_pk (&pk, keyid);
     }
   else
     {
       keyid[0] = buf32_to_u32 (fpr+12);
       keyid[1] = buf32_to_u32 (fpr+16);
     }
 
   return keyid[1];
 }
 
 typedef struct key_item **KeyHashTable; /* see new_key_hash_table() */
 
 /*
  * Structure to keep track of keys, this is used as an array wherre
  * the item right after the last one has a keyblock set to NULL.
  * Maybe we can drop this thing and replace it by key_item
  */
 struct key_array
 {
   KBNODE keyblock;
 };
 
 
 /* Control information for the trust DB.  */
 static struct
 {
   int init;
   int level;
   char *dbname;
   int no_trustdb;
 } trustdb_args;
 
 /* Some globals.  */
 static struct key_item *user_utk_list; /* temp. used to store --trusted-keys */
 static struct key_item *utk_list;      /* all ultimately trusted keys */
 
 static int pending_check_trustdb;
 
 static int validate_keys (ctrl_t ctrl, int interactive);
 
 
 /**********************************************
  ************* some helpers *******************
  **********************************************/
 
 static struct key_item *
 new_key_item (void)
 {
   struct key_item *k;
 
   k = xmalloc_clear (sizeof *k);
   return k;
 }
 
 static void
 release_key_items (struct key_item *k)
 {
   struct key_item *k2;
 
   for (; k; k = k2)
     {
       k2 = k->next;
       xfree (k->trust_regexp);
       xfree (k);
     }
 }
 
 #define KEY_HASH_TABLE_SIZE 1024
 
 /*
  * For fast keylook up we need a hash table.  Each byte of a KeyID
  * should be distributed equally over the 256 possible values (except
  * for v3 keyIDs but we consider them as not important here). So we
  * can just use 10 bits to index a table of KEY_HASH_TABLE_SIZE key items.
  * Possible optimization: Do not use key_items but other hash_table when the
  * duplicates lists get too large.
  */
 static KeyHashTable
 new_key_hash_table (void)
 {
   struct key_item **tbl;
 
   tbl = xmalloc_clear (KEY_HASH_TABLE_SIZE * sizeof *tbl);
   return tbl;
 }
 
 static void
 release_key_hash_table (KeyHashTable tbl)
 {
   int i;
 
   if (!tbl)
     return;
   for (i=0; i < KEY_HASH_TABLE_SIZE; i++)
     release_key_items (tbl[i]);
   xfree (tbl);
 }
 
 /*
  * Returns: True if the keyID is in the given hash table
  */
 static int
 test_key_hash_table (KeyHashTable tbl, u32 *kid)
 {
   struct key_item *k;
 
   for (k = tbl[(kid[1] % KEY_HASH_TABLE_SIZE)]; k; k = k->next)
     if (k->kid[0] == kid[0] && k->kid[1] == kid[1])
       return 1;
   return 0;
 }
 
 /*
  * Add a new key to the hash table.  The key is identified by its key ID.
  */
 static void
 add_key_hash_table (KeyHashTable tbl, u32 *kid)
 {
   int i = kid[1] % KEY_HASH_TABLE_SIZE;
   struct key_item *k, *kk;
 
   for (k = tbl[i]; k; k = k->next)
     if (k->kid[0] == kid[0] && k->kid[1] == kid[1])
       return; /* already in table */
 
   kk = new_key_item ();
   kk->kid[0] = kid[0];
   kk->kid[1] = kid[1];
   kk->next = tbl[i];
   tbl[i] = kk;
 }
 
 /*
  * Release a key_array
  */
 static void
 release_key_array ( struct key_array *keys )
 {
     struct key_array *k;
 
     if (keys) {
         for (k=keys; k->keyblock; k++)
             release_kbnode (k->keyblock);
         xfree (keys);
     }
 }
 
 
 /*********************************************
  **********  Initialization  *****************
  *********************************************/
 
 
 
 /*
  * Used to register extra ultimately trusted keys - this has to be done
  * before initializing the validation module.
  * FIXME: Should be replaced by a function to add those keys to the trustdb.
  */
 static void
 tdb_register_trusted_keyid (u32 *keyid)
 {
   struct key_item *k;
 
   k = new_key_item ();
   k->kid[0] = keyid[0];
   k->kid[1] = keyid[1];
   k->next = user_utk_list;
   user_utk_list = k;
 }
 
 
 void
 tdb_register_trusted_key (const char *string)
 {
   gpg_error_t err;
   KEYDB_SEARCH_DESC desc;
   u32 kid[2];
 
   err = classify_user_id (string, &desc, 1);
   if (!err)
     {
       if (desc.mode == KEYDB_SEARCH_MODE_LONG_KID)
         {
           tdb_register_trusted_keyid (desc.u.kid);
           return;
         }
       if (desc.mode == KEYDB_SEARCH_MODE_FPR && desc.fprlen == 20)
         {
           kid[0] = buf32_to_u32 (desc.u.fpr+12);
           kid[1] = buf32_to_u32 (desc.u.fpr+16);
           tdb_register_trusted_keyid (kid);
           return;
         }
       if (desc.mode == KEYDB_SEARCH_MODE_FPR && desc.fprlen == 32)
         {
           kid[0] = buf32_to_u32 (desc.u.fpr);
           kid[1] = buf32_to_u32 (desc.u.fpr+4);
           tdb_register_trusted_keyid (kid);
           return;
         }
     }
   log_error (_("'%s' is not a valid long keyID\n"), string );
 }
 
 
 /*
  * Helper to add a key to the global list of ultimately trusted keys.
  * Returns: true = inserted, false = already in list.
  */
 static int
 add_utk (u32 *kid)
 {
   struct key_item *k;
 
   if (tdb_keyid_is_utk (kid))
     return 0;
 
   k = new_key_item ();
   k->kid[0] = kid[0];
   k->kid[1] = kid[1];
   k->ownertrust = TRUST_ULTIMATE;
   k->next = utk_list;
   utk_list = k;
   if( opt.verbose > 1 )
     log_info(_("key %s: accepted as trusted key\n"), keystr(kid));
   return 1;
 }
 
 
 /****************
  * Verify that all our secret keys are usable and put them into the utk_list.
  */
 static void
 verify_own_keys (ctrl_t ctrl)
 {
   TRUSTREC rec;
   ulong recnum;
   int rc;
   struct key_item *k;
 
   if (utk_list)
     return;
 
   /* scan the trustdb to find all ultimately trusted keys */
   for (recnum=1; !tdbio_read_record (recnum, &rec, 0); recnum++ )
     {
       if (rec.rectype == RECTYPE_TRUST
           && (rec.r.trust.ownertrust & TRUST_MASK) == TRUST_ULTIMATE)
         {
           u32 kid[2];
 
           keyid_from_fpr20 (ctrl, rec.r.trust.fingerprint, kid);
           if (!add_utk (kid))
             log_info (_("key %s occurs more than once in the trustdb\n"),
                       keystr(kid));
         }
     }
 
   /* Put any --trusted-key keys into the trustdb */
   for (k = user_utk_list; k; k = k->next)
     {
       if ( add_utk (k->kid) )
         { /* not yet in trustDB as ultimately trusted */
           PKT_public_key pk;
 
           memset (&pk, 0, sizeof pk);
           rc = get_pubkey_with_ldap_fallback (ctrl, &pk, k->kid);
           if (rc)
 	    log_info(_("key %s: no public key for trusted key - skipped\n"),
 		     keystr(k->kid));
           else
 	    {
 	      tdb_update_ownertrust
                 (ctrl, &pk, ((tdb_get_ownertrust (ctrl, &pk, 0) & ~TRUST_MASK)
                              | TRUST_ULTIMATE ));
 	      release_public_key_parts (&pk);
 	    }
 
           if (!opt.quiet)
             log_info (_("key %s marked as ultimately trusted\n"),
                       keystr(k->kid));
         }
     }
 
   /* release the helper table table */
   release_key_items (user_utk_list);
   user_utk_list = NULL;
   return;
 }
 
 /* Returns whether KID is on the list of ultimately trusted keys.  */
 int
 tdb_keyid_is_utk (u32 *kid)
 {
   struct key_item *k;
 
   for (k = utk_list; k; k = k->next)
     if (k->kid[0] == kid[0] && k->kid[1] == kid[1])
       return 1;
 
   return 0;
 }
 
 /* Return the list of ultimately trusted keys.  */
 struct key_item *
 tdb_utks (void)
 {
   return utk_list;
 }
 
 /*********************************************
  *********** TrustDB stuff *******************
  *********************************************/
 
 /*
  * Read a record but die if it does not exist
  */
 static void
 read_record (ulong recno, TRUSTREC *rec, int rectype )
 {
   int rc = tdbio_read_record (recno, rec, rectype);
   if (rc)
     {
       log_error(_("trust record %lu, req type %d: read failed: %s\n"),
                 recno, rec->rectype, gpg_strerror (rc) );
       tdbio_invalid();
     }
   if (rectype != rec->rectype)
     {
       log_error(_("trust record %lu is not of requested type %d\n"),
                 rec->recnum, rectype);
       tdbio_invalid();
     }
 }
 
 /*
  * Write a record and die on error
  */
 static void
 write_record (ctrl_t ctrl, TRUSTREC *rec)
 {
   int rc = tdbio_write_record (ctrl, rec);
   if (rc)
     {
       log_error(_("trust record %lu, type %d: write failed: %s\n"),
 			    rec->recnum, rec->rectype, gpg_strerror (rc) );
       tdbio_invalid();
     }
 }
 
 /*
  * sync the TrustDb and die on error
  */
 static void
 do_sync(void)
 {
     int rc = tdbio_sync ();
     if(rc)
       {
         log_error (_("trustdb: sync failed: %s\n"), gpg_strerror (rc) );
         g10_exit(2);
       }
 }
 
 const char *
 trust_model_string (int model)
 {
   switch (model)
     {
     case TM_CLASSIC:  return "classic";
     case TM_PGP:      return "pgp";
     case TM_EXTERNAL: return "external";
     case TM_TOFU:     return "tofu";
     case TM_TOFU_PGP: return "tofu+pgp";
     case TM_ALWAYS:   return "always";
     case TM_DIRECT:   return "direct";
     default:          return "unknown";
     }
 }
 
 /****************
  * Perform some checks over the trustdb
  *  level 0: only open the db
  *	  1: used for initial program startup
  */
 int
 setup_trustdb( int level, const char *dbname )
 {
     /* just store the args */
     if( trustdb_args.init )
 	return 0;
     trustdb_args.level = level;
     trustdb_args.dbname = dbname? xstrdup(dbname): NULL;
     return 0;
 }
 
 void
 how_to_fix_the_trustdb ()
 {
   const char *name = trustdb_args.dbname;
 
   if (!name)
     name = "trustdb.gpg";
 
   log_info (_("You may try to re-create the trustdb using the commands:\n"));
   log_info ("  cd %s\n", default_homedir ());
   log_info ("  %s --export-ownertrust > otrust.tmp\n", GPG_NAME);
 #ifdef HAVE_W32_SYSTEM
   log_info ("  del %s\n", name);
 #else
   log_info ("  rm %s\n", name);
 #endif
   log_info ("  %s --import-ownertrust < otrust.tmp\n", GPG_NAME);
   log_info (_("If that does not work, please consult the manual\n"));
 }
 
 
 /* Initialize the trustdb.  With NO_CREATE set a missing trustdb is
  * not an error and the function won't terminate the process on error;
  * in that case 0 is returned if there is a trustdb or an error code
  * if no trustdb is available.  */
 gpg_error_t
 init_trustdb (ctrl_t ctrl, int no_create)
 {
   int level = trustdb_args.level;
   const char* dbname = trustdb_args.dbname;
 
   if( trustdb_args.init )
     return 0;
 
   trustdb_args.init = 1;
 
   if(level==0 || level==1)
     {
       int rc = tdbio_set_dbname (ctrl, dbname, (!no_create && level),
                                  &trustdb_args.no_trustdb);
       if (no_create && trustdb_args.no_trustdb)
         {
           /* No trustdb found and the caller asked us not to create
            * it.  Return an error and set the initialization state
            * back so that we always test for an existing trustdb.  */
           trustdb_args.init = 0;
           return gpg_error (GPG_ERR_ENOENT);
         }
       if (rc)
 	log_fatal("can't init trustdb: %s\n", gpg_strerror (rc) );
     }
   else
     BUG();
 
   if(opt.trust_model==TM_AUTO)
     {
       /* Try and set the trust model off of whatever the trustdb says
 	 it is. */
       opt.trust_model=tdbio_read_model();
 
       /* Sanity check this ;) */
       if(opt.trust_model != TM_CLASSIC
 	 && opt.trust_model != TM_PGP
 	 && opt.trust_model != TM_TOFU_PGP
 	 && opt.trust_model != TM_TOFU
 	 && opt.trust_model != TM_EXTERNAL)
 	{
 	  log_info(_("unable to use unknown trust model (%d) - "
 		     "assuming %s trust model\n"),opt.trust_model,"pgp");
 	  opt.trust_model = TM_PGP;
 	}
 
       if(opt.verbose)
 	log_info(_("using %s trust model\n"),
                  trust_model_string (opt.trust_model));
     }
 
   if (opt.trust_model==TM_PGP || opt.trust_model==TM_CLASSIC
       || opt.trust_model == TM_TOFU || opt.trust_model == TM_TOFU_PGP)
     {
       /* Verify the list of ultimately trusted keys and move the
 	 --trusted-keys list there as well. */
       if(level==1)
 	verify_own_keys (ctrl);
 
       if(!tdbio_db_matches_options())
 	pending_check_trustdb=1;
     }
 
   return 0;
 }
 
 
 /* Check whether we have a trust database, initializing it if
    necessary if the trust model is not 'always trust'.  Returns true
    if we do have a usable trust database.  */
 int
 have_trustdb (ctrl_t ctrl)
 {
   return !init_trustdb (ctrl, opt.trust_model == TM_ALWAYS);
 }
 
 
 /****************
  * Recreate the WoT but do not ask for new ownertrusts.  Special
  * feature: In batch mode and without a forced yes, this is only done
  * when a check is due.  This can be used to run the check from a crontab
  */
 void
 check_trustdb (ctrl_t ctrl)
 {
   init_trustdb (ctrl, 0);
   if (opt.trust_model == TM_PGP || opt.trust_model == TM_CLASSIC
       || opt.trust_model == TM_TOFU_PGP || opt.trust_model == TM_TOFU)
     {
       if (opt.batch && !opt.answer_yes)
 	{
 	  ulong scheduled;
 
 	  scheduled = tdbio_read_nextcheck ();
 	  if (!scheduled)
 	    {
 	      log_info (_("no need for a trustdb check\n"));
 	      return;
 	    }
 
 	  if (scheduled > make_timestamp ())
 	    {
 	      log_info (_("next trustdb check due at %s\n"),
 			strtimestamp (scheduled));
 	      return;
 	    }
 	}
 
       validate_keys (ctrl, 0);
     }
   else
     log_info (_("no need for a trustdb check with '%s' trust model\n"),
 	      trust_model_string(opt.trust_model));
 }
 
 
 /*
  * Recreate the WoT.
  */
 void
 update_trustdb (ctrl_t ctrl)
 {
   init_trustdb (ctrl, 0);
   if (opt.trust_model == TM_PGP || opt.trust_model == TM_CLASSIC
       || opt.trust_model == TM_TOFU_PGP || opt.trust_model == TM_TOFU)
     validate_keys (ctrl, 1);
   else
     log_info (_("no need for a trustdb update with '%s' trust model\n"),
 	      trust_model_string(opt.trust_model));
 }
 
 void
 tdb_revalidation_mark (ctrl_t ctrl)
 {
   init_trustdb (ctrl, 0);
   if (trustdb_args.no_trustdb && opt.trust_model == TM_ALWAYS)
     return;
 
   /* We simply set the time for the next check to 1 (far back in 1970)
      so that a --update-trustdb will be scheduled.  */
   if (tdbio_write_nextcheck (ctrl, 1))
     do_sync ();
   pending_check_trustdb = 1;
 }
 
 int
 trustdb_pending_check(void)
 {
   return pending_check_trustdb;
 }
 
 /* If the trustdb is dirty, and we're interactive, update it.
    Otherwise, check it unless no-auto-check-trustdb is set. */
 void
 tdb_check_or_update (ctrl_t ctrl)
 {
   if (trustdb_pending_check ())
     {
       if (opt.interactive)
 	update_trustdb (ctrl);
       else if (!opt.no_auto_check_trustdb)
 	check_trustdb (ctrl);
     }
 }
 
 void
 read_trust_options (ctrl_t ctrl,
                     byte *trust_model, ulong *created, ulong *nextcheck,
 		    byte *marginals, byte *completes, byte *cert_depth,
 		    byte *min_cert_level)
 {
   TRUSTREC opts;
 
   init_trustdb (ctrl, 0);
   if (trustdb_args.no_trustdb && opt.trust_model == TM_ALWAYS)
     memset (&opts, 0, sizeof opts);
   else
     read_record (0, &opts, RECTYPE_VER);
 
   if(trust_model)
     *trust_model=opts.r.ver.trust_model;
   if(created)
     *created=opts.r.ver.created;
   if(nextcheck)
     *nextcheck=opts.r.ver.nextcheck;
   if(marginals)
     *marginals=opts.r.ver.marginals;
   if(completes)
     *completes=opts.r.ver.completes;
   if(cert_depth)
     *cert_depth=opts.r.ver.cert_depth;
   if(min_cert_level)
     *min_cert_level=opts.r.ver.min_cert_level;
 }
 
 /***********************************************
  ***********  Ownertrust et al. ****************
  ***********************************************/
 
 static int
 read_trust_record (ctrl_t ctrl, PKT_public_key *pk, TRUSTREC *rec)
 {
   int rc;
 
   init_trustdb (ctrl, 0);
   rc = tdbio_search_trust_bypk (ctrl, pk, rec);
   if (rc)
     {
       if (gpg_err_code (rc) != GPG_ERR_NOT_FOUND)
         log_error ("trustdb: searching trust record failed: %s\n",
                    gpg_strerror (rc));
       return rc;
     }
 
   if (rec->rectype != RECTYPE_TRUST)
     {
       log_error ("trustdb: record %lu is not a trust record\n",
                  rec->recnum);
       return GPG_ERR_TRUSTDB;
     }
 
   return 0;
 }
 
 
 /*
  * Return the assigned ownertrust value for the given public key.  The
  * key should be the primary key.  If NO_CREATE is set a missing
  * trustdb will not be created.  This comes for example handy when we
  * want to print status lines (DECRYPTION_KEY) which carry ownertrust
  * values but we usually use --always-trust.
  */
 unsigned int
 tdb_get_ownertrust (ctrl_t ctrl, PKT_public_key *pk, int no_create)
 {
   TRUSTREC rec;
   gpg_error_t err;
 
   if (trustdb_args.no_trustdb && opt.trust_model == TM_ALWAYS)
     return TRUST_UNKNOWN;
 
   /* If the caller asked not to create a trustdb we call init_trustdb
    * directly and allow it to fail with an error code for a
    * non-existing trustdb.  */
   if (no_create && init_trustdb (ctrl, 1))
     return TRUST_UNKNOWN;
 
   err = read_trust_record (ctrl, pk, &rec);
   if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
     return TRUST_UNKNOWN; /* no record yet */
   if (err)
     {
       tdbio_invalid ();
       return TRUST_UNKNOWN; /* actually never reached */
     }
 
   return rec.r.trust.ownertrust;
 }
 
 
 unsigned int
 tdb_get_min_ownertrust (ctrl_t ctrl, PKT_public_key *pk, int no_create)
 {
   TRUSTREC rec;
   gpg_error_t err;
 
   if (trustdb_args.no_trustdb && opt.trust_model == TM_ALWAYS)
     return TRUST_UNKNOWN;
 
   /* If the caller asked not to create a trustdb we call init_trustdb
    * directly and allow it to fail with an error code for a
    * non-existing trustdb.  */
   if (no_create && init_trustdb (ctrl, 1))
     return TRUST_UNKNOWN;
 
   err = read_trust_record (ctrl, pk, &rec);
   if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
     return TRUST_UNKNOWN; /* no record yet */
   if (err)
     {
       tdbio_invalid ();
       return TRUST_UNKNOWN; /* actually never reached */
     }
 
   return rec.r.trust.min_ownertrust;
 }
 
 
 /*
  * Set the trust value of the given public key to the new value.
  * The key should be a primary one.
  */
 void
 tdb_update_ownertrust (ctrl_t ctrl, PKT_public_key *pk, unsigned int new_trust )
 {
   TRUSTREC rec;
   gpg_error_t err;
 
   if (trustdb_args.no_trustdb && opt.trust_model == TM_ALWAYS)
     return;
 
   err = read_trust_record (ctrl, pk, &rec);
   if (!err)
     {
       if (DBG_TRUST)
         log_debug ("update ownertrust from %u to %u\n",
                    (unsigned int)rec.r.trust.ownertrust, new_trust );
       if (rec.r.trust.ownertrust != new_trust)
         {
           rec.r.trust.ownertrust = new_trust;
           write_record (ctrl, &rec);
           tdb_revalidation_mark (ctrl);
           do_sync ();
         }
     }
   else if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
     { /* no record yet - create a new one */
       if (DBG_TRUST)
         log_debug ("insert ownertrust %u\n", new_trust );
 
       memset (&rec, 0, sizeof rec);
       rec.recnum = tdbio_new_recnum (ctrl);
       rec.rectype = RECTYPE_TRUST;
       fpr20_from_pk (pk, rec.r.trust.fingerprint);
       rec.r.trust.ownertrust = new_trust;
       write_record (ctrl, &rec);
       tdb_revalidation_mark (ctrl);
       do_sync ();
     }
   else
     {
       tdbio_invalid ();
     }
 }
 
 static void
 update_min_ownertrust (ctrl_t ctrl, u32 *kid, unsigned int new_trust)
 {
   PKT_public_key *pk;
   TRUSTREC rec;
   gpg_error_t err;
 
   if (trustdb_args.no_trustdb && opt.trust_model == TM_ALWAYS)
     return;
 
   pk = xmalloc_clear (sizeof *pk);
   err = get_pubkey (ctrl, pk, kid);
   if (err)
     {
       log_error (_("public key %s not found: %s\n"),
                  keystr (kid), gpg_strerror (err));
       xfree (pk);
       return;
     }
 
   err = read_trust_record (ctrl, pk, &rec);
   if (!err)
     {
       if (DBG_TRUST)
         log_debug ("key %08lX%08lX: update min_ownertrust from %u to %u\n",
                    (ulong)kid[0],(ulong)kid[1],
 		   (unsigned int)rec.r.trust.min_ownertrust,
 		   new_trust );
       if (rec.r.trust.min_ownertrust != new_trust)
         {
           rec.r.trust.min_ownertrust = new_trust;
           write_record (ctrl, &rec);
           tdb_revalidation_mark (ctrl);
           do_sync ();
         }
     }
   else if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
     { /* no record yet - create a new one */
       if (DBG_TRUST)
         log_debug ("insert min_ownertrust %u\n", new_trust );
 
       memset (&rec, 0, sizeof rec);
       rec.recnum = tdbio_new_recnum (ctrl);
       rec.rectype = RECTYPE_TRUST;
       fpr20_from_pk (pk, rec.r.trust.fingerprint);
       rec.r.trust.min_ownertrust = new_trust;
       write_record (ctrl, &rec);
       tdb_revalidation_mark (ctrl);
       do_sync ();
     }
   else
     {
       tdbio_invalid ();
     }
 
   free_public_key (pk);
 }
 
 
 /*
  * Clear the ownertrust and min_ownertrust values.
  *
  * Return: True if a change actually happened.
  */
 int
 tdb_clear_ownertrusts (ctrl_t ctrl, PKT_public_key *pk)
 {
   TRUSTREC rec;
   gpg_error_t err;
 
   init_trustdb (ctrl, 0);
 
   if (trustdb_args.no_trustdb && opt.trust_model == TM_ALWAYS)
     return 0;
 
   err = read_trust_record (ctrl, pk, &rec);
   if (!err)
     {
       if (DBG_TRUST)
 	{
 	  log_debug ("clearing ownertrust (old value %u)\n",
 		     (unsigned int)rec.r.trust.ownertrust);
 	  log_debug ("clearing min_ownertrust (old value %u)\n",
 		     (unsigned int)rec.r.trust.min_ownertrust);
 	}
       if (rec.r.trust.ownertrust || rec.r.trust.min_ownertrust)
         {
           rec.r.trust.ownertrust = 0;
           rec.r.trust.min_ownertrust = 0;
           write_record (ctrl, &rec);
           tdb_revalidation_mark (ctrl);
           do_sync ();
           return 1;
         }
     }
   else if (gpg_err_code (err) != GPG_ERR_NOT_FOUND)
     {
       tdbio_invalid ();
     }
   return 0;
 }
 
 /*
  * Note: Caller has to do a sync
  */
 static void
 update_validity (ctrl_t ctrl, PKT_public_key *pk, PKT_user_id *uid,
                  int depth, int validity)
 {
   TRUSTREC trec, vrec;
   gpg_error_t err;
   ulong recno;
 
   namehash_from_uid(uid);
 
   err = read_trust_record (ctrl, pk, &trec);
   if (err && gpg_err_code (err) != GPG_ERR_NOT_FOUND)
     {
       tdbio_invalid ();
       return;
     }
   if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
     {
       /* No record yet - create a new one. */
       memset (&trec, 0, sizeof trec);
       trec.recnum = tdbio_new_recnum (ctrl);
       trec.rectype = RECTYPE_TRUST;
       fpr20_from_pk (pk, trec.r.trust.fingerprint);
       trec.r.trust.ownertrust = 0;
       }
 
   /* locate an existing one */
   recno = trec.r.trust.validlist;
   while (recno)
     {
       read_record (recno, &vrec, RECTYPE_VALID);
       if ( !memcmp (vrec.r.valid.namehash, uid->namehash, 20) )
         break;
       recno = vrec.r.valid.next;
     }
 
   if (!recno) /* insert a new validity record */
     {
       memset (&vrec, 0, sizeof vrec);
       vrec.recnum = tdbio_new_recnum (ctrl);
       vrec.rectype = RECTYPE_VALID;
       memcpy (vrec.r.valid.namehash, uid->namehash, 20);
       vrec.r.valid.next = trec.r.trust.validlist;
       trec.r.trust.validlist = vrec.recnum;
     }
   vrec.r.valid.validity = validity;
   vrec.r.valid.full_count = uid->help_full_count;
   vrec.r.valid.marginal_count = uid->help_marginal_count;
   write_record (ctrl, &vrec);
   trec.r.trust.depth = depth;
   write_record (ctrl, &trec);
 }
 
 
 /***********************************************
  *********  Query trustdb values  **************
  ***********************************************/
 
 /* Return true if key is disabled.  Note that this is usually used via
    the pk_is_disabled macro.  */
 int
 tdb_cache_disabled_value (ctrl_t ctrl, PKT_public_key *pk)
 {
   gpg_error_t err;
   TRUSTREC trec;
   int disabled = 0;
 
   if (pk->flags.disabled_valid)
     return pk->flags.disabled;
 
   init_trustdb (ctrl, 0);
 
   if (trustdb_args.no_trustdb)
     return 0;  /* No trustdb => not disabled.  */
 
   err = read_trust_record (ctrl, pk, &trec);
   if (err && gpg_err_code (err) != GPG_ERR_NOT_FOUND)
     {
       tdbio_invalid ();
       goto leave;
     }
   if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
     {
       /* No record found, so assume not disabled.  */
       goto leave;
     }
 
   if ((trec.r.trust.ownertrust & TRUST_FLAG_DISABLED))
     disabled = 1;
 
   /* Cache it for later so we don't need to look at the trustdb every
      time */
   pk->flags.disabled = disabled;
   pk->flags.disabled_valid = 1;
 
  leave:
   return disabled;
 }
 
 
 void
 tdb_check_trustdb_stale (ctrl_t ctrl)
 {
   static int did_nextcheck=0;
 
   init_trustdb (ctrl, 0);
 
   if (trustdb_args.no_trustdb)
     return;  /* No trustdb => can't be stale.  */
 
   if (!did_nextcheck
       && (opt.trust_model == TM_PGP || opt.trust_model == TM_CLASSIC
           || opt.trust_model == TM_TOFU_PGP || opt.trust_model == TM_TOFU))
     {
       ulong scheduled;
 
       did_nextcheck = 1;
       scheduled = tdbio_read_nextcheck ();
       if ((scheduled && scheduled <= make_timestamp ())
 	  || pending_check_trustdb)
         {
           if (opt.no_auto_check_trustdb)
             {
               pending_check_trustdb = 1;
               if (!opt.quiet)
                 log_info (_("please do a --check-trustdb\n"));
             }
           else
             {
               if (!opt.quiet)
                 log_info (_("checking the trustdb\n"));
               validate_keys (ctrl, 0);
             }
         }
     }
 }
 
 /*
  * Return the validity information for KB/PK (at least one of them
  * must be non-NULL).  This is the core of get_validity.  If SIG is
  * not NULL, then the trust is being evaluated in the context of the
  * provided signature.  This is used by the TOFU code to record
  * statistics.
  */
 unsigned int
 tdb_get_validity_core (ctrl_t ctrl,
                        kbnode_t kb,
                        PKT_public_key *pk, PKT_user_id *uid,
                        PKT_public_key *main_pk,
 		       PKT_signature *sig,
 		       int may_ask)
 {
   TRUSTREC trec, vrec;
   gpg_error_t err = 0;
   ulong recno;
 #ifdef USE_TOFU
   unsigned int tofu_validity = TRUST_UNKNOWN;
   int free_kb = 0;
 #endif
   unsigned int validity = TRUST_UNKNOWN;
 
   if (kb && pk)
     log_assert (keyid_cmp (pk_main_keyid (pk),
                            pk_main_keyid (kb->pkt->pkt.public_key)) == 0);
 
   if (! pk)
     {
       log_assert (kb);
       pk = kb->pkt->pkt.public_key;
     }
 
 #ifndef USE_TOFU
   (void)sig;
   (void)may_ask;
 #endif
 
   init_trustdb (ctrl, 0);
 
   /* If we have no trustdb (which also means it has not been created)
      and the trust-model is always, we don't know the validity -
      return immediately.  If we won't do that the tdbio code would try
      to open the trustdb and run into a fatal error.  */
   if (trustdb_args.no_trustdb && opt.trust_model == TM_ALWAYS)
     return TRUST_UNKNOWN;
 
   check_trustdb_stale (ctrl);
 
   if(opt.trust_model==TM_DIRECT)
     {
       /* Note that this happens BEFORE any user ID stuff is checked.
 	 The direct trust model applies to keys as a whole. */
       validity = tdb_get_ownertrust (ctrl, main_pk, 0);
       goto leave;
     }
 
 #ifdef USE_TOFU
   if (opt.trust_model == TM_TOFU || opt.trust_model == TM_TOFU_PGP)
     {
       kbnode_t n = NULL;
       strlist_t user_id_list = NULL;
       int done = 0;
 
       /* If the caller didn't supply a user id then use all uids.  */
       if (! uid)
         {
           if (! kb)
             {
               kb = get_pubkeyblock (ctrl, main_pk->keyid);
               free_kb = 1;
             }
           n = kb;
         }
 
       if (DBG_TRUST && sig && sig->signers_uid)
         log_debug ("TOFU: only considering user id: '%s'\n",
                    sig->signers_uid);
 
       while (!done && (uid || (n = find_next_kbnode (n, PKT_USER_ID))))
 	{
 	  PKT_user_id *user_id;
           int expired = 0;
 
 	  if (uid)
             {
               user_id = uid;
               /* If the caller specified a user id, then we only
                  process the specified user id and are done after the
                  first iteration.  */
               done = 1;
             }
 	  else
 	    user_id = n->pkt->pkt.user_id;
 
           if (user_id->attrib_data)
             /* Skip user attributes.  */
             continue;
 
           if (sig && sig->signers_uid)
             /* Make sure the UID matches.  */
             {
               char *email = mailbox_from_userid (user_id->name, 0);
               if (!email || !*email || strcmp (sig->signers_uid, email) != 0)
                 {
                   if (DBG_TRUST)
                     log_debug ("TOFU: skipping user id '%s', which does"
                                " not match the signer's email ('%s')\n",
                                email, sig->signers_uid);
                   xfree (email);
                   continue;
                 }
               xfree (email);
             }
 
           /* If the user id is revoked or expired, then skip it.  */
           if (user_id->flags.revoked || user_id->flags.expired)
             {
               if (DBG_TRUST)
                 {
                   char *s;
                   if (user_id->flags.revoked && user_id->flags.expired)
                     s = "revoked and expired";
                   else if (user_id->flags.revoked)
                     s = "revoked";
                   else
                     s = "expire";
 
                   log_debug ("TOFU: Ignoring %s user id (%s)\n",
                              s, user_id->name);
                 }
 
               if (user_id->flags.revoked)
                 continue;
 
               expired = 1;
             }
 
           add_to_strlist (&user_id_list, user_id->name);
           user_id_list->flags = expired;
         }
 
       /* Process the user ids in the order they appear in the key
          block.  */
       strlist_rev (&user_id_list);
 
       /* It only makes sense to observe any signature before getting
          the validity.  This is because if the current signature
          results in a conflict, then we damn well want to take that
          into account.  */
       if (sig)
         {
           err = tofu_register_signature (ctrl, main_pk, user_id_list,
                                          sig->digest, sig->digest_len,
                                          sig->timestamp, "unknown");
           if (err)
             {
               log_error ("TOFU: error registering signature: %s\n",
                          gpg_strerror (err));
 
               tofu_validity = TRUST_UNKNOWN;
             }
         }
       if (! err)
         tofu_validity = tofu_get_validity (ctrl, main_pk, user_id_list,
                                            may_ask);
 
       free_strlist (user_id_list);
       if (free_kb)
         release_kbnode (kb);
     }
 #endif /*USE_TOFU*/
 
   if (opt.trust_model == TM_TOFU_PGP
       || opt.trust_model == TM_CLASSIC
       || opt.trust_model == TM_PGP)
     {
       err = read_trust_record (ctrl, main_pk, &trec);
       if (err && gpg_err_code (err) != GPG_ERR_NOT_FOUND)
 	{
 	  tdbio_invalid ();
 	  return 0;
 	}
       if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
 	{
 	  /* No record found.  */
 	  validity = TRUST_UNKNOWN;
 	  goto leave;
 	}
 
       /* Loop over all user IDs */
       recno = trec.r.trust.validlist;
       validity = 0;
       while (recno)
 	{
 	  read_record (recno, &vrec, RECTYPE_VALID);
 
 	  if(uid)
 	    {
 	      /* If a user ID is given we return the validity for that
 		 user ID ONLY.  If the namehash is not found, then
 		 there is no validity at all (i.e. the user ID wasn't
 		 signed). */
 	      if(memcmp(vrec.r.valid.namehash,uid->namehash,20)==0)
 		{
 		  validity=(vrec.r.valid.validity & TRUST_MASK);
 		  break;
 		}
 	    }
 	  else
 	    {
 	      /* If no user ID is given, we take the maximum validity
 		 over all user IDs */
 	      if (validity < (vrec.r.valid.validity & TRUST_MASK))
 		validity = (vrec.r.valid.validity & TRUST_MASK);
 	    }
 
 	  recno = vrec.r.valid.next;
 	}
 
       if ((trec.r.trust.ownertrust & TRUST_FLAG_DISABLED))
 	{
 	  validity |= TRUST_FLAG_DISABLED;
 	  pk->flags.disabled = 1;
 	}
       else
 	pk->flags.disabled = 0;
       pk->flags.disabled_valid = 1;
     }
 
  leave:
 #ifdef USE_TOFU
   validity = tofu_wot_trust_combine (tofu_validity, validity);
 #else /*!USE_TOFU*/
   validity &= TRUST_MASK;
 
   if (validity == TRUST_NEVER)
     /* TRUST_NEVER trumps everything else.  */
     validity |= TRUST_NEVER;
   if (validity == TRUST_EXPIRED)
     /* TRUST_EXPIRED trumps everything but TRUST_NEVER.  */
     validity |= TRUST_EXPIRED;
 #endif /*!USE_TOFU*/
 
   if (opt.trust_model != TM_TOFU
       && pending_check_trustdb)
     validity |= TRUST_FLAG_PENDING_CHECK;
 
   return validity;
 }
 
 
 static void
 get_validity_counts (ctrl_t ctrl, PKT_public_key *pk, PKT_user_id *uid)
 {
   TRUSTREC trec, vrec;
   ulong recno;
 
   if(pk==NULL || uid==NULL)
     BUG();
 
   namehash_from_uid(uid);
 
   uid->help_marginal_count=uid->help_full_count=0;
 
   init_trustdb (ctrl, 0);
 
   if(read_trust_record (ctrl, pk, &trec))
     return;
 
   /* loop over all user IDs */
   recno = trec.r.trust.validlist;
   while (recno)
     {
       read_record (recno, &vrec, RECTYPE_VALID);
 
       if(memcmp(vrec.r.valid.namehash,uid->namehash,20)==0)
 	{
 	  uid->help_marginal_count=vrec.r.valid.marginal_count;
 	  uid->help_full_count=vrec.r.valid.full_count;
 	  /*  es_printf("Fetched marginal %d, full %d\n",uid->help_marginal_count,uid->help_full_count); */
 	  break;
 	}
 
       recno = vrec.r.valid.next;
     }
 }
 
 void
 list_trust_path( const char *username )
 {
   (void)username;
 }
 
 /****************
  * Enumerate all keys, which are needed to build all trust paths for
  * the given key.  This function does not return the key itself or
  * the ultimate key (the last point in cerificate chain).  Only
  * certificate chains which ends up at an ultimately trusted key
  * are listed.	If ownertrust or validity is not NULL, the corresponding
  * value for the returned LID is also returned in these variable(s).
  *
  *  1) create a void pointer and initialize it to NULL
  *  2) pass this void pointer by reference to this function.
  *     Set lid to the key you want to enumerate and pass it by reference.
  *  3) call this function as long as it does not return -1
  *     to indicate EOF. LID does contain the next key used to build the web
  *  4) Always call this function a last time with LID set to NULL,
  *     so that it can free its context.
  *
  * Returns: -1 on EOF or the level of the returned LID
  */
 int
 enum_cert_paths( void **context, ulong *lid,
 		 unsigned *ownertrust, unsigned *validity )
 {
   (void)context;
   (void)lid;
   (void)ownertrust;
   (void)validity;
   return -1;
 }
 
 
 /****************
  * Print the current path
  */
 void
 enum_cert_paths_print (void **context, FILE *fp,
                        int refresh, ulong selected_lid)
 {
   (void)context;
   (void)fp;
   (void)refresh;
   (void)selected_lid;
 }
 
 
 
 /****************************************
  *********** NEW NEW NEW ****************
  ****************************************/
 
 static int
 ask_ownertrust (ctrl_t ctrl, u32 *kid, int minimum)
 {
   PKT_public_key *pk;
   int rc;
   int ot;
 
   pk = xmalloc_clear (sizeof *pk);
   rc = get_pubkey (ctrl, pk, kid);
   if (rc)
     {
       log_error (_("public key %s not found: %s\n"),
                  keystr(kid), gpg_strerror (rc) );
+      free_public_key (pk);
       return TRUST_UNKNOWN;
     }
 
   if(opt.force_ownertrust)
     {
       log_info("force trust for key %s to %s\n",
 	       keystr(kid),trust_value_to_string(opt.force_ownertrust));
       tdb_update_ownertrust (ctrl, pk, opt.force_ownertrust);
       ot=opt.force_ownertrust;
     }
   else
     {
       ot=edit_ownertrust (ctrl, pk, 0);
       if(ot>0)
 	ot = tdb_get_ownertrust (ctrl, pk, 0);
       else if(ot==0)
 	ot = minimum?minimum:TRUST_UNDEFINED;
       else
 	ot = -1; /* quit */
     }
 
   free_public_key( pk );
 
   return ot;
 }
 
 
 static void
 mark_keyblock_seen (KeyHashTable tbl, KBNODE node)
 {
   for ( ;node; node = node->next )
     if (node->pkt->pkttype == PKT_PUBLIC_KEY
 	|| node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
       {
         u32 aki[2];
 
         keyid_from_pk (node->pkt->pkt.public_key, aki);
         add_key_hash_table (tbl, aki);
       }
 }
 
 
 static void
 dump_key_array (int depth, struct key_array *keys)
 {
   struct key_array *kar;
 
   for (kar=keys; kar->keyblock; kar++)
     {
       KBNODE node = kar->keyblock;
       u32 kid[2];
 
       keyid_from_pk(node->pkt->pkt.public_key, kid);
       es_printf ("%d:%08lX%08lX:K::%c::::\n",
                  depth, (ulong)kid[0], (ulong)kid[1], '?');
 
       for (; node; node = node->next)
         {
           if (node->pkt->pkttype == PKT_USER_ID)
             {
               int len = node->pkt->pkt.user_id->len;
 
               if (len > 30)
                 len = 30;
               es_printf ("%d:%08lX%08lX:U:::%c:::",
                          depth, (ulong)kid[0], (ulong)kid[1],
                          (node->flag & 4)? 'f':
                          (node->flag & 2)? 'm':
                          (node->flag & 1)? 'q':'-');
               es_write_sanitized (es_stdout, node->pkt->pkt.user_id->name,
                                   len, ":", NULL);
               es_putc (':', es_stdout);
               es_putc ('\n', es_stdout);
             }
         }
     }
 }
 
 
 static void
 store_validation_status (ctrl_t ctrl, int depth,
                          kbnode_t keyblock, KeyHashTable stored)
 {
   KBNODE node;
   int status;
   int any = 0;
 
   for (node=keyblock; node; node = node->next)
     {
       if (node->pkt->pkttype == PKT_USER_ID)
         {
           PKT_user_id *uid = node->pkt->pkt.user_id;
           if (node->flag & 4)
             status = TRUST_FULLY;
           else if (node->flag & 2)
             status = TRUST_MARGINAL;
           else if (node->flag & 1)
             status = TRUST_UNDEFINED;
           else
             status = 0;
 
           if (status)
             {
               update_validity (ctrl, keyblock->pkt->pkt.public_key,
 			       uid, depth, status);
 
 	      mark_keyblock_seen(stored,keyblock);
 
               any = 1;
             }
         }
     }
 
   if (any)
     do_sync ();
 }
 
 
 /* Returns a sanitized copy of the regexp (which might be "", but not
    NULL). */
 /* Operator characters except '.' and backslash.
    See regex(7) on BSD.  */
 #define REGEXP_OPERATOR_CHARS "^[$()|*+?{"
 
 static char *
 sanitize_regexp(const char *old)
 {
   size_t start=0,len=strlen(old),idx=0;
   int escaped=0,standard_bracket=0;
   char *new=xmalloc((len*2)+1); /* enough to \-escape everything if we
 				   have to */
 
   /* There are basically two commonly-used regexps here.  GPG and most
      versions of PGP use "<[^>]+[@.]example\.com>$" and PGP (9)
      command line uses "example.com" (i.e. whatever the user specifies,
      and we can't expect users know to use "\." instead of ".").  So
      here are the rules: we're allowed to start with "<[^>]+[@.]" and
      end with ">$" or start and end with nothing.  In between, the
      only legal regex character is ".", and everything else gets
      escaped.  Part of the gotcha here is that some regex packages
      allow more than RFC-4880 requires.  For example, 4880 has no "{}"
      operator, but GNU regex does.  Commenting removes these operators
      from consideration.  A possible future enhancement is to use
      commenting to effectively back off a given regex to the Henry
      Spencer syntax in 4880. -dshaw */
 
   /* Are we bracketed between "<[^>]+[@.]" and ">$" ? */
   if(len>=12 && strncmp(old,"<[^>]+[@.]",10)==0
      && old[len-2]=='>' && old[len-1]=='$')
     {
       strcpy(new,"<[^>]+[@.]");
       idx=strlen(new);
       standard_bracket=1;
       start+=10;
       len-=2;
     }
 
   /* Walk the remaining characters and ensure that everything that is
      left is not an operational regex character. */
   for(;start<len;start++)
     {
       if(!escaped && old[start]=='\\')
 	escaped=1;
       else if (!escaped && strchr (REGEXP_OPERATOR_CHARS, old[start]))
 	new[idx++]='\\';
       else
 	escaped=0;
 
       new[idx++]=old[start];
     }
 
   new[idx]='\0';
 
   /* Note that the (sub)string we look at might end with a bare "\".
      If it does, leave it that way.  If the regexp actually ended with
      ">$", then it was escaping the ">" and is fine.  If the regexp
      actually ended with the bare "\", then it's an illegal regexp and
      regcomp should kick it out. */
 
   if(standard_bracket)
     strcat(new,">$");
 
   return new;
 }
 
 /* Used by validate_one_keyblock to confirm a regexp within a trust
    signature.  Returns 1 for match, and 0 for no match or regex
    error. */
 static int
 check_regexp(const char *expr,const char *string)
 {
   int ret;
   char *regexp;
 
   regexp=sanitize_regexp(expr);
 
   {
     regex_t pat;
 
     ret=regcomp(&pat,regexp,REG_ICASE|REG_EXTENDED);
     if(ret==0)
       {
 	ret=regexec(&pat,string,0,NULL,0);
 	regfree(&pat);
       }
     ret=(ret==0);
   }
 
   if(DBG_TRUST)
     log_debug("regexp '%s' ('%s') on '%s': %s\n",
 	      regexp,expr,string,ret?"YES":"NO");
 
   xfree(regexp);
 
   return ret;
 }
 
 /*
  * Return true if the key is signed by one of the keys in the given
  * key ID list.  User IDs with a valid signature are marked by node
  * flags as follows:
  *  flag bit 0: There is at least one signature
  *           1: There is marginal confidence that this is a legitimate uid
  *           2: There is full confidence that this is a legitimate uid.
  *           8: Used for internal purposes.
  *           9: Ditto (in mark_usable_uid_certs())
  *          10: Ditto (ditto)
  * This function assumes that all kbnode flags are cleared on entry.
  */
 static int
 validate_one_keyblock (ctrl_t ctrl, kbnode_t kb, struct key_item *klist,
                        u32 curtime, u32 *next_expire)
 {
   struct key_item *kr;
   KBNODE node, uidnode=NULL;
   PKT_user_id *uid=NULL;
   PKT_public_key *pk = kb->pkt->pkt.public_key;
   u32 main_kid[2];
   int issigned=0, any_signed = 0;
 
   keyid_from_pk(pk, main_kid);
   for (node=kb; node; node = node->next)
     {
       /* A bit of discussion here: is it better for the web of trust
 	 to be built among only self-signed uids?  On the one hand, a
 	 self-signed uid is a statement that the key owner definitely
 	 intended that uid to be there, but on the other hand, a
 	 signed (but not self-signed) uid does carry trust, of a sort,
 	 even if it is a statement being made by people other than the
 	 key owner "through" the uids on the key owner's key.  I'm
 	 going with the latter.  However, if the user ID was
 	 explicitly revoked, or passively allowed to expire, that
 	 should stop validity through the user ID until it is
 	 resigned.  -dshaw */
 
       if (node->pkt->pkttype == PKT_USER_ID
 	  && !node->pkt->pkt.user_id->flags.revoked
 	  && !node->pkt->pkt.user_id->flags.expired)
         {
           if (uidnode && issigned)
             {
               if (uid->help_full_count >= opt.completes_needed
                   || uid->help_marginal_count >= opt.marginals_needed )
                 uidnode->flag |= 4;
               else if (uid->help_full_count || uid->help_marginal_count)
                 uidnode->flag |= 2;
               uidnode->flag |= 1;
               any_signed = 1;
             }
           uidnode = node;
 	  uid=uidnode->pkt->pkt.user_id;
 
 	  /* If the selfsig is going to expire... */
 	  if(uid->expiredate && uid->expiredate<*next_expire)
 	    *next_expire = uid->expiredate;
 
           issigned = 0;
 	  get_validity_counts (ctrl, pk, uid);
           mark_usable_uid_certs (ctrl, kb, uidnode, main_kid, klist,
                                  curtime, next_expire);
         }
       else if (node->pkt->pkttype == PKT_SIGNATURE
 	       && (node->flag & (1<<8)) && uid)
         {
 	  /* Note that we are only seeing unrevoked sigs here */
           PKT_signature *sig = node->pkt->pkt.signature;
 
           kr = is_in_klist (klist, sig);
 	  /* If the trust_regexp does not match, it's as if the sig
              did not exist.  This is safe for non-trust sigs as well
              since we don't accept a regexp on the sig unless it's a
              trust sig. */
           if (kr && (!kr->trust_regexp
                      || !(opt.trust_model == TM_PGP
                           || opt.trust_model == TM_TOFU_PGP)
                      || (uidnode
                          && check_regexp(kr->trust_regexp,
                                          uidnode->pkt->pkt.user_id->name))))
             {
 	      /* Are we part of a trust sig chain?  We always favor
                  the latest trust sig, rather than the greater or
                  lesser trust sig or value.  I could make a decent
                  argument for any of these cases, but this seems to be
                  what PGP does, and I'd like to be compatible. -dms */
               if ((opt.trust_model == TM_PGP
                    || opt.trust_model == TM_TOFU_PGP)
                   && sig->trust_depth
                   && pk->trust_timestamp <= sig->timestamp)
 		{
 		  unsigned char depth;
 
 		  /* If the depth on the signature is less than the
 		     chain currently has, then use the signature depth
 		     so we don't increase the depth beyond what the
 		     signer wanted.  If the depth on the signature is
 		     more than the chain currently has, then use the
 		     chain depth so we use as much of the signature
 		     depth as the chain will permit.  An ultimately
 		     trusted signature can restart the depth to
 		     whatever level it likes. */
 
 		  if (sig->trust_depth < kr->trust_depth
                       || kr->ownertrust == TRUST_ULTIMATE)
 		    depth = sig->trust_depth;
 		  else
 		    depth = kr->trust_depth;
 
 		  if (depth)
 		    {
 		      if(DBG_TRUST)
 			log_debug ("trust sig on %s, sig depth is %d,"
                                    " kr depth is %d\n",
                                    uidnode->pkt->pkt.user_id->name,
                                    sig->trust_depth,
                                    kr->trust_depth);
 
 		      /* If we got here, we know that:
 
 			 this is a trust sig.
 
 			 it's a newer trust sig than any previous trust
 			 sig on this key (not uid).
 
 			 it is legal in that it was either generated by an
 			 ultimate key, or a key that was part of a trust
 			 chain, and the depth does not violate the
 			 original trust sig.
 
 			 if there is a regexp attached, it matched
 			 successfully.
 		      */
 
 		      if (DBG_TRUST)
 			log_debug ("replacing trust value %d with %d and "
                                    "depth %d with %d\n",
                                    pk->trust_value,sig->trust_value,
                                    pk->trust_depth,depth);
 
 		      pk->trust_value = sig->trust_value;
 		      pk->trust_depth = depth-1;
 
 		      /* If the trust sig contains a regexp, record it
 			 on the pk for the next round. */
 		      if (sig->trust_regexp)
 			pk->trust_regexp = sig->trust_regexp;
 		    }
 		}
 
               if (kr->ownertrust == TRUST_ULTIMATE)
                 uid->help_full_count = opt.completes_needed;
               else if (kr->ownertrust == TRUST_FULLY)
                 uid->help_full_count++;
               else if (kr->ownertrust == TRUST_MARGINAL)
                 uid->help_marginal_count++;
               issigned = 1;
 	    }
         }
     }
 
   if (uidnode && issigned)
     {
       if (uid->help_full_count >= opt.completes_needed
 	  || uid->help_marginal_count >= opt.marginals_needed )
         uidnode->flag |= 4;
       else if (uid->help_full_count || uid->help_marginal_count)
         uidnode->flag |= 2;
       uidnode->flag |= 1;
       any_signed = 1;
     }
 
   return any_signed;
 }
 
 
 static int
 search_skipfnc (void *opaque, u32 *kid, int dummy_uid_no)
 {
   (void)dummy_uid_no;
   return test_key_hash_table ((KeyHashTable)opaque, kid);
 }
 
 
 /*
  * Scan all keys and return a key_array of all suitable keys from
  * klist.  The caller has to pass keydb handle so that we don't use
  * to create our own.  Returns either a key_array or NULL in case of
  * an error.  No results found are indicated by an empty array.
  * Caller hast to release the returned array.
  */
 static struct key_array *
 validate_key_list (ctrl_t ctrl, KEYDB_HANDLE hd, KeyHashTable full_trust,
                    struct key_item *klist, u32 curtime, u32 *next_expire)
 {
   KBNODE keyblock = NULL;
   struct key_array *keys = NULL;
   size_t nkeys, maxkeys;
   int rc;
   KEYDB_SEARCH_DESC desc;
 
   maxkeys = 1000;
   keys = xmalloc ((maxkeys+1) * sizeof *keys);
   nkeys = 0;
 
   rc = keydb_search_reset (hd);
   if (rc)
     {
       log_error ("keydb_search_reset failed: %s\n", gpg_strerror (rc));
       xfree (keys);
       return NULL;
     }
 
   memset (&desc, 0, sizeof desc);
   desc.mode = KEYDB_SEARCH_MODE_FIRST;
   desc.skipfnc = search_skipfnc;
   desc.skipfncvalue = full_trust;
   rc = keydb_search (hd, &desc, 1, NULL);
   if (gpg_err_code (rc) == GPG_ERR_NOT_FOUND)
     {
       keys[nkeys].keyblock = NULL;
       return keys;
     }
   if (rc)
     {
       log_error ("keydb_search(first) failed: %s\n", gpg_strerror (rc));
       goto die;
     }
 
   desc.mode = KEYDB_SEARCH_MODE_NEXT; /* change mode */
   do
     {
       PKT_public_key *pk;
 
       rc = keydb_get_keyblock (hd, &keyblock);
       if (rc)
         {
           log_error ("keydb_get_keyblock failed: %s\n", gpg_strerror (rc));
 	  goto die;
         }
 
       if ( keyblock->pkt->pkttype != PKT_PUBLIC_KEY)
         {
           log_debug ("ooops: invalid pkttype %d encountered\n",
                      keyblock->pkt->pkttype);
           dump_kbnode (keyblock);
           release_kbnode(keyblock);
           continue;
         }
 
       /* prepare the keyblock for further processing */
       merge_keys_and_selfsig (ctrl, keyblock);
       clear_kbnode_flags (keyblock);
       pk = keyblock->pkt->pkt.public_key;
       if (pk->has_expired || pk->flags.revoked)
         {
           /* it does not make sense to look further at those keys */
           mark_keyblock_seen (full_trust, keyblock);
         }
       else if (validate_one_keyblock (ctrl, keyblock, klist,
                                       curtime, next_expire))
         {
 	  KBNODE node;
 
           if (pk->expiredate && pk->expiredate >= curtime
               && pk->expiredate < *next_expire)
             *next_expire = pk->expiredate;
 
           if (nkeys == maxkeys) {
             maxkeys += 1000;
             keys = xrealloc (keys, (maxkeys+1) * sizeof *keys);
           }
           keys[nkeys++].keyblock = keyblock;
 
 	  /* Optimization - if all uids are fully trusted, then we
 	     never need to consider this key as a candidate again. */
 
 	  for (node=keyblock; node; node = node->next)
 	    if (node->pkt->pkttype == PKT_USER_ID && !(node->flag & 4))
 	      break;
 
 	  if(node==NULL)
 	    mark_keyblock_seen (full_trust, keyblock);
 
           keyblock = NULL;
         }
 
       release_kbnode (keyblock);
       keyblock = NULL;
     }
   while (!(rc = keydb_search (hd, &desc, 1, NULL)));
 
   if (rc && gpg_err_code (rc) != GPG_ERR_NOT_FOUND)
     {
       log_error ("keydb_search_next failed: %s\n", gpg_strerror (rc));
       goto die;
     }
 
   keys[nkeys].keyblock = NULL;
   return keys;
 
  die:
   keys[nkeys].keyblock = NULL;
   release_key_array (keys);
   return NULL;
 }
 
 /* Caller must sync */
 static void
 reset_trust_records (ctrl_t ctrl)
 {
   TRUSTREC rec;
   ulong recnum;
   int count = 0, nreset = 0;
 
   for (recnum=1; !tdbio_read_record (recnum, &rec, 0); recnum++ )
     {
       if(rec.rectype==RECTYPE_TRUST)
 	{
 	  count++;
 	  if(rec.r.trust.min_ownertrust)
 	    {
 	      rec.r.trust.min_ownertrust=0;
 	      write_record (ctrl, &rec);
 	    }
 
 	}
       else if(rec.rectype==RECTYPE_VALID
 	      && ((rec.r.valid.validity&TRUST_MASK)
 		  || rec.r.valid.marginal_count
 		  || rec.r.valid.full_count))
 	{
 	  rec.r.valid.validity &= ~TRUST_MASK;
 	  rec.r.valid.marginal_count=rec.r.valid.full_count=0;
 	  nreset++;
 	  write_record (ctrl, &rec);
 	}
 
     }
 
   if (opt.verbose)
     {
       log_info (ngettext("%d key processed",
                          "%d keys processed",
                          count), count);
       log_printf (ngettext(" (%d validity count cleared)\n",
                            " (%d validity counts cleared)\n",
                            nreset), nreset);
     }
 }
 
 /*
  * Run the key validation procedure.
  *
  * This works this way:
  * Step 1: Find all ultimately trusted keys (UTK).
  *         mark them all as seen and put them into klist.
  * Step 2: loop max_cert_times
  * Step 3:   if OWNERTRUST of any key in klist is undefined
  *             ask user to assign ownertrust
  * Step 4:   Loop over all keys in the keyDB which are not marked seen
  * Step 5:     if key is revoked or expired
  *                mark key as seen
  *                continue loop at Step 4
  * Step 6:     For each user ID of that key signed by a key in klist
  *                Calculate validity by counting trusted signatures.
  *                Set validity of user ID
  * Step 7:     If any signed user ID was found
  *                mark key as seen
  *             End Loop
  * Step 8:   Build a new klist from all fully trusted keys from step 6
  *           End Loop
  *         Ready
  *
  */
 static int
 validate_keys (ctrl_t ctrl, int interactive)
 {
   int rc = 0;
   int quit=0;
   struct key_item *klist = NULL;
   struct key_item *k;
   struct key_array *keys = NULL;
   struct key_array *kar;
   KEYDB_HANDLE kdb = NULL;
   KBNODE node;
   int depth;
   int ot_unknown, ot_undefined, ot_never, ot_marginal, ot_full, ot_ultimate;
   KeyHashTable stored,used,full_trust;
   u32 start_time, next_expire;
 
   /* Make sure we have all sigs cached.  TODO: This is going to
      require some architectural re-thinking, as it is agonizingly slow.
      Perhaps combine this with reset_trust_records(), or only check
      the caches on keys that are actually involved in the web of
      trust. */
   keydb_rebuild_caches (ctrl, 0);
 
   kdb = keydb_new (ctrl);
   if (!kdb)
     return gpg_error_from_syserror ();
 
   start_time = make_timestamp ();
   next_expire = 0xffffffff; /* set next expire to the year 2106 */
   stored = new_key_hash_table ();
   used = new_key_hash_table ();
   full_trust = new_key_hash_table ();
 
   reset_trust_records (ctrl);
 
   /* Fixme: Instead of always building a UTK list, we could just build it
    * here when needed */
   if (!utk_list)
     {
       if (!opt.quiet)
         log_info (_("no ultimately trusted keys found\n"));
       goto leave;
     }
 
   /* mark all UTKs as used and fully_trusted and set validity to
      ultimate */
   for (k=utk_list; k; k = k->next)
     {
       KBNODE keyblock;
       PKT_public_key *pk;
 
       keyblock = get_pubkeyblock (ctrl, k->kid);
       if (!keyblock)
         {
           log_error (_("public key of ultimately"
                        " trusted key %s not found\n"), keystr(k->kid));
           continue;
         }
       mark_keyblock_seen (used, keyblock);
       mark_keyblock_seen (stored, keyblock);
       mark_keyblock_seen (full_trust, keyblock);
       pk = keyblock->pkt->pkt.public_key;
       for (node=keyblock; node; node = node->next)
         {
           if (node->pkt->pkttype == PKT_USER_ID)
 	    update_validity (ctrl, pk, node->pkt->pkt.user_id,
                              0, TRUST_ULTIMATE);
         }
       if ( pk->expiredate && pk->expiredate >= start_time
            && pk->expiredate < next_expire)
         next_expire = pk->expiredate;
 
       release_kbnode (keyblock);
       do_sync ();
     }
 
   if (opt.trust_model == TM_TOFU)
     /* In the TOFU trust model, we only need to save the ultimately
        trusted keys.  */
     goto leave;
 
   klist = utk_list;
 
   if (!opt.quiet)
     log_info ("marginals needed: %d  completes needed: %d  trust model: %s\n",
               opt.marginals_needed, opt.completes_needed,
               trust_model_string (opt.trust_model));
 
   for (depth=0; depth < opt.max_cert_depth; depth++)
     {
       int valids=0,key_count;
       /* See whether we should assign ownertrust values to the keys in
          klist.  */
       ot_unknown = ot_undefined = ot_never = 0;
       ot_marginal = ot_full = ot_ultimate = 0;
       for (k=klist; k; k = k->next)
         {
 	  int min=0;
 
 	  /* 120 and 60 are as per RFC2440 */
 	  if(k->trust_value>=120)
 	    min=TRUST_FULLY;
 	  else if(k->trust_value>=60)
 	    min=TRUST_MARGINAL;
 
 	  if(min!=k->min_ownertrust)
 	    update_min_ownertrust (ctrl, k->kid,min);
 
           if (interactive && k->ownertrust == TRUST_UNKNOWN)
 	    {
 	      k->ownertrust = ask_ownertrust (ctrl, k->kid,min);
 
 	      if (k->ownertrust == (unsigned int)(-1))
 		{
 		  quit=1;
 		  goto leave;
 		}
 	    }
 
 	  /* This can happen during transition from an old trustdb
 	     before trust sigs.  It can also happen if a user uses two
 	     different versions of GnuPG or changes the --trust-model
 	     setting. */
 	  if(k->ownertrust<min)
 	    {
 	      if(DBG_TRUST)
 		log_debug("key %08lX%08lX:"
 			  " overriding ownertrust '%s' with '%s'\n",
 			  (ulong)k->kid[0],(ulong)k->kid[1],
 			  trust_value_to_string(k->ownertrust),
 			  trust_value_to_string(min));
 
 	      k->ownertrust=min;
 	    }
 
 	  if (k->ownertrust == TRUST_UNKNOWN)
             ot_unknown++;
           else if (k->ownertrust == TRUST_UNDEFINED)
             ot_undefined++;
           else if (k->ownertrust == TRUST_NEVER)
             ot_never++;
           else if (k->ownertrust == TRUST_MARGINAL)
             ot_marginal++;
           else if (k->ownertrust == TRUST_FULLY)
             ot_full++;
           else if (k->ownertrust == TRUST_ULTIMATE)
             ot_ultimate++;
 
 	  valids++;
         }
 
       /* Find all keys which are signed by a key in kdlist */
       keys = validate_key_list (ctrl, kdb, full_trust, klist,
 				start_time, &next_expire);
       if (!keys)
         {
           log_error ("validate_key_list failed\n");
           rc = GPG_ERR_GENERAL;
           goto leave;
         }
 
       for (key_count=0, kar=keys; kar->keyblock; kar++, key_count++)
         ;
 
       /* Store the calculated valididation status somewhere */
       if (opt.verbose > 1 && DBG_TRUST)
         dump_key_array (depth, keys);
 
       for (kar=keys; kar->keyblock; kar++)
         store_validation_status (ctrl, depth, kar->keyblock, stored);
 
       if (!opt.quiet)
         log_info (_("depth: %d  valid: %3d  signed: %3d"
                     "  trust: %d-, %dq, %dn, %dm, %df, %du\n"),
                   depth, valids, key_count, ot_unknown, ot_undefined,
                   ot_never, ot_marginal, ot_full, ot_ultimate );
 
       /* Build a new kdlist from all fully valid keys in KEYS */
       if (klist != utk_list)
         release_key_items (klist);
       klist = NULL;
       for (kar=keys; kar->keyblock; kar++)
         {
           for (node=kar->keyblock; node; node = node->next)
             {
               if (node->pkt->pkttype == PKT_USER_ID && (node->flag & 4))
                 {
 		  u32 kid[2];
 
 		  /* have we used this key already? */
                   keyid_from_pk (kar->keyblock->pkt->pkt.public_key, kid);
 		  if(test_key_hash_table(used,kid)==0)
 		    {
 		      /* Normally we add both the primary and subkey
 			 ids to the hash via mark_keyblock_seen, but
 			 since we aren't using this hash as a skipfnc,
 			 that doesn't matter here. */
 		      add_key_hash_table (used,kid);
 		      k = new_key_item ();
 		      k->kid[0]=kid[0];
 		      k->kid[1]=kid[1];
 		      k->ownertrust =
 			(tdb_get_ownertrust
                            (ctrl, kar->keyblock->pkt->pkt.public_key, 0)
                          & TRUST_MASK);
 		      k->min_ownertrust = tdb_get_min_ownertrust
                         (ctrl, kar->keyblock->pkt->pkt.public_key, 0);
 		      k->trust_depth=
 			kar->keyblock->pkt->pkt.public_key->trust_depth;
 		      k->trust_value=
 			kar->keyblock->pkt->pkt.public_key->trust_value;
 		      if(kar->keyblock->pkt->pkt.public_key->trust_regexp)
 			k->trust_regexp=
 			  xstrdup(kar->keyblock->pkt->
 				   pkt.public_key->trust_regexp);
 		      k->next = klist;
 		      klist = k;
 		      break;
 		    }
 		}
 	    }
 	}
       release_key_array (keys);
       keys = NULL;
       if (!klist)
         break; /* no need to dive in deeper */
     }
 
  leave:
   keydb_release (kdb);
   release_key_array (keys);
   if (klist != utk_list)
     release_key_items (klist);
   release_key_hash_table (full_trust);
   release_key_hash_table (used);
   release_key_hash_table (stored);
   if (!rc && !quit) /* mark trustDB as checked */
     {
       int rc2;
 
       if (next_expire == 0xffffffff || next_expire < start_time )
         tdbio_write_nextcheck (ctrl, 0);
       else
         {
           tdbio_write_nextcheck (ctrl, next_expire);
           if (!opt.quiet)
             log_info (_("next trustdb check due at %s\n"),
                       strtimestamp (next_expire));
         }
 
       rc2 = tdbio_update_version_record (ctrl);
       if (rc2)
 	{
 	  log_error (_("unable to update trustdb version record: "
                        "write failed: %s\n"), gpg_strerror (rc2));
 	  tdbio_invalid ();
 	}
 
       do_sync ();
       pending_check_trustdb = 0;
     }
 
   return rc;
 }