diff --git a/g10/export.c b/g10/export.c
index c7cfcfaa4..1eec70935 100644
--- a/g10/export.c
+++ b/g10/export.c
@@ -1,2504 +1,2903 @@
 /* export.c - Export keys in the OpenPGP defined format.
  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004,
  *               2005, 2010 Free Software Foundation, Inc.
  * Copyright (C) 1998-2016  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 "main.h"
 #include "../common/i18n.h"
 #include "../common/membuf.h"
 #include "../common/host2net.h"
 #include "../common/zb32.h"
 #include "../common/recsel.h"
 #include "../common/mbox-util.h"
 #include "../common/init.h"
 #include "trustdb.h"
 #include "call-agent.h"
 #include "key-clean.h"
 #include "pkglue.h"
 
 
 /* An object to keep track of subkeys. */
 struct subkey_list_s
 {
   struct subkey_list_s *next;
   u32 kid[2];
 };
 typedef struct subkey_list_s *subkey_list_t;
 
 
 /* An object to track statistics for export operations.  */
 struct export_stats_s
 {
   ulong count;            /* Number of processed keys.        */
   ulong secret_count;     /* Number of secret keys seen.      */
   ulong exported;         /* Number of actual exported keys.  */
 };
 
 
 /* A global variable to store the selector created from
  * --export-filter keep-uid=EXPR.
  * --export-filter drop-subkey=EXPR.
  *
  * FIXME: We should put this into the CTRL object but that requires a
  * lot more changes right now.
  */
 static recsel_expr_t export_keep_uid;
 static recsel_expr_t export_drop_subkey;
 
 
 /* An object used for a linked list to implement the
  * push_export_filter/pop_export_filters functions.  */
 struct export_filter_attic_s
 {
   struct export_filter_attic_s *next;
   recsel_expr_t export_keep_uid;
   recsel_expr_t export_drop_subkey;
 };
 static struct export_filter_attic_s *export_filter_attic;
 
 
 
 /* Local prototypes.  */
 static int do_export (ctrl_t ctrl, strlist_t users, int secret,
                       unsigned int options, export_stats_t stats);
 static int do_export_stream (ctrl_t ctrl, iobuf_t out,
                              strlist_t users, int secret,
                              kbnode_t *keyblock_out, unsigned int options,
 			     export_stats_t stats, int *any);
 static gpg_error_t print_dane_records
 /**/                 (iobuf_t out, kbnode_t keyblock, PKT_public_key *pk,
                       const void *data, size_t datalen);
 
 
 static void
 cleanup_export_globals (void)
 {
   recsel_release (export_keep_uid);
   export_keep_uid = NULL;
   recsel_release (export_drop_subkey);
   export_drop_subkey = NULL;
 }
 
 
 /* Option parser for export options.  See parse_options for
    details.  */
 int
 parse_export_options(char *str,unsigned int *options,int noisy)
 {
   struct parse_options export_opts[]=
     {
       {"export-local-sigs",EXPORT_LOCAL_SIGS,NULL,
        N_("export signatures that are marked as local-only")},
       {"export-attributes",EXPORT_ATTRIBUTES,NULL,
        N_("export attribute user IDs (generally photo IDs)")},
       {"export-sensitive-revkeys",EXPORT_SENSITIVE_REVKEYS,NULL,
        N_("export revocation keys marked as \"sensitive\"")},
       {"export-clean",EXPORT_CLEAN,NULL,
        N_("remove unusable parts from key during export")},
       {"export-minimal",EXPORT_MINIMAL|EXPORT_CLEAN,NULL,
        N_("remove as much as possible from key during export")},
 
       {"export-dane", EXPORT_DANE_FORMAT, NULL, NULL },
 
       {"backup", EXPORT_BACKUP, NULL,
        N_("use the GnuPG key backup format")},
       {"export-backup", EXPORT_BACKUP, NULL, NULL },
 
       /* Aliases for backward compatibility */
       {"include-local-sigs",EXPORT_LOCAL_SIGS,NULL,NULL},
       {"include-attributes",EXPORT_ATTRIBUTES,NULL,NULL},
       {"include-sensitive-revkeys",EXPORT_SENSITIVE_REVKEYS,NULL,NULL},
       /* dummy */
       {"export-unusable-sigs",0,NULL,NULL},
       {"export-clean-sigs",0,NULL,NULL},
       {"export-clean-uids",0,NULL,NULL},
       {NULL,0,NULL,NULL}
       /* add tags for include revoked and disabled? */
     };
   int rc;
 
   rc = parse_options (str, options, export_opts, noisy);
   if (!rc)
     return 0;
 
   /* Alter other options we want or don't want for restore.  */
   if ((*options & EXPORT_BACKUP))
     {
       *options |= (EXPORT_LOCAL_SIGS | EXPORT_ATTRIBUTES
                    | EXPORT_SENSITIVE_REVKEYS);
       *options &= ~(EXPORT_CLEAN | EXPORT_MINIMAL
                     | EXPORT_DANE_FORMAT);
     }
 
   return rc;
 }
 
 
 /* Parse and set an export 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 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 exported.  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.
  *
  *  - drop-subkey :: If the expression evaluates to true for a subkey
  *                packet that subkey and all it dependencies will be
  *                remove from the keyblock.  The expression may use these
  *                variables:
  *
  *                - secret   :: 1 for a secret subkey, else 0.
  *                - key_algo :: Public key algorithm id
  */
 gpg_error_t
 parse_and_set_export_filter (const char *string)
 {
   gpg_error_t err;
 
   /* Auto register the cleanup function.  */
   register_mem_cleanup_func (cleanup_export_globals);
 
   if (!strncmp (string, "keep-uid=", 9))
     err = recsel_parse_expr (&export_keep_uid, string+9);
   else if (!strncmp (string, "drop-subkey=", 12))
     err = recsel_parse_expr (&export_drop_subkey, string+12);
   else
     err = gpg_error (GPG_ERR_INV_NAME);
 
   return err;
 }
 
 
 /* Push the current export filters onto a stack so that new export
  * filters can be defined which will be active until the next
  * pop_export_filters or another push_export_filters.  */
 void
 push_export_filters (void)
 {
   struct export_filter_attic_s *item;
 
   item = xcalloc (1, sizeof *item);
   item->export_keep_uid = export_keep_uid;
   export_keep_uid = NULL;
   item->export_drop_subkey = export_drop_subkey;
   export_drop_subkey = NULL;
   item->next = export_filter_attic;
   export_filter_attic = item;
 }
 
 
 /* Revert the last push_export_filters.  */
 void
 pop_export_filters (void)
 {
   struct export_filter_attic_s *item;
 
   item = export_filter_attic;
   if (!item)
     BUG (); /* No corresponding push.  */
   export_filter_attic = item->next;
   cleanup_export_globals ();
   export_keep_uid = item->export_keep_uid;
   export_drop_subkey = item->export_drop_subkey;
 }
 
 
 
 /* Create a new export stats object initialized to zero.  On error
    returns NULL and sets ERRNO.  */
 export_stats_t
 export_new_stats (void)
 {
   export_stats_t stats;
 
   return xtrycalloc (1, sizeof *stats);
 }
 
 
 /* Release an export stats object.  */
 void
 export_release_stats (export_stats_t stats)
 {
   xfree (stats);
 }
 
 
 /* Print export statistics using the status interface.  */
 void
 export_print_stats (export_stats_t stats)
 {
   if (!stats)
     return;
 
   if (is_status_enabled ())
     {
       char buf[15*20];
 
       snprintf (buf, sizeof buf, "%lu %lu %lu",
 		stats->count,
 		stats->secret_count,
 		stats->exported );
       write_status_text (STATUS_EXPORT_RES, buf);
     }
 }
 
 
 /*
  * Export public keys (to stdout or to --output FILE).
  *
  * Depending on opt.armor the output is armored.  OPTIONS are defined
  * in main.h.  If USERS is NULL, all keys will be exported.  STATS is
  * either an export stats object for update or NULL.
  *
  * This function is the core of "gpg --export".
  */
 int
 export_pubkeys (ctrl_t ctrl, strlist_t users, unsigned int options,
                 export_stats_t stats)
 {
   return do_export (ctrl, users, 0, options, stats);
 }
 
 
 /*
  * Export secret keys (to stdout or to --output FILE).
  *
  * Depending on opt.armor the output is armored.  OPTIONS are defined
  * in main.h.  If USERS is NULL, all secret keys will be exported.
  * STATS is either an export stats object for update or NULL.
  *
  * This function is the core of "gpg --export-secret-keys".
  */
 int
 export_seckeys (ctrl_t ctrl, strlist_t users, unsigned int options,
                 export_stats_t stats)
 {
   return do_export (ctrl, users, 1, options, stats);
 }
 
 
 /*
  * Export secret sub keys (to stdout or to --output FILE).
  *
  * This is the same as export_seckeys but replaces the primary key by
  * a stub key.  Depending on opt.armor the output is armored.  OPTIONS
  * are defined in main.h.  If USERS is NULL, all secret subkeys will
  * be exported.  STATS is either an export stats object for update or
  * NULL.
  *
  * This function is the core of "gpg --export-secret-subkeys".
  */
 int
 export_secsubkeys (ctrl_t ctrl, strlist_t users, unsigned int options,
                    export_stats_t stats)
 {
   return do_export (ctrl, users, 2, options, stats);
 }
 
 
 /*
  * Export a single key into a memory buffer.  STATS is either an
  * export stats object for update or NULL.  If PREFIX is not NULL
  * PREFIXLEN bytes from PREFIX are prepended to the R_DATA.
  */
 gpg_error_t
 export_pubkey_buffer (ctrl_t ctrl, const char *keyspec, unsigned int options,
                       const void *prefix, size_t prefixlen,
                       export_stats_t stats,
                       kbnode_t *r_keyblock, void **r_data, size_t *r_datalen)
 {
   gpg_error_t err;
   iobuf_t iobuf;
   int any;
   strlist_t helplist;
 
   *r_keyblock = NULL;
   *r_data = NULL;
   *r_datalen = 0;
 
   helplist = NULL;
   if (!add_to_strlist_try (&helplist, keyspec))
     return gpg_error_from_syserror ();
 
   iobuf = iobuf_temp ();
   if (prefix && prefixlen)
     iobuf_write (iobuf, prefix, prefixlen);
   err = do_export_stream (ctrl, iobuf, helplist, 0, r_keyblock, options,
                           stats, &any);
   if (!err && !any)
     err = gpg_error (GPG_ERR_NOT_FOUND);
   if (!err)
     {
       const void *src;
       size_t datalen;
 
       iobuf_flush_temp (iobuf);
       src = iobuf_get_temp_buffer (iobuf);
       datalen = iobuf_get_temp_length (iobuf);
       if (!datalen)
         err = gpg_error (GPG_ERR_NO_PUBKEY);
       else if (!(*r_data = xtrymalloc (datalen)))
         err = gpg_error_from_syserror ();
       else
         {
           memcpy (*r_data, src, datalen);
           *r_datalen = datalen;
         }
     }
   iobuf_close (iobuf);
   free_strlist (helplist);
   if (err && *r_keyblock)
     {
       release_kbnode (*r_keyblock);
       *r_keyblock = NULL;
     }
   return err;
 }
 
 
 /* Export the keys identified by the list of strings in USERS.  If
    Secret is false public keys will be exported.  With secret true
    secret keys will be exported; in this case 1 means the entire
    secret keyblock and 2 only the subkeys.  OPTIONS are the export
    options to apply.  */
 static int
 do_export (ctrl_t ctrl, strlist_t users, int secret, unsigned int options,
            export_stats_t stats)
 {
   IOBUF out = NULL;
   int any, rc;
   armor_filter_context_t *afx = NULL;
   compress_filter_context_t zfx;
 
   memset( &zfx, 0, sizeof zfx);
 
   rc = open_outfile (-1, NULL, 0, !!secret, &out );
   if (rc)
     return rc;
 
   if ( opt.armor && !(options & EXPORT_DANE_FORMAT) )
     {
       afx = new_armor_context ();
       afx->what = secret? 5 : 1;
       push_armor_filter (afx, out);
     }
 
   rc = do_export_stream (ctrl, out, users, secret, NULL, options, stats, &any);
 
   if ( rc || !any )
     iobuf_cancel (out);
   else
     iobuf_close (out);
   release_armor_context (afx);
   return rc;
 }
 
 
 
 /* Release an entire subkey list. */
 static void
 release_subkey_list (subkey_list_t list)
 {
   while (list)
     {
       subkey_list_t tmp = list->next;;
       xfree (list);
       list = tmp;
     }
 }
 
 
 /* Returns true if NODE is a subkey and contained in LIST. */
 static int
 subkey_in_list_p (subkey_list_t list, KBNODE node)
 {
   if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
       || node->pkt->pkttype == PKT_SECRET_SUBKEY )
     {
       u32 kid[2];
 
       keyid_from_pk (node->pkt->pkt.public_key, kid);
 
       for (; list; list = list->next)
         if (list->kid[0] == kid[0] && list->kid[1] == kid[1])
           return 1;
     }
   return 0;
 }
 
 /* Allocate a new subkey list item from NODE. */
 static subkey_list_t
 new_subkey_list_item (KBNODE node)
 {
   subkey_list_t list = xcalloc (1, sizeof *list);
 
   if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
       || node->pkt->pkttype == PKT_SECRET_SUBKEY)
     keyid_from_pk (node->pkt->pkt.public_key, list->kid);
 
   return list;
 }
 
 
 /* Helper function to check whether the subkey at NODE actually
    matches the description at DESC.  The function returns true if the
    key under question has been specified by an exact specification
    (keyID or fingerprint) and does match the one at NODE.  It is
    assumed that the packet at NODE is either a public or secret
    subkey. */
 int
 exact_subkey_match_p (KEYDB_SEARCH_DESC *desc, kbnode_t node)
 {
   u32 kid[2];
   byte fpr[MAX_FINGERPRINT_LEN];
   size_t fprlen;
   int result = 0;
 
   switch(desc->mode)
     {
     case KEYDB_SEARCH_MODE_SHORT_KID:
     case KEYDB_SEARCH_MODE_LONG_KID:
       keyid_from_pk (node->pkt->pkt.public_key, kid);
       break;
 
     case KEYDB_SEARCH_MODE_FPR:
       fingerprint_from_pk (node->pkt->pkt.public_key, fpr, &fprlen);
       break;
 
     default:
       break;
     }
 
   switch(desc->mode)
     {
     case KEYDB_SEARCH_MODE_SHORT_KID:
       if (desc->u.kid[1] == kid[1])
         result = 1;
       break;
 
     case KEYDB_SEARCH_MODE_LONG_KID:
       if (desc->u.kid[0] == kid[0] && desc->u.kid[1] == kid[1])
         result = 1;
       break;
 
     case KEYDB_SEARCH_MODE_FPR:
       if (fprlen == desc->fprlen && !memcmp (desc->u.fpr, fpr, desc->fprlen))
         result = 1;
       break;
 
     default:
       break;
     }
 
   return result;
 }
 
 
 /* Return an error if the key represented by the S-expression S_KEY
  * and the OpenPGP key represented by PK do not use the same curve. */
 static gpg_error_t
 match_curve_skey_pk (gcry_sexp_t s_key, PKT_public_key *pk)
 {
   gcry_sexp_t curve = NULL;
   gcry_sexp_t flags = NULL;
   char *curve_str = NULL;
   char *flag;
   const char *oidstr = NULL;
   gcry_mpi_t curve_as_mpi = NULL;
   gpg_error_t err;
   int is_eddsa = 0;
   int idx = 0;
 
   if (!(pk->pubkey_algo==PUBKEY_ALGO_ECDH
         || pk->pubkey_algo==PUBKEY_ALGO_ECDSA
         || pk->pubkey_algo==PUBKEY_ALGO_EDDSA))
     return gpg_error (GPG_ERR_PUBKEY_ALGO);
 
   curve = gcry_sexp_find_token (s_key, "curve", 0);
   if (!curve)
     {
       log_error ("no reported curve\n");
       return gpg_error (GPG_ERR_UNKNOWN_CURVE);
     }
   curve_str = gcry_sexp_nth_string (curve, 1);
   gcry_sexp_release (curve); curve = NULL;
   if (!curve_str)
     {
       log_error ("no curve name\n");
       return gpg_error (GPG_ERR_UNKNOWN_CURVE);
     }
   if (!strcmp (curve_str, "Ed448"))
     is_eddsa = 1;
   oidstr = openpgp_curve_to_oid (curve_str, NULL, NULL);
   if (!oidstr)
     {
       log_error ("no OID known for curve '%s'\n", curve_str);
       xfree (curve_str);
       return gpg_error (GPG_ERR_UNKNOWN_CURVE);
     }
   xfree (curve_str);
   err = openpgp_oid_from_str (oidstr, &curve_as_mpi);
   if (err)
     return err;
   if (gcry_mpi_cmp (pk->pkey[0], curve_as_mpi))
     {
       log_error ("curves do not match\n");
       gcry_mpi_release (curve_as_mpi);
       return gpg_error (GPG_ERR_INV_CURVE);
     }
   gcry_mpi_release (curve_as_mpi);
   flags = gcry_sexp_find_token (s_key, "flags", 0);
   if (flags)
     {
       for (idx = 1; idx < gcry_sexp_length (flags); idx++)
         {
           flag = gcry_sexp_nth_string (flags, idx);
           if (flag && (strcmp ("eddsa", flag) == 0))
             is_eddsa = 1;
           gcry_free (flag);
         }
     }
   if (is_eddsa != (pk->pubkey_algo == PUBKEY_ALGO_EDDSA))
     {
       log_error ("disagreement about EdDSA\n");
       err = gpg_error (GPG_ERR_INV_CURVE);
     }
 
   return err;
 }
 
 
 /* Return a canonicalized public key algorithms.  This is used to
    compare different flavors of algorithms (e.g. ELG and ELG_E are
    considered the same).  */
 static enum gcry_pk_algos
 canon_pk_algo (enum gcry_pk_algos algo)
 {
   switch (algo)
     {
     case GCRY_PK_RSA:
     case GCRY_PK_RSA_E:
     case GCRY_PK_RSA_S: return GCRY_PK_RSA;
     case GCRY_PK_ELG:
     case GCRY_PK_ELG_E: return GCRY_PK_ELG;
     case GCRY_PK_ECC:
     case GCRY_PK_ECDSA:
     case GCRY_PK_ECDH: return GCRY_PK_ECC;
     default: return algo;
     }
 }
 
 
 /* Take a cleartext dump of a secret key in PK and change the
  * parameter array in PK to include the secret parameters.  */
 static gpg_error_t
 cleartext_secret_key_to_openpgp (gcry_sexp_t s_key, PKT_public_key *pk)
 {
   gpg_error_t err;
   gcry_sexp_t top_list;
   gcry_sexp_t key = NULL;
   char *key_type = NULL;
   enum gcry_pk_algos pk_algo;
   struct seckey_info *ski;
   int idx, sec_start;
   gcry_mpi_t pub_params[10] = { NULL };
 
   /* we look for a private-key, then the first element in it tells us
      the type */
   top_list = gcry_sexp_find_token (s_key, "private-key", 0);
   if (!top_list)
     goto bad_seckey;
 
   /* ignore all S-expression after the first sublist -- we assume that
      they are comments or otherwise irrelevant to OpenPGP */
   if (gcry_sexp_length(top_list) < 2)
     goto bad_seckey;
   key = gcry_sexp_nth (top_list, 1);
   if (!key)
     goto bad_seckey;
   key_type = gcry_sexp_nth_string(key, 0);
   pk_algo = gcry_pk_map_name (key_type);
 
   log_assert (!pk->seckey_info);
 
   pk->seckey_info = ski = xtrycalloc (1, sizeof *ski);
   if (!ski)
     {
       err = gpg_error_from_syserror ();
       goto leave;
     }
 
   switch (canon_pk_algo (pk_algo))
     {
     case GCRY_PK_RSA:
       if (!is_RSA (pk->pubkey_algo))
         goto bad_pubkey_algo;
       err = gcry_sexp_extract_param (key, NULL, "ne",
                                      &pub_params[0],
                                      &pub_params[1],
                                      NULL);
       for (idx=0; idx < 2 && !err; idx++)
         if (gcry_mpi_cmp(pk->pkey[idx], pub_params[idx]))
           err = gpg_error (GPG_ERR_BAD_PUBKEY);
       if (!err)
         {
           for (idx = 2; idx < 6 && !err; idx++)
             {
               gcry_mpi_release (pk->pkey[idx]);
               pk->pkey[idx] = NULL;
             }
           err = gcry_sexp_extract_param (key, NULL, "dpqu",
                                          &pk->pkey[2],
                                          &pk->pkey[3],
                                          &pk->pkey[4],
                                          &pk->pkey[5],
                                          NULL);
         }
       if (!err)
         {
           for (idx = 2; idx < 6; idx++)
             ski->csum += checksum_mpi (pk->pkey[idx]);
         }
       break;
 
     case GCRY_PK_DSA:
       if (!is_DSA (pk->pubkey_algo))
         goto bad_pubkey_algo;
       err = gcry_sexp_extract_param (key, NULL, "pqgy",
                                      &pub_params[0],
                                      &pub_params[1],
                                      &pub_params[2],
                                      &pub_params[3],
                                      NULL);
       for (idx=0; idx < 4 && !err; idx++)
         if (gcry_mpi_cmp(pk->pkey[idx], pub_params[idx]))
           err = gpg_error (GPG_ERR_BAD_PUBKEY);
       if (!err)
         {
           gcry_mpi_release (pk->pkey[4]);
           pk->pkey[4] = NULL;
           err = gcry_sexp_extract_param (key, NULL, "x",
                                          &pk->pkey[4],
                                          NULL);
         }
       if (!err)
         ski->csum += checksum_mpi (pk->pkey[4]);
       break;
 
     case GCRY_PK_ELG:
       if (!is_ELGAMAL (pk->pubkey_algo))
         goto bad_pubkey_algo;
       err = gcry_sexp_extract_param (key, NULL, "pgy",
                                      &pub_params[0],
                                      &pub_params[1],
                                      &pub_params[2],
                                      NULL);
       for (idx=0; idx < 3 && !err; idx++)
         if (gcry_mpi_cmp(pk->pkey[idx], pub_params[idx]))
           err = gpg_error (GPG_ERR_BAD_PUBKEY);
       if (!err)
         {
           gcry_mpi_release (pk->pkey[3]);
           pk->pkey[3] = NULL;
           err = gcry_sexp_extract_param (key, NULL, "x",
                                          &pk->pkey[3],
                                          NULL);
         }
       if (!err)
         ski->csum += checksum_mpi (pk->pkey[3]);
       break;
 
     case GCRY_PK_ECC:
       err = match_curve_skey_pk (key, pk);
       if (err)
         goto leave;
       else
         err = sexp_extract_param_sos (key, "q", &pub_params[0]);
       if (!err && (gcry_mpi_cmp(pk->pkey[1], pub_params[0])))
         err = gpg_error (GPG_ERR_BAD_PUBKEY);
 
       sec_start = 2;
       if (pk->pubkey_algo == PUBKEY_ALGO_ECDH)
         sec_start += 1;
       if (!err)
         {
           gcry_mpi_release (pk->pkey[sec_start]);
           pk->pkey[sec_start] = NULL;
           err = sexp_extract_param_sos (key, "d", &pk->pkey[sec_start]);
         }
 
       if (!err)
         ski->csum += checksum_mpi (pk->pkey[sec_start]);
       break;
 
     default:
       pk->seckey_info = NULL;
       xfree (ski);
       err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
       break;
     }
 
  leave:
   gcry_sexp_release (top_list);
   gcry_sexp_release (key);
   gcry_free (key_type);
 
   for (idx=0; idx < DIM(pub_params); idx++)
     gcry_mpi_release (pub_params[idx]);
   return err;
 
  bad_pubkey_algo:
   err = gpg_error (GPG_ERR_PUBKEY_ALGO);
   goto leave;
 
  bad_seckey:
   err = gpg_error (GPG_ERR_BAD_SECKEY);
   goto leave;
 }
 
 
 /* Use the key transfer format given in S_PGP to create the secinfo
    structure in PK and change the parameter array in PK to include the
    secret parameters.  */
 static gpg_error_t
 transfer_format_to_openpgp (gcry_sexp_t s_pgp, PKT_public_key *pk)
 {
   gpg_error_t err;
   gcry_sexp_t top_list;
   gcry_sexp_t list = NULL;
   char *curve = NULL;
   const char *value;
   size_t valuelen;
   char *string;
   int  idx;
   int  is_v4, is_protected;
   enum gcry_pk_algos pk_algo;
   int  protect_algo = 0;
   char iv[16];
   int  ivlen = 0;
   int  s2k_mode = 0;
   int  s2k_algo = 0;
   byte s2k_salt[8];
   u32  s2k_count = 0;
   int  is_ecdh = 0;
   size_t npkey, nskey;
   gcry_mpi_t skey[10];  /* We support up to 9 parameters.  */
   int skeyidx = 0;
   struct seckey_info *ski;
 
   /* gcry_log_debugsxp ("transferkey", s_pgp); */
   top_list = gcry_sexp_find_token (s_pgp, "openpgp-private-key", 0);
   if (!top_list)
     goto bad_seckey;
 
   list = gcry_sexp_find_token (top_list, "version", 0);
   if (!list)
     goto bad_seckey;
   value = gcry_sexp_nth_data (list, 1, &valuelen);
   if (!value || valuelen != 1 || !(value[0] == '3' || value[0] == '4'))
     goto bad_seckey;
   is_v4 = (value[0] == '4');
 
   gcry_sexp_release (list);
   list = gcry_sexp_find_token (top_list, "protection", 0);
   if (!list)
     goto bad_seckey;
   value = gcry_sexp_nth_data (list, 1, &valuelen);
   if (!value)
     goto bad_seckey;
   if (valuelen == 4 && !memcmp (value, "sha1", 4))
     is_protected = 2;
   else if (valuelen == 3 && !memcmp (value, "sum", 3))
     is_protected = 1;
   else if (valuelen == 4 && !memcmp (value, "none", 4))
     is_protected = 0;
   else
     goto bad_seckey;
   if (is_protected)
     {
       string = gcry_sexp_nth_string (list, 2);
       if (!string)
         goto bad_seckey;
       protect_algo = gcry_cipher_map_name (string);
       xfree (string);
 
       value = gcry_sexp_nth_data (list, 3, &valuelen);
       if (!value || !valuelen || valuelen > sizeof iv)
         goto bad_seckey;
       memcpy (iv, value, valuelen);
       ivlen = valuelen;
 
       string = gcry_sexp_nth_string (list, 4);
       if (!string)
         goto bad_seckey;
       s2k_mode = strtol (string, NULL, 10);
       xfree (string);
 
       string = gcry_sexp_nth_string (list, 5);
       if (!string)
         goto bad_seckey;
       s2k_algo = gcry_md_map_name (string);
       xfree (string);
 
       value = gcry_sexp_nth_data (list, 6, &valuelen);
       if (!value || !valuelen || valuelen > sizeof s2k_salt)
         goto bad_seckey;
       memcpy (s2k_salt, value, valuelen);
 
       string = gcry_sexp_nth_string (list, 7);
       if (!string)
         goto bad_seckey;
       s2k_count = strtoul (string, NULL, 10);
       xfree (string);
     }
 
   /* Parse the gcrypt PK algo and check that it is okay.  */
   gcry_sexp_release (list);
   list = gcry_sexp_find_token (top_list, "algo", 0);
   if (!list)
     goto bad_seckey;
   string = gcry_sexp_nth_string (list, 1);
   if (!string)
     goto bad_seckey;
   pk_algo = gcry_pk_map_name (string);
   xfree (string); string = NULL;
   if (gcry_pk_algo_info (pk_algo, GCRYCTL_GET_ALGO_NPKEY, NULL, &npkey)
       || gcry_pk_algo_info (pk_algo, GCRYCTL_GET_ALGO_NSKEY, NULL, &nskey)
       || !npkey || npkey >= nskey)
     goto bad_seckey;
 
   /* Check that the pubkey algo matches the one from the public key.  */
   switch (canon_pk_algo (pk_algo))
     {
     case GCRY_PK_RSA:
       if (!is_RSA (pk->pubkey_algo))
         pk_algo = 0;  /* Does not match.  */
       break;
     case GCRY_PK_DSA:
       if (!is_DSA (pk->pubkey_algo))
         pk_algo = 0;  /* Does not match.  */
       break;
     case GCRY_PK_ELG:
       if (!is_ELGAMAL (pk->pubkey_algo))
         pk_algo = 0;  /* Does not match.  */
       break;
     case GCRY_PK_ECC:
       if (pk->pubkey_algo == PUBKEY_ALGO_ECDSA)
         ;
       else if (pk->pubkey_algo == PUBKEY_ALGO_ECDH)
         is_ecdh = 1;
       else if (pk->pubkey_algo == PUBKEY_ALGO_EDDSA)
         ;
       else
         pk_algo = 0;  /* Does not match.  */
       /* For ECC we do not have the domain parameters thus fix our info.  */
       npkey = 1;
       nskey = 2;
       break;
     default:
       pk_algo = 0;   /* Oops.  */
       break;
     }
   if (!pk_algo)
     {
       err = gpg_error (GPG_ERR_PUBKEY_ALGO);
       goto leave;
     }
 
   /* This check has to go after the ecc adjustments. */
   if (nskey > PUBKEY_MAX_NSKEY)
     goto bad_seckey;
 
   /* Parse the key parameters.  */
   gcry_sexp_release (list);
   list = gcry_sexp_find_token (top_list, "skey", 0);
   if (!list)
     goto bad_seckey;
   for (idx=0;;)
     {
       int is_enc;
 
       value = gcry_sexp_nth_data (list, ++idx, &valuelen);
       if (!value && skeyidx >= npkey)
         break;  /* Ready.  */
 
       /* Check for too many parameters.  Note that depending on the
          protection mode and version number we may see less than NSKEY
          (but at least NPKEY+1) parameters.  */
       if (idx >= 2*nskey)
         goto bad_seckey;
       if (skeyidx >= DIM (skey)-1)
         goto bad_seckey;
 
       if (!value || valuelen != 1 || !(value[0] == '_' || value[0] == 'e'))
         goto bad_seckey;
       is_enc = (value[0] == 'e');
       value = gcry_sexp_nth_data (list, ++idx, &valuelen);
       if (!value || !valuelen)
         goto bad_seckey;
       if (is_enc
           || pk->pubkey_algo == PUBKEY_ALGO_ECDSA
           || pk->pubkey_algo == PUBKEY_ALGO_EDDSA
           || pk->pubkey_algo == PUBKEY_ALGO_ECDH)
         {
           unsigned int nbits = valuelen*8;
           const unsigned char *p = value;
 
           if (*p && nbits >= 8 && !(*p & 0x80))
             if (--nbits >= 7 && !(*p & 0x40))
               if (--nbits >= 6 && !(*p & 0x20))
                 if (--nbits >= 5 && !(*p & 0x10))
                   if (--nbits >= 4 && !(*p & 0x08))
                     if (--nbits >= 3 && !(*p & 0x04))
                       if (--nbits >= 2 && !(*p & 0x02))
                         if (--nbits >= 1 && !(*p & 0x01))
                           --nbits;
 
           skey[skeyidx] = gcry_mpi_set_opaque_copy (NULL, value, nbits);
           if (!skey[skeyidx])
             goto outofmem;
           if (is_enc)
             gcry_mpi_set_flag (skey[skeyidx], GCRYMPI_FLAG_USER1);
           else
             gcry_mpi_set_flag (skey[skeyidx], GCRYMPI_FLAG_USER2);
         }
       else
         {
           if (gcry_mpi_scan (skey + skeyidx, GCRYMPI_FMT_STD,
                              value, valuelen, NULL))
             goto bad_seckey;
         }
       skeyidx++;
     }
   skey[skeyidx++] = NULL;
 
   gcry_sexp_release (list); list = NULL;
 
   /* We have no need for the CSUM value thus we don't parse it.  */
   /* list = gcry_sexp_find_token (top_list, "csum", 0); */
   /* if (list) */
   /*   { */
   /*     string = gcry_sexp_nth_string (list, 1); */
   /*     if (!string) */
   /*       goto bad_seckey; */
   /*     desired_csum = strtoul (string, NULL, 10); */
   /*     xfree (string); */
   /*   } */
   /* else */
   /*   desired_csum = 0; */
   /* gcry_sexp_release (list); list = NULL; */
 
   /* Get the curve name if any,  */
   list = gcry_sexp_find_token (top_list, "curve", 0);
   if (list)
     {
       curve = gcry_sexp_nth_string (list, 1);
       gcry_sexp_release (list); list = NULL;
     }
 
   gcry_sexp_release (top_list); top_list = NULL;
 
   /* log_debug ("XXX is_v4=%d\n", is_v4); */
   /* log_debug ("XXX pubkey_algo=%d\n", pubkey_algo); */
   /* log_debug ("XXX is_protected=%d\n", is_protected); */
   /* log_debug ("XXX protect_algo=%d\n", protect_algo); */
   /* log_printhex ("XXX iv", iv, ivlen); */
   /* log_debug ("XXX ivlen=%d\n", ivlen); */
   /* log_debug ("XXX s2k_mode=%d\n", s2k_mode); */
   /* log_debug ("XXX s2k_algo=%d\n", s2k_algo); */
   /* log_printhex ("XXX s2k_salt", s2k_salt, sizeof s2k_salt); */
   /* log_debug ("XXX s2k_count=%lu\n", (unsigned long)s2k_count); */
   /* for (idx=0; skey[idx]; idx++) */
   /*   { */
   /*     int is_enc = gcry_mpi_get_flag (skey[idx], GCRYMPI_FLAG_OPAQUE); */
   /*     log_info ("XXX skey[%d]%s:", idx, is_enc? " (enc)":""); */
   /*     if (is_enc) */
   /*       { */
   /*         void *p; */
   /*         unsigned int nbits; */
   /*         p = gcry_mpi_get_opaque (skey[idx], &nbits); */
   /*         log_printhex (NULL, p, (nbits+7)/8); */
   /*       } */
   /*     else */
   /*       gcry_mpi_dump (skey[idx]); */
   /*     log_printf ("\n"); */
   /*   } */
 
   if (!is_v4 || is_protected != 2 )
     {
       /* We only support the v4 format and a SHA-1 checksum.  */
       err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
       goto leave;
     }
 
   /* We need to change the received parameters for ECC algorithms.
      The transfer format has the curve name and the parameters
      separate.  We put them all into the SKEY array.  */
   if (canon_pk_algo (pk_algo) == GCRY_PK_ECC)
     {
       const char *oidstr;
 
       /* Assert that all required parameters are available.  We also
          check that the array does not contain more parameters than
          needed (this was used by some beta versions of 2.1.  */
       if (!curve || !skey[0] || !skey[1] || skey[2])
         {
           err = gpg_error (GPG_ERR_INTERNAL);
           goto leave;
         }
 
       oidstr = openpgp_curve_to_oid (curve, NULL, NULL);
       if (!oidstr)
         {
           log_error ("no OID known for curve '%s'\n", curve);
           err = gpg_error (GPG_ERR_UNKNOWN_CURVE);
           goto leave;
         }
       /* Put the curve's OID into the MPI array.  This requires
          that we shift Q and D.  For ECDH also insert the KDF parms. */
       if (is_ecdh)
         {
           skey[4] = NULL;
           skey[3] = skey[1];
           skey[2] = gcry_mpi_copy (pk->pkey[2]);
         }
       else
         {
           skey[3] = NULL;
           skey[2] = skey[1];
         }
       skey[1] = skey[0];
       skey[0] = NULL;
       err = openpgp_oid_from_str (oidstr, skey + 0);
       if (err)
         goto leave;
       /* Fixup the NPKEY and NSKEY to match OpenPGP reality.  */
       npkey = 2 + is_ecdh;
       nskey = 3 + is_ecdh;
 
       /* for (idx=0; skey[idx]; idx++) */
       /*   { */
       /*     log_info ("YYY skey[%d]:", idx); */
       /*     if (gcry_mpi_get_flag (skey[idx], GCRYMPI_FLAG_OPAQUE)) */
       /*       { */
       /*         void *p; */
       /*         unsigned int nbits; */
       /*         p = gcry_mpi_get_opaque (skey[idx], &nbits); */
       /*         log_printhex (NULL, p, (nbits+7)/8); */
       /*       } */
       /*     else */
       /*       gcry_mpi_dump (skey[idx]); */
       /*     log_printf ("\n"); */
       /*   } */
     }
 
   /* Do some sanity checks.  */
   if (s2k_count > 255)
     {
       /* We expect an already encoded S2K count.  */
       err = gpg_error (GPG_ERR_INV_DATA);
       goto leave;
     }
   err = openpgp_cipher_test_algo (protect_algo);
   if (err)
     goto leave;
   err = openpgp_md_test_algo (s2k_algo);
   if (err)
     goto leave;
 
   /* Check that the public key parameters match.  Note that since
      Libgcrypt 1.5 gcry_mpi_cmp handles opaque MPI correctly.  */
   for (idx=0; idx < npkey; idx++)
     if (gcry_mpi_cmp (pk->pkey[idx], skey[idx]))
       {
         err = gpg_error (GPG_ERR_BAD_PUBKEY);
         goto leave;
       }
 
   /* Check that the first secret key parameter in SKEY is encrypted
      and that there are no more secret key parameters.  The latter is
      guaranteed by the v4 packet format.  */
   if (!gcry_mpi_get_flag (skey[npkey], GCRYMPI_FLAG_USER1))
     goto bad_seckey;
   if (npkey+1 < DIM (skey) && skey[npkey+1])
     goto bad_seckey;
 
   /* Check that the secret key parameters in PK are all set to NULL. */
   for (idx=npkey; idx < nskey; idx++)
     if (pk->pkey[idx])
       goto bad_seckey;
 
   /* Now build the protection info. */
   pk->seckey_info = ski = xtrycalloc (1, sizeof *ski);
   if (!ski)
     {
       err = gpg_error_from_syserror ();
       goto leave;
     }
 
   ski->is_protected = 1;
   ski->sha1chk = 1;
   ski->algo = protect_algo;
   ski->s2k.mode = s2k_mode;
   ski->s2k.hash_algo = s2k_algo;
   log_assert (sizeof ski->s2k.salt == sizeof s2k_salt);
   memcpy (ski->s2k.salt, s2k_salt, sizeof s2k_salt);
   ski->s2k.count = s2k_count;
   log_assert (ivlen <= sizeof ski->iv);
   memcpy (ski->iv, iv, ivlen);
   ski->ivlen = ivlen;
 
   /* Store the protected secret key parameter.  */
   pk->pkey[npkey] = skey[npkey];
   skey[npkey] = NULL;
 
   /* That's it.  */
 
  leave:
   gcry_free (curve);
   gcry_sexp_release (list);
   gcry_sexp_release (top_list);
   for (idx=0; idx < skeyidx; idx++)
     gcry_mpi_release (skey[idx]);
   return err;
 
  bad_seckey:
   err = gpg_error (GPG_ERR_BAD_SECKEY);
   goto leave;
 
  outofmem:
   err = gpg_error (GPG_ERR_ENOMEM);
   goto leave;
 }
 
 
 /* Print an "EXPORTED" status line.  PK is the primary public key.  */
 static void
 print_status_exported (PKT_public_key *pk)
 {
   char *hexfpr;
 
   if (!is_status_enabled ())
     return;
 
   hexfpr = hexfingerprint (pk, NULL, 0);
   write_status_text (STATUS_EXPORTED, hexfpr? hexfpr : "[?]");
   xfree (hexfpr);
 }
 
 
 /*
  * Receive a secret key from agent specified by HEXGRIP.
  *
  * Since the key data from the agent is encrypted, decrypt it using
  * CIPHERHD context.  Then, parse the decrypted key data into transfer
  * format, and put secret parameters into PK.
  *
  * If CLEARTEXT is 0, store the secret key material
  * passphrase-protected.  Otherwise, store secret key material in the
  * clear.
  *
  * CACHE_NONCE_ADDR is used to share nonce for multiple key retrievals.
  */
 gpg_error_t
 receive_seckey_from_agent (ctrl_t ctrl, gcry_cipher_hd_t cipherhd,
                            int cleartext,
                            char **cache_nonce_addr, const char *hexgrip,
                            PKT_public_key *pk)
 {
   gpg_error_t err = 0;
   unsigned char *wrappedkey = NULL;
   size_t wrappedkeylen;
   unsigned char *key = NULL;
   size_t keylen, realkeylen;
   gcry_sexp_t s_skey;
   char *prompt;
 
   if (opt.verbose)
     log_info ("key %s: asking agent for the secret parts\n", hexgrip);
 
   prompt = gpg_format_keydesc (ctrl, pk, FORMAT_KEYDESC_EXPORT,1);
   err = agent_export_key (ctrl, hexgrip, prompt, !cleartext, cache_nonce_addr,
                           &wrappedkey, &wrappedkeylen,
 			  pk->keyid, pk->main_keyid, pk->pubkey_algo);
   xfree (prompt);
 
   if (err)
     goto unwraperror;
   if (wrappedkeylen < 24)
     {
       err = gpg_error (GPG_ERR_INV_LENGTH);
       goto unwraperror;
     }
   keylen = wrappedkeylen - 8;
   key = xtrymalloc_secure (keylen);
   if (!key)
     {
       err = gpg_error_from_syserror ();
       goto unwraperror;
     }
   err = gcry_cipher_decrypt (cipherhd, key, keylen, wrappedkey, wrappedkeylen);
   if (err)
     goto unwraperror;
   realkeylen = gcry_sexp_canon_len (key, keylen, NULL, &err);
   if (!realkeylen)
     goto unwraperror; /* Invalid csexp.  */
 
   err = gcry_sexp_sscan (&s_skey, NULL, key, realkeylen);
   if (!err)
     {
       if (cleartext)
         err = cleartext_secret_key_to_openpgp (s_skey, pk);
       else
         err = transfer_format_to_openpgp (s_skey, pk);
       gcry_sexp_release (s_skey);
     }
 
  unwraperror:
   xfree (key);
   xfree (wrappedkey);
   if (err)
     {
       log_error ("key %s: error receiving key from agent:"
                  " %s%s\n", hexgrip, gpg_strerror (err),
                  gpg_err_code (err) == GPG_ERR_FULLY_CANCELED?
                  "":_(" - skipped"));
     }
   return err;
 }
 
 
 /* Write KEYBLOCK either to stdout or to the file set with the
  * --output option.  This is a simplified version of do_export_stream
  * which supports only a few export options.  */
 gpg_error_t
 write_keyblock_to_output (kbnode_t keyblock, int with_armor,
                           unsigned int options)
 {
   gpg_error_t err;
   const char *fname;
   iobuf_t out;
   kbnode_t node;
   armor_filter_context_t *afx = NULL;
   iobuf_t out_help = NULL;
   PKT_public_key *pk = NULL;
 
   fname = opt.outfile? opt.outfile : "-";
   if (is_secured_filename (fname) )
     return gpg_error (GPG_ERR_EPERM);
 
   out = iobuf_create (fname, 0);
   if (!out)
     {
       err = gpg_error_from_syserror ();
       log_error(_("can't create '%s': %s\n"), fname, gpg_strerror (err));
       return err;
     }
   if (opt.verbose)
     log_info (_("writing to '%s'\n"), iobuf_get_fname_nonnull (out));
 
   if ((options & EXPORT_DANE_FORMAT))
     {
       with_armor = 0;
       out_help = iobuf_temp ();
     }
 
   if (with_armor)
     {
       afx = new_armor_context ();
       afx->what = 1;
       push_armor_filter (afx, out);
     }
 
   for (node = keyblock; node; node = node->next)
     {
       if (is_deleted_kbnode (node))
         continue;
       if (node->pkt->pkttype == PKT_RING_TRUST)
         continue; /* Skip - they should not be here anyway.  */
 
       if (!pk && (node->pkt->pkttype == PKT_PUBLIC_KEY
                   || node->pkt->pkttype == PKT_SECRET_KEY))
         pk = node->pkt->pkt.public_key;
 
       if ((options & EXPORT_BACKUP))
         err = build_packet_and_meta (out_help? out_help : out, node->pkt);
       else
         err = build_packet (out_help? out_help : out, node->pkt);
       if (err)
         {
           log_error ("build_packet(%d) failed: %s\n",
                      node->pkt->pkttype, gpg_strerror (err) );
           goto leave;
         }
     }
   err = 0;
 
   if (out_help && pk && (options & EXPORT_DANE_FORMAT))
     {
       const void *data;
       size_t datalen;
 
       iobuf_flush_temp (out_help);
       data = iobuf_get_temp_buffer (out_help);
       datalen = iobuf_get_temp_length (out_help);
 
       err = print_dane_records (out, keyblock, pk, data, datalen);
     }
 
  leave:
   if (err)
     iobuf_cancel (out);
   else
     iobuf_close (out);
   iobuf_cancel (out_help);
   release_armor_context (afx);
   return err;
 }
 
 
 /*
  * 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-subkey 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_subkey_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_PUBLIC_SUBKEY
           || node->pkt->pkttype == PKT_SECRET_SUBKEY)
         {
           parm.node = node;
           if (recsel_select (selector, impex_filter_getval, &parm))
             {
               /*log_debug ("drop-subkey: deleting a key\n");*/
               /* The subkey packet and all following packets up to the
                * next subkey.  */
               delete_kbnode (node);
               for (; node->next
                      && node->next->pkt->pkttype != PKT_PUBLIC_SUBKEY
                      && node->next->pkt->pkttype != PKT_SECRET_SUBKEY ;
                    node = node->next)
                 delete_kbnode (node->next);
 	    }
         }
     }
 }
 
 
 /* Print DANErecords for all user IDs in KEYBLOCK to OUT.  The data
  * for the record is taken from (DATA,DATELEN).  PK is the public key
  * packet with the primary key. */
 static gpg_error_t
 print_dane_records (iobuf_t out, kbnode_t keyblock, PKT_public_key *pk,
                     const void *data, size_t datalen)
 {
   gpg_error_t err = 0;
   kbnode_t kbctx, node;
   PKT_user_id *uid;
   char *mbox = NULL;
   char hashbuf[32];
   char *hash = NULL;
   char *domain;
   const char *s;
   unsigned int len;
   estream_t fp = NULL;
   char *hexdata = NULL;
   char *hexfpr;
 
   hexfpr = hexfingerprint (pk, NULL, 0);
   if (!hexfpr)
     {
       err = gpg_error_from_syserror ();
       goto leave;
     }
   hexdata = bin2hex (data, datalen, NULL);
   if (!hexdata)
     {
       err = gpg_error_from_syserror ();
       goto leave;
     }
   ascii_strlwr (hexdata);
   fp = es_fopenmem (0, "rw,samethread");
   if (!fp)
     {
       err = gpg_error_from_syserror ();
       goto leave;
     }
 
   for (kbctx = NULL; (node = walk_kbnode (keyblock, &kbctx, 0));)
     {
       if (node->pkt->pkttype != PKT_USER_ID)
         continue;
       uid = node->pkt->pkt.user_id;
 
       if (uid->flags.expired || uid->flags.revoked)
         continue;
 
       xfree (mbox);
       mbox = mailbox_from_userid (uid->name, 0);
       if (!mbox)
         continue;
 
       domain = strchr (mbox, '@');
       *domain++ = 0;
 
       if (1)
         {
           es_fprintf (fp, "$ORIGIN _openpgpkey.%s.\n; %s\n; ", domain, hexfpr);
           print_utf8_buffer (fp, uid->name, uid->len);
           es_putc ('\n', fp);
           gcry_md_hash_buffer (GCRY_MD_SHA256, hashbuf, mbox, strlen (mbox));
           xfree (hash);
           hash = bin2hex (hashbuf, 28, NULL);
           if (!hash)
             {
               err = gpg_error_from_syserror ();
               goto leave;
             }
           ascii_strlwr (hash);
           len = strlen (hexdata)/2;
           es_fprintf (fp, "%s TYPE61 \\# %u (\n", hash, len);
           for (s = hexdata; ;)
             {
               es_fprintf (fp, "\t%.64s\n", s);
               if (strlen (s) < 64)
                 break;
               s += 64;
             }
           es_fputs ("\t)\n\n", fp);
         }
     }
 
   /* Make sure it is a string and write it.  */
   es_fputc (0, fp);
   {
     void *vp;
 
     if (es_fclose_snatch (fp, &vp, NULL))
       {
         err = gpg_error_from_syserror ();
         goto leave;
       }
     fp = NULL;
     iobuf_writestr (out, vp);
     es_free (vp);
   }
   err = 0;
 
  leave:
   xfree (hash);
   xfree (mbox);
   es_fclose (fp);
   xfree (hexdata);
   xfree (hexfpr);
   return err;
 }
 
 
 /* Helper for do_export_stream which writes one keyblock to OUT.  */
 static gpg_error_t
 do_export_one_keyblock (ctrl_t ctrl, kbnode_t keyblock, u32 *keyid,
                         iobuf_t out, int secret, unsigned int options,
                         export_stats_t stats, int *any,
                         KEYDB_SEARCH_DESC *desc, size_t ndesc,
                         size_t descindex, gcry_cipher_hd_t cipherhd)
 {
   gpg_error_t err = gpg_error (GPG_ERR_NOT_FOUND);
   char *cache_nonce = NULL;
   subkey_list_t subkey_list = NULL;  /* Track already processed subkeys. */
   int skip_until_subkey = 0;
   int cleartext = 0;
   char *hexgrip = NULL;
   char *serialno = NULL;
   PKT_public_key *pk;
   u32 subkidbuf[2], *subkid;
   kbnode_t kbctx, node;
 
   /* NB: walk_kbnode skips packets marked as deleted.  */
   for (kbctx=NULL; (node = walk_kbnode (keyblock, &kbctx, 0)); )
     {
       if (skip_until_subkey)
         {
           if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
             skip_until_subkey = 0;
           else
             continue;
         }
 
       /* We used to use comment packets, but not any longer.  In
        * case we still have comments on a key, strip them here
        * before we call build_packet(). */
       if (node->pkt->pkttype == PKT_COMMENT)
         continue;
 
       /* Skip ring trust packets - they should not be here anyway.  */
       if (node->pkt->pkttype == PKT_RING_TRUST)
         continue;
 
       /* If exact is set, then we only export what was requested
        * (plus the primary key, if the user didn't specifically
        * request it). */
       if (desc[descindex].exact && node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
         {
           if (!exact_subkey_match_p (desc+descindex, node))
             {
               /* Before skipping this subkey, check whether any
                * other description wants an exact match on a
                * subkey and include that subkey into the output
                * too.  Need to add this subkey to a list so that
                * it won't get processed a second time.
                *
                * So the first step here is to check that list and
                * skip in any case if the key is in that list.
                *
                * We need this whole mess because the import
                * function of GnuPG < 2.1 is not able to merge
                * secret keys and thus it is useless to output them
                * as two separate keys and have import merge them.
                */
               if (subkey_in_list_p (subkey_list, node))
                 skip_until_subkey = 1; /* Already processed this one. */
               else
                 {
                   size_t j;
 
                   for (j=0; j < ndesc; j++)
                     if (j != descindex && desc[j].exact
                         && exact_subkey_match_p (desc+j, node))
                       break;
                   if (!(j < ndesc))
                     skip_until_subkey = 1; /* No other one matching. */
                 }
             }
 
           if (skip_until_subkey)
             continue;
 
           /* Mark this one as processed. */
           {
             subkey_list_t tmp = new_subkey_list_item (node);
             tmp->next = subkey_list;
             subkey_list = tmp;
           }
         }
 
       if (node->pkt->pkttype == PKT_SIGNATURE)
         {
           /* Do not export packets which are marked as not
            * exportable.  */
           if (!(options & EXPORT_LOCAL_SIGS)
               && !node->pkt->pkt.signature->flags.exportable)
             continue; /* not exportable */
 
           /* Do not export packets with a "sensitive" revocation key
            * unless the user wants us to.  Note that we do export
            * these when issuing the actual revocation (see revoke.c). */
           if (!(options & EXPORT_SENSITIVE_REVKEYS)
               && node->pkt->pkt.signature->revkey)
             {
               int i;
 
               for (i = 0; i < node->pkt->pkt.signature->numrevkeys; i++)
                 if ((node->pkt->pkt.signature->revkey[i].class & 0x40))
                   break;
               if (i < node->pkt->pkt.signature->numrevkeys)
                 continue;
             }
         }
 
       /* Don't export attribs? */
       if (!(options & EXPORT_ATTRIBUTES)
           && node->pkt->pkttype == PKT_USER_ID
           && node->pkt->pkt.user_id->attrib_data)
         {
           /* Skip until we get to something that is not an attrib or a
            * signature on an attrib.  */
           while (kbctx->next && kbctx->next->pkt->pkttype == PKT_SIGNATURE)
             kbctx = kbctx->next;
 
           continue;
         }
 
       if (secret && (node->pkt->pkttype == PKT_PUBLIC_KEY
                      || node->pkt->pkttype == PKT_PUBLIC_SUBKEY))
         {
           pk = node->pkt->pkt.public_key;
           if (node->pkt->pkttype == PKT_PUBLIC_KEY)
             subkid = NULL;
           else
             {
               keyid_from_pk (pk, subkidbuf);
               subkid = subkidbuf;
             }
 
           if (pk->seckey_info)
             {
               log_error ("key %s: oops: seckey_info already set"
                          " - skipped\n", keystr_with_sub (keyid, subkid));
               skip_until_subkey = 1;
               continue;
             }
 
           xfree (hexgrip);
           err = hexkeygrip_from_pk (pk, &hexgrip);
           if (err)
             {
               log_error ("key %s: error computing keygrip: %s"
                          " - skipped\n", keystr_with_sub (keyid, subkid),
                          gpg_strerror (err));
               skip_until_subkey = 1;
               err = 0;
               continue;
             }
 
           xfree (serialno);
           serialno = NULL;
           if (secret == 2 && node->pkt->pkttype == PKT_PUBLIC_KEY)
             {
               /* We are asked not to export the secret parts of the
                * primary key.  Make up an error code to create the
                * stub.  */
               err = GPG_ERR_NOT_FOUND;
             }
           else
             err = agent_get_keyinfo (ctrl, hexgrip, &serialno, &cleartext);
 
           if ((!err && serialno)
               && secret == 2 && node->pkt->pkttype == PKT_PUBLIC_KEY)
             {
               /* It does not make sense to export a key with its
                * primary key on card using a non-key stub.  Thus we
                * skip those keys when used with --export-secret-subkeys. */
               log_info (_("key %s: key material on-card - skipped\n"),
                         keystr_with_sub (keyid, subkid));
               skip_until_subkey = 1;
             }
           else if (gpg_err_code (err) == GPG_ERR_NOT_FOUND
                    || (!err && serialno))
             {
               /* Create a key stub.  */
               struct seckey_info *ski;
               const char *s;
 
               pk->seckey_info = ski = xtrycalloc (1, sizeof *ski);
               if (!ski)
                 {
                   err = gpg_error_from_syserror ();
                   goto leave;
                 }
 
               ski->is_protected = 1;
               if (err)
                 ski->s2k.mode = 1001; /* GNU dummy (no secret key).  */
               else
                 {
                   ski->s2k.mode = 1002; /* GNU-divert-to-card.  */
                   for (s=serialno; sizeof (ski->ivlen) && *s && s[1];
                        ski->ivlen++, s += 2)
                     ski->iv[ski->ivlen] = xtoi_2 (s);
                 }
 
               if ((options & EXPORT_BACKUP))
                 err = build_packet_and_meta (out, node->pkt);
               else
                 err = build_packet (out, node->pkt);
               if (!err && node->pkt->pkttype == PKT_PUBLIC_KEY)
                 {
                   stats->exported++;
                   print_status_exported (node->pkt->pkt.public_key);
                 }
             }
           else if (!err)
             {
               err = receive_seckey_from_agent (ctrl, cipherhd,
                                                cleartext, &cache_nonce,
                                                hexgrip, pk);
               if (err)
                 {
                   if (gpg_err_code (err) == GPG_ERR_FULLY_CANCELED)
                     goto leave;
                   write_status_error ("export_keys.secret", err);
                   skip_until_subkey = 1;
                   err = 0;
                 }
               else
                 {
                   if ((options & EXPORT_BACKUP))
                     err = build_packet_and_meta (out, node->pkt);
                   else
                     err = build_packet (out, node->pkt);
                   if (node->pkt->pkttype == PKT_PUBLIC_KEY)
                     {
                       stats->exported++;
                       print_status_exported (node->pkt->pkt.public_key);
                     }
                 }
             }
           else
             {
               log_error ("key %s: error getting keyinfo from agent: %s"
                          " - skipped\n", keystr_with_sub (keyid, subkid),
                              gpg_strerror (err));
               skip_until_subkey = 1;
               err = 0;
             }
 
           xfree (pk->seckey_info);
           pk->seckey_info = NULL;
           {
             int i;
             for (i = pubkey_get_npkey (pk->pubkey_algo);
                  i < pubkey_get_nskey (pk->pubkey_algo); i++)
               {
                 gcry_mpi_release (pk->pkey[i]);
                 pk->pkey[i] = NULL;
               }
           }
         }
       else /* Not secret or common packets.  */
         {
           if ((options & EXPORT_BACKUP))
             err = build_packet_and_meta (out, node->pkt);
           else
             err = build_packet (out, node->pkt);
           if (!err && node->pkt->pkttype == PKT_PUBLIC_KEY)
             {
               stats->exported++;
               print_status_exported (node->pkt->pkt.public_key);
             }
         }
 
       if (err)
         {
           log_error ("build_packet(%d) failed: %s\n",
                      node->pkt->pkttype, gpg_strerror (err));
           goto leave;
         }
 
       if (!skip_until_subkey)
         *any = 1;
     }
 
  leave:
   release_subkey_list (subkey_list);
   xfree (serialno);
   xfree (hexgrip);
   xfree (cache_nonce);
   return err;
 }
 
 
+/* For secret key export we need to setup a decryption context.
+ * Returns 0 and the context at r_cipherhd.  */
+static gpg_error_t
+get_keywrap_key (ctrl_t ctrl, gcry_cipher_hd_t *r_cipherhd)
+{
+#ifdef ENABLE_SELINUX_HACKS
+  (void)ctrl;
+  *r_cipherhd = NULL;
+  log_error (_("exporting secret keys not allowed\n"));
+  return gpg_error (GPG_ERR_NOT_SUPPORTED);
+#else
+  gpg_error_t err;
+  void *kek = NULL;
+  size_t keklen;
+  gcry_cipher_hd_t cipherhd;
+
+  *r_cipherhd = NULL;
+
+  err = agent_keywrap_key (ctrl, 1, &kek, &keklen);
+  if (err)
+    {
+      log_error ("error getting the KEK: %s\n", gpg_strerror (err));
+      return err;
+    }
+
+  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));
+
+  if (!err)
+    *r_cipherhd = cipherhd;
+  else
+    gcry_cipher_close (cipherhd);
+  xfree (kek);
+  return err;
+#endif
+}
+
+
 /* Export the keys identified by the list of strings in USERS to the
    stream OUT.  If SECRET is false public keys will be exported.  With
    secret true secret keys will be exported; in this case 1 means the
    entire secret keyblock and 2 only the subkeys.  OPTIONS are the
    export options to apply.  If KEYBLOCK_OUT is not NULL, AND the exit
    code is zero, a pointer to the first keyblock found and exported
    will be stored at this address; no other keyblocks are exported in
    this case.  The caller must free the returned keyblock.  If any
    key has been exported true is stored at ANY. */
 static int
 do_export_stream (ctrl_t ctrl, iobuf_t out, strlist_t users, int secret,
 		  kbnode_t *keyblock_out, unsigned int options,
                   export_stats_t stats, int *any)
 {
   gpg_error_t err = 0;
   PACKET pkt;
   kbnode_t keyblock = NULL;
   kbnode_t node;
   size_t ndesc, descindex;
   KEYDB_SEARCH_DESC *desc = NULL;
   KEYDB_HANDLE kdbhd;
   strlist_t sl;
   gcry_cipher_hd_t cipherhd = NULL;
   struct export_stats_s dummystats;
   iobuf_t out_help = NULL;
 
   if (!stats)
     stats = &dummystats;
   *any = 0;
   init_packet (&pkt);
   kdbhd = keydb_new (ctrl);
   if (!kdbhd)
     return gpg_error_from_syserror ();
 
   /* For the DANE format open a helper iobuf and
    * enforce some options.  */
   if ((options & EXPORT_DANE_FORMAT))
     {
       out_help = iobuf_temp ();
       options |= EXPORT_MINIMAL | EXPORT_CLEAN;
     }
 
   if (!users)
     {
       ndesc = 1;
       desc = xcalloc (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)
         {
           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));
         }
 
       keydb_disable_caching (kdbhd);  /* We are looping the search.  */
 
       /* It would be nice to see which of the given users did actually
          match one in the keyring.  To implement this we need to have
          a found flag for each entry in desc.  To set this flag we
          must check all those entries after a match to mark all
          matched one - currently we stop at the first match.  To do
          this we need an extra flag to enable this feature.  */
     }
 
-#ifdef ENABLE_SELINUX_HACKS
-  if (secret)
-    {
-      log_error (_("exporting secret keys not allowed\n"));
-      err = gpg_error (GPG_ERR_NOT_SUPPORTED);
-      goto leave;
-    }
-#endif
-
   /* For secret key export we need to setup a decryption context.  */
-  if (secret)
-    {
-      void *kek = NULL;
-      size_t keklen;
-
-      err = agent_keywrap_key (ctrl, 1, &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)
-        {
-          log_error ("error setting up an encryption context: %s\n",
-                     gpg_strerror (err));
-          goto leave;
-        }
-      xfree (kek);
-      kek = NULL;
-    }
+  if (secret && (err = get_keywrap_key (ctrl, &cipherhd)))
+    goto leave;
 
   for (;;)
     {
       u32 keyid[2];
       PKT_public_key *pk;
 
       err = keydb_search (kdbhd, desc, ndesc, &descindex);
       if (!users)
         desc[0].mode = KEYDB_SEARCH_MODE_NEXT;
       if (err)
         break;
 
       /* Read the keyblock. */
       release_kbnode (keyblock);
       keyblock = NULL;
       err = keydb_get_keyblock (kdbhd, &keyblock);
       if (err)
         {
           log_error (_("error reading keyblock: %s\n"), gpg_strerror (err));
           goto leave;
 	}
 
       node = find_kbnode (keyblock, PKT_PUBLIC_KEY);
       if (!node)
         {
           log_error ("public key packet not found in keyblock - skipped\n");
           continue;
         }
       stats->count++;
       setup_main_keyids (keyblock);  /* gpg_format_keydesc needs it.  */
       pk = node->pkt->pkt.public_key;
       keyid_from_pk (pk, keyid);
 
       /* If a secret key export is required we need to check whether
          we have a secret key at all and if so create the seckey_info
          structure.  */
       if (secret)
         {
           if (agent_probe_any_secret_key (ctrl, keyblock))
             continue;  /* No secret key (neither primary nor subkey).  */
 
           /* No v3 keys with GNU mode 1001. */
           if (secret == 2 && pk->version == 3)
             {
               log_info (_("key %s: PGP 2.x style key - skipped\n"),
                         keystr (keyid));
               continue;
             }
 
           /* The agent does not yet allow export of v3 packets.  It is
              actually questionable whether we should allow them at
              all.  */
           if (pk->version == 3)
             {
               log_info ("key %s: PGP 2.x style key (v3) export "
                         "not yet supported - skipped\n", keystr (keyid));
               continue;
             }
           stats->secret_count++;
         }
 
       /* Always do the cleaning on the public key part if requested.
        * A designated revocation is never stripped, even with
        * export-minimal set.  */
       if ((options & EXPORT_CLEAN))
         {
           merge_keys_and_selfsig (ctrl, keyblock);
           clean_all_uids (ctrl, keyblock, opt.verbose,
                           (options&EXPORT_MINIMAL), NULL, NULL);
           clean_all_subkeys (ctrl, keyblock, opt.verbose,
                              (options&EXPORT_MINIMAL)? KEY_CLEAN_ALL
                              /**/                    : KEY_CLEAN_AUTHENCR,
                              NULL, NULL);
           commit_kbnode (&keyblock);
         }
 
       if (export_keep_uid)
         {
           commit_kbnode (&keyblock);
           apply_keep_uid_filter (ctrl, keyblock, export_keep_uid);
           commit_kbnode (&keyblock);
         }
 
       if (export_drop_subkey)
         {
           commit_kbnode (&keyblock);
           apply_drop_subkey_filter (ctrl, keyblock, export_drop_subkey);
           commit_kbnode (&keyblock);
         }
 
       /* And write it. */
       err = do_export_one_keyblock (ctrl, keyblock, keyid,
                                     out_help? out_help : out,
                                     secret, options, stats, any,
                                     desc, ndesc, descindex, cipherhd);
       if (err)
         break;
 
       if (keyblock_out)
         {
           *keyblock_out = keyblock;
           break;
         }
 
       if (out_help && (options & EXPORT_DANE_FORMAT))
         {
           /* We want to write DANE records.  OUT_HELP has the
            * keyblock and we print a record for each uid to OUT. */
           const void *data;
           size_t datalen;
 
           iobuf_flush_temp (out_help);
           data = iobuf_get_temp_buffer (out_help);
           datalen = iobuf_get_temp_length (out_help);
 
           err = print_dane_records (out, keyblock, pk, data, datalen);
           if (err)
             goto leave;
 
           iobuf_close (out_help);
           out_help = iobuf_temp ();
         }
 
     }
   if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
     err = 0;
 
  leave:
   iobuf_cancel (out_help);
   gcry_cipher_close (cipherhd);
   xfree(desc);
   keydb_release (kdbhd);
   if (err || !keyblock_out)
     release_kbnode( keyblock );
   if( !*any )
     log_info(_("WARNING: nothing exported\n"));
   return err;
 }
 
 
+
+/* Write the uint32 VALUE to MB in networ byte order.  */
+static void
+mb_write_uint32 (membuf_t *mb, u32 value)
+{
+  unsigned char buffer[4];
+
+  ulongtobuf (buffer, (ulong)value);
+  put_membuf (mb, buffer, 4);
+}
+
+/* Write the byte C to MB.  */
+static void
+mb_write_uint8 (membuf_t *mb, int c)
+{
+  unsigned char buf[1];
+
+  buf[0] = c;
+  put_membuf (mb, buf, 1);
+}
+
+
+/* Simple wrapper around put_membuf.  */
+static void
+mb_write_data (membuf_t *mb, const void *data, size_t datalen)
+{
+  put_membuf (mb, data, datalen);
+}
+
+/* Write STRING with terminating Nul to MB.  */
+static void
+mb_write_cstring (membuf_t *mb, const char *string)
+{
+  put_membuf (mb, string, strlen (string)+1);
+}
+
+/* Write an SSH style string to MB.  */
+static void
+mb_write_string (membuf_t *mb, const void *string, size_t n)
+{
+  mb_write_uint32 (mb, (u32)n);
+  mb_write_data (mb, string, n);
+}
+
+/* Write an MPI as SSH style string to MB   */
+static void
+mb_write_mpi (membuf_t *mb, gcry_mpi_t mpi, int strip_prefix)
+{
+  unsigned int nbits;
+  const unsigned char *p;
+  size_t n;
+
+  if (gcry_mpi_get_flag (mpi, GCRYMPI_FLAG_OPAQUE))
+    {
+      p = gcry_mpi_get_opaque (mpi, &nbits);
+      n = (nbits + 7) / 8;
+
+      if (strip_prefix && n > 1 && p[0] == 0x40)
+        {
+          /* We need to strip our 0x40 prefix.  */
+          p++;
+          n--;
+        }
+      mb_write_string (mb, p, n);
+    }
+  else
+    {
+      gpg_error_t err;
+      unsigned char *buf;
+
+      err = gcry_mpi_aprint (GCRYMPI_FMT_SSH, &buf, &n, mpi);
+      if (err)
+        set_membuf_err (mb, err);
+      else
+        {
+          mb_write_data (mb, buf, n);
+          gcry_free (buf);
+        }
+    }
+}
+
 
 
 static gpg_error_t
 key_to_sshblob (membuf_t *mb, const char *identifier, ...)
 {
   va_list arg_ptr;
   gpg_error_t err = 0;
   unsigned char nbuf[4];
   unsigned char *buf;
   size_t buflen;
   gcry_mpi_t a;
 
   buflen = strlen (identifier);
   ulongtobuf (nbuf, (ulong)buflen);
   put_membuf (mb, nbuf, 4);
   put_membuf (mb, identifier, buflen);
   if (buflen > 11 && !memcmp (identifier, "ecdsa-sha2-", 11))
     {
+      /* Store the name of the curve taken from the identifier.  */
       ulongtobuf (nbuf, (ulong)(buflen - 11));
       put_membuf (mb, nbuf, 4);
       put_membuf (mb, identifier+11, buflen - 11);
     }
   va_start (arg_ptr, identifier);
   while ((a = va_arg (arg_ptr, gcry_mpi_t)))
     {
       if (gcry_mpi_get_flag (a, GCRYMPI_FLAG_OPAQUE))
         {
           unsigned int nbits;
           const unsigned char *p;
 
           p = gcry_mpi_get_opaque (a, &nbits);
           buflen = (nbits + 7) / 8;
 
           if (!strcmp (identifier, "ssh-ed25519")
               && buflen > 1 && p[0] == 0x40)
             {
               /* We need to strip our 0x40 prefix.  */
               put_membuf (mb, "\x00\x00\x00\x20", 4);
               put_membuf (mb, p+1, buflen-1);
             }
           else
             {
               unsigned char c;
 
               c = buflen >> 24;
               put_membuf (mb, &c, 1);
               c = buflen >> 16;
               put_membuf (mb, &c, 1);
               c = buflen >> 8;
               put_membuf (mb, &c, 1);
               c = buflen;
               put_membuf (mb, &c, 1);
               put_membuf (mb, p, buflen);
             }
         }
       else
         {
           err = gcry_mpi_aprint (GCRYMPI_FMT_SSH, &buf, &buflen, a);
           if (err)
             break;
           put_membuf (mb, buf, buflen);
           gcry_free (buf);
         }
     }
   va_end (arg_ptr);
   return err;
 }
 
 
 static gpg_error_t
 export_one_ssh_key (estream_t fp, PKT_public_key *pk)
 {
   gpg_error_t err;
   const char *identifier = NULL;
   membuf_t mb;
   void *blob;
   size_t bloblen;
 
   init_membuf (&mb, 4096);
 
   switch (pk->pubkey_algo)
     {
     case PUBKEY_ALGO_DSA:
       identifier = "ssh-dss";
       err = key_to_sshblob (&mb, identifier,
                             pk->pkey[0], pk->pkey[1], pk->pkey[2], pk->pkey[3],
                             NULL);
       break;
 
     case PUBKEY_ALGO_RSA:
     case PUBKEY_ALGO_RSA_S:
       identifier = "ssh-rsa";
       err = key_to_sshblob (&mb, identifier, pk->pkey[1], pk->pkey[0], NULL);
       break;
 
     case PUBKEY_ALGO_ECDSA:
       {
         char *curveoid;
         const char *curve;
 
         curveoid = openpgp_oid_to_str (pk->pkey[0]);
         if (!curveoid)
           err = gpg_error_from_syserror ();
         else if (!(curve = openpgp_oid_to_curve (curveoid, 0)))
           err = gpg_error (GPG_ERR_UNKNOWN_CURVE);
         else
           {
             if (!strcmp (curve, "nistp256"))
               identifier = "ecdsa-sha2-nistp256";
             else if (!strcmp (curve, "nistp384"))
               identifier = "ecdsa-sha2-nistp384";
             else if (!strcmp (curve, "nistp521"))
               identifier = "ecdsa-sha2-nistp521";
 
             if (!identifier)
               err = gpg_error (GPG_ERR_UNKNOWN_CURVE);
             else
               err = key_to_sshblob (&mb, identifier, pk->pkey[1], NULL);
           }
         xfree (curveoid);
       }
       break;
 
     case PUBKEY_ALGO_EDDSA:
       if (openpgp_oid_is_ed25519 (pk->pkey[0]))
         {
           identifier = "ssh-ed25519";
           err = key_to_sshblob (&mb, identifier, pk->pkey[1], NULL);
         }
       else if (openpgp_oid_is_ed448 (pk->pkey[0]))
         {
           identifier = "ssh-ed448";
           err = key_to_sshblob (&mb, identifier, pk->pkey[1], NULL);
         }
       else
         err = gpg_error (GPG_ERR_UNKNOWN_CURVE);
       break;
 
     case PUBKEY_ALGO_ELGAMAL_E:
     case PUBKEY_ALGO_ELGAMAL:
       err = gpg_error (GPG_ERR_UNUSABLE_PUBKEY);
       break;
 
     default:
       err = GPG_ERR_PUBKEY_ALGO;
       break;
     }
 
   if (err)
     goto leave;
 
   blob = get_membuf (&mb, &bloblen);
   if (blob)
     {
       struct b64state b64_state;
 
       es_fprintf (fp, "%s ", identifier);
       err = b64enc_start_es (&b64_state, fp, "");
       if (err)
         {
           xfree (blob);
           goto leave;
         }
 
       err = b64enc_write (&b64_state, blob, bloblen);
       b64enc_finish (&b64_state);
 
       es_fprintf (fp, " openpgp:0x%08lX\n", (ulong)keyid_from_pk (pk, NULL));
       xfree (blob);
     }
 
  leave:
   xfree (get_membuf (&mb, NULL));
   return err;
 }
 
 /* Export the key identified by USERID in the SSH public key format.
    The function exports the latest subkey with Authentication
    capability unless the '!' suffix is used to export a specific
    key.  */
 gpg_error_t
 export_ssh_key (ctrl_t ctrl, const char *userid)
 {
   gpg_error_t err;
   kbnode_t keyblock = NULL;
   KEYDB_SEARCH_DESC desc;
   u32 latest_date;
   u32 curtime = make_timestamp ();
   kbnode_t latest_key, node;
   PKT_public_key *pk;
   estream_t fp = NULL;
   const char *fname = "-";
 
   /* We need to know whether the key has been specified using the
      exact syntax ('!' suffix).  Thus we need to run a
      classify_user_id on our own.  */
   err = classify_user_id (userid, &desc, 1);
 
   /* Get the public key.  */
   if (!err)
     {
       getkey_ctx_t getkeyctx;
 
       err = get_pubkey_byname (ctrl, GET_PUBKEY_NO_AKL,
                                &getkeyctx, NULL, userid, &keyblock,
                                NULL,
                                0  /* Only usable keys or given exact. */);
       if (!err)
         {
           err = getkey_next (ctrl, getkeyctx, NULL, NULL);
           if (!err)
             err = gpg_error (GPG_ERR_AMBIGUOUS_NAME);
           else if (gpg_err_code (err) == GPG_ERR_NO_PUBKEY)
             err = 0;
         }
       getkey_end (ctrl, getkeyctx);
     }
   if (err)
     {
       log_error (_("key \"%s\" not found: %s\n"), userid, gpg_strerror (err));
       return err;
     }
 
   /* The finish_lookup code in getkey.c does not handle auth keys,
      thus we have to duplicate the code here to find the latest
      subkey.  However, if the key has been found using an exact match
      ('!' notation) we use that key without any further checks and
      even allow the use of the primary key. */
   latest_date = 0;
   latest_key = NULL;
   for (node = keyblock; node; node = node->next)
     {
       if ((node->pkt->pkttype == PKT_PUBLIC_SUBKEY
            || node->pkt->pkttype == PKT_PUBLIC_KEY)
           && node->pkt->pkt.public_key->flags.exact)
         {
           latest_key = node;
           break;
         }
     }
   if (!latest_key)
     {
       for (node = keyblock; node; node = node->next)
         {
           if (node->pkt->pkttype != PKT_PUBLIC_SUBKEY)
             continue;
 
           pk = node->pkt->pkt.public_key;
           if (DBG_LOOKUP)
             log_debug ("\tchecking subkey %08lX\n",
                        (ulong) keyid_from_pk (pk, NULL));
           if (!(pk->pubkey_usage & PUBKEY_USAGE_AUTH))
             {
               if (DBG_LOOKUP)
                 log_debug ("\tsubkey not usable for authentication\n");
               continue;
             }
           if (!pk->flags.valid)
             {
               if (DBG_LOOKUP)
                 log_debug ("\tsubkey not valid\n");
               continue;
             }
           if (pk->flags.revoked)
             {
               if (DBG_LOOKUP)
                 log_debug ("\tsubkey has been revoked\n");
               continue;
             }
           if (pk->has_expired)
             {
               if (DBG_LOOKUP)
                 log_debug ("\tsubkey has expired\n");
               continue;
             }
           if (pk->timestamp > curtime && !opt.ignore_valid_from)
             {
               if (DBG_LOOKUP)
                 log_debug ("\tsubkey not yet valid\n");
               continue;
             }
           if (DBG_LOOKUP)
             log_debug ("\tsubkey might be fine\n");
           /* In case a key has a timestamp of 0 set, we make sure that it
              is used.  A better change would be to compare ">=" but that
              might also change the selected keys and is as such a more
              intrusive change.  */
           if (pk->timestamp > latest_date || (!pk->timestamp && !latest_date))
             {
               latest_date = pk->timestamp;
               latest_key = node;
             }
         }
 
       /* If no subkey was suitable check the primary key.  */
       if (!latest_key
           && (node = keyblock) && node->pkt->pkttype == PKT_PUBLIC_KEY)
         {
           pk = node->pkt->pkt.public_key;
           if (DBG_LOOKUP)
             log_debug ("\tchecking primary key %08lX\n",
                        (ulong) keyid_from_pk (pk, NULL));
           if (!(pk->pubkey_usage & PUBKEY_USAGE_AUTH))
             {
               if (DBG_LOOKUP)
                 log_debug ("\tprimary key not usable for authentication\n");
             }
           else if (!pk->flags.valid)
             {
               if (DBG_LOOKUP)
                 log_debug ("\tprimary key not valid\n");
             }
           else if (pk->flags.revoked)
             {
               if (DBG_LOOKUP)
                 log_debug ("\tprimary key has been revoked\n");
             }
           else if (pk->has_expired)
             {
               if (DBG_LOOKUP)
                 log_debug ("\tprimary key has expired\n");
             }
           else if (pk->timestamp > curtime && !opt.ignore_valid_from)
             {
               if (DBG_LOOKUP)
                 log_debug ("\tprimary key not yet valid\n");
             }
           else
             {
               if (DBG_LOOKUP)
                 log_debug ("\tprimary key is fine\n");
               latest_date = pk->timestamp;
               latest_key = node;
             }
         }
     }
 
   if (!latest_key)
     {
       err = gpg_error (GPG_ERR_UNUSABLE_PUBKEY);
       log_error (_("key \"%s\" not found: %s\n"), userid, gpg_strerror (err));
       goto leave;
     }
 
   pk = latest_key->pkt->pkt.public_key;
   if (DBG_LOOKUP)
     log_debug ("\tusing key %08lX\n", (ulong) keyid_from_pk (pk, NULL));
 
   if (opt.outfile && *opt.outfile && strcmp (opt.outfile, "-"))
     fp = es_fopen ((fname = opt.outfile), "w");
   else
     fp = es_stdout;
   if (!fp)
     {
       err = gpg_error_from_syserror ();
       log_error (_("error creating '%s': %s\n"), fname, gpg_strerror (err));
       goto leave;
     }
 
   err = export_one_ssh_key (fp, pk);
   if (err)
     goto leave;
 
   if (es_ferror (fp))
     err = gpg_error_from_syserror ();
   else
     {
       if (fp != es_stdout && es_fclose (fp))
         err = gpg_error_from_syserror ();
       fp = NULL;
     }
 
   if (err)
     log_error (_("error writing '%s': %s\n"), fname, gpg_strerror (err));
 
  leave:
   if (fp != es_stdout)
     es_fclose (fp);
   release_kbnode (keyblock);
   return err;
 }
+
+
+/* Simplified version of receive_seckey_from_agent used to get the raw
+ * key.  */
+gpg_error_t
+receive_raw_seckey_from_agent (ctrl_t ctrl, gcry_cipher_hd_t cipherhd,
+                               const char *hexgrip, gcry_sexp_t *r_key)
+{
+  gpg_error_t err = 0;
+  unsigned char *wrappedkey = NULL;
+  size_t wrappedkeylen;
+  unsigned char *key = NULL;
+  size_t keylen, realkeylen;
+  gcry_sexp_t s_skey = NULL;
+
+  *r_key = NULL;
+  if (opt.verbose)
+    log_info ("key %s: asking agent for the secret parts\n", hexgrip);
+
+  {
+    char * prompt = gpg_format_keydesc (ctrl, NULL, FORMAT_KEYDESC_KEYGRIP, 1);
+    err = agent_export_key (ctrl, hexgrip, prompt, 0, NULL,
+                            &wrappedkey, &wrappedkeylen,
+                            NULL, NULL, 0);
+    xfree (prompt);
+  }
+  if (err)
+    goto leave;
+
+  if (wrappedkeylen < 24)
+    {
+      err = gpg_error (GPG_ERR_INV_LENGTH);
+      goto leave;
+    }
+  keylen = wrappedkeylen - 8;
+  key = xtrymalloc_secure (keylen);
+  if (!key)
+    {
+      err = gpg_error_from_syserror ();
+      goto leave;
+    }
+  err = gcry_cipher_decrypt (cipherhd, key, keylen, wrappedkey, wrappedkeylen);
+  if (err)
+    goto leave;
+  realkeylen = gcry_sexp_canon_len (key, keylen, NULL, &err);
+  if (!realkeylen)
+    goto leave; /* Invalid csexp.  */
+
+  err = gcry_sexp_sscan (&s_skey, NULL, key, realkeylen);
+  if (!err)
+    {
+      gcry_log_debugsxp ("skey", s_skey);
+      *r_key = s_skey;
+      s_skey = NULL;
+    }
+
+ leave:
+  gcry_sexp_release (s_skey);
+  xfree (key);
+  xfree (wrappedkey);
+  if (err)
+    {
+      log_error ("key %s: error receiving key from agent:"
+                 " %s%s\n", hexgrip, gpg_strerror (err),
+                 "");
+    }
+  return err;
+}
+
+
+/* Export the key identified by USERID in the SSH secret key format.
+ * The USERID must be given in keygrip format (prefixed with a '&')
+ * and thus no OpenPGP key is required.  The exported key is not
+ * protected.  */
+gpg_error_t
+export_secret_ssh_key (ctrl_t ctrl, const char *userid)
+{
+  gpg_error_t err;
+  KEYDB_SEARCH_DESC desc;
+  estream_t fp = NULL;
+  const char *fname = "-";
+  gcry_cipher_hd_t cipherhd = NULL;
+  char hexgrip[KEYGRIP_LEN * 2 + 1];
+  gcry_sexp_t skey = NULL;
+  gcry_sexp_t skeyalgo = NULL;
+  const char *identifier = NULL;
+  membuf_t mb;
+  membuf_t mb2;
+  void *blob = NULL;
+  size_t bloblen;
+  const char *s;
+  size_t n;
+  char *p;
+  int pkalgo;
+  int i;
+  gcry_mpi_t keyparam[10] = { NULL };
+  struct b64state b64_state;
+
+  init_membuf_secure (&mb, 1024);
+  init_membuf_secure (&mb2, 1024);
+
+  /* Check that a keygrip has been given.  */
+  err = classify_user_id (userid, &desc, 1);
+  if (err || desc.mode != KEYDB_SEARCH_MODE_KEYGRIP )
+    {
+      log_error (_("key \"%s\" not found: %s\n"), userid,
+                 err? gpg_strerror (err) : "Not a Keygrip" );
+      return err;
+    }
+
+  bin2hex (desc.u.grip, KEYGRIP_LEN, hexgrip);
+
+  if ((err = get_keywrap_key (ctrl, &cipherhd)))
+    goto leave;
+
+  err = receive_raw_seckey_from_agent (ctrl, cipherhd, hexgrip, &skey);
+  if (err)
+    goto leave;
+
+  /* Get the type of the key expression.  */
+  s = gcry_sexp_nth_data (skey, 0, &n);
+  if (!s || !(n == 11 && !memcmp (s, "private-key", 11)))
+    {
+      log_info ("Note: only on-disk secret keys may be exported\n");
+      err = gpg_error (GPG_ERR_NO_SECKEY);
+      goto leave;
+    }
+
+  mb_write_cstring (&mb, "openssh-key-v1"); /* Auth_Magic. */
+  mb_write_string (&mb, "none", 4); /* ciphername */
+  mb_write_string (&mb, "none", 4); /* kdfname  */
+  mb_write_uint32 (&mb, 0);         /* kdfoptions  */
+  mb_write_uint32 (&mb, 1);         /* number of keys  */
+
+  pkalgo = get_pk_algo_from_key (skey);
+  switch (pkalgo)
+    {
+    case PUBKEY_ALGO_RSA:
+    case PUBKEY_ALGO_RSA_S:
+      identifier = "ssh-rsa";
+      err = gcry_sexp_extract_param (skey, NULL, "nedpq",
+                                     &keyparam[0],
+                                     &keyparam[1],
+                                     &keyparam[2],
+                                     &keyparam[3],
+                                     &keyparam[4],
+                                     NULL);
+      if (err)
+        goto leave;
+      mb_write_string (&mb2, identifier, strlen (identifier));
+      mb_write_mpi (&mb2, keyparam[1], 0);  /* e (right, e is first here) */
+      mb_write_mpi (&mb2, keyparam[0], 0);  /* n */
+      /* Append public to the output block as an SSH string.  */
+      p = get_membuf (&mb2, &n);
+      if (!p)
+        {
+          err = gpg_error_from_syserror ();
+          goto leave;
+        }
+      mb_write_string (&mb, p, n);
+      xfree (p);
+      init_membuf_secure (&mb2, 1024);
+      mb_write_string (&mb2, identifier, strlen (identifier));
+      {
+        char checkbytes[4];
+        gcry_create_nonce (checkbytes, sizeof checkbytes);
+        mb_write_data (&mb2, checkbytes, sizeof checkbytes);
+        mb_write_data (&mb2, checkbytes, sizeof checkbytes);
+      }
+      mb_write_mpi (&mb2, keyparam[0], 0);  /* n */
+      mb_write_mpi (&mb2, keyparam[1], 0);  /* e */
+      /*FIXME: Fixup u,p,q to match the OpenSSH format.  */
+      mb_write_mpi (&mb2, keyparam[2], 0);  /* d */
+      mb_write_mpi (&mb2, keyparam[1], 0);  /* iqmp1 */
+      mb_write_mpi (&mb2, keyparam[3], 0);  /* p */
+      mb_write_mpi (&mb2, keyparam[4], 0);  /* q */
+      /* Fixme: take the comment from skey.  */
+      mb_write_string (&mb2, "<comment>", 9);
+      /* Pad to a blocksize of 8 (for cipher "none").  */
+      i = 0;
+      while (peek_membuf (&mb2, &n) && (n % 8))
+        mb_write_uint8 (&mb2, ++i);
+      /* Append encrypted block to the output as an SSH string.  */
+      p = get_membuf (&mb2, &n);
+      if (!p)
+        {
+          err = gpg_error_from_syserror ();
+          goto leave;
+        }
+      mb_write_string (&mb, p, n);
+      xfree (p);
+      err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
+      break;
+
+    /* case PUBKEY_ALGO_ECDSA: */
+    /*   { */
+    /*     char *curveoid; */
+    /*     const char *curve; */
+
+    /*     curveoid = openpgp_oid_to_str (pk->pkey[0]); */
+    /*     if (!curveoid) */
+    /*       err = gpg_error_from_syserror (); */
+    /*     else if (!(curve = openpgp_oid_to_curve (curveoid, 0))) */
+    /*       err = gpg_error (GPG_ERR_UNKNOWN_CURVE); */
+    /*     else */
+    /*       { */
+    /*         if (!strcmp (curve, "nistp256")) */
+    /*           identifier = "ecdsa-sha2-nistp256"; */
+    /*         else if (!strcmp (curve, "nistp384")) */
+    /*           identifier = "ecdsa-sha2-nistp384"; */
+    /*         else if (!strcmp (curve, "nistp521")) */
+    /*           identifier = "ecdsa-sha2-nistp521"; */
+
+    /*         if (!identifier) */
+    /*           err = gpg_error (GPG_ERR_UNKNOWN_CURVE); */
+    /*         else */
+    /*           err = key_to_sshblob (&mb, identifier, pk->pkey[1], NULL); */
+    /*       } */
+    /*     xfree (curveoid); */
+    /*   } */
+    /*   break; */
+
+    /* case PUBKEY_ALGO_EDDSA: */
+    /*   if (openpgp_oid_is_ed25519 (pk->pkey[0])) */
+    /*     { */
+    /*       identifier = "ssh-ed25519"; */
+    /*       err = key_to_sshblob (&mb, identifier, pk->pkey[1], NULL); */
+    /*     } */
+    /*   else if (openpgp_oid_is_ed448 (pk->pkey[0])) */
+    /*     { */
+    /*       identifier = "ssh-ed448"; */
+    /*       err = key_to_sshblob (&mb, identifier, pk->pkey[1], NULL); */
+    /*     } */
+    /*   else */
+    /*     err = gpg_error (GPG_ERR_UNKNOWN_CURVE); */
+    /*   break; */
+
+    case PUBKEY_ALGO_DSA:
+      log_info ("Note: export of ssh-dsa keys is not supported\n");
+      err = gpg_error (GPG_ERR_NOT_SUPPORTED);
+      break;
+
+    case PUBKEY_ALGO_ELGAMAL_E:
+    case PUBKEY_ALGO_ELGAMAL:
+      err = gpg_error (GPG_ERR_UNUSABLE_SECKEY);
+      break;
+
+    default:
+      err = GPG_ERR_PUBKEY_ALGO;
+      break;
+    }
+
+  if (err)
+    goto leave;
+
+  blob = get_membuf (&mb, &bloblen);
+  if (!blob)
+    {
+      err = gpg_error_from_syserror ();
+      goto leave;
+    }
+
+  if (opt.outfile && *opt.outfile && strcmp (opt.outfile, "-"))
+    fp = es_fopen ((fname = opt.outfile), "w");
+  else
+    fp = es_stdout;
+  if (!fp)
+    {
+      err = gpg_error_from_syserror ();
+      log_error (_("error creating '%s': %s\n"), fname, gpg_strerror (err));
+      goto leave;
+    }
+
+  err = b64enc_start_es (&b64_state, fp, "OPENSSH PRIVATE_KEY");
+  if (err)
+    goto leave;
+  err = b64enc_write (&b64_state, blob, bloblen);
+  b64enc_finish (&b64_state);
+  if (err)
+    goto leave;
+
+  if (es_ferror (fp))
+    err = gpg_error_from_syserror ();
+  else
+    {
+      if (fp != es_stdout && es_fclose (fp))
+        err = gpg_error_from_syserror ();
+      fp = NULL;
+    }
+
+  log_info ("Beware: the private key is not protected;"
+            " use \"ssh-keygen -p\" to protect it\n");
+  if (err)
+    log_error (_("error writing '%s': %s\n"), fname, gpg_strerror (err));
+
+
+ leave:
+  xfree (blob);
+  gcry_sexp_release (skey);
+  gcry_sexp_release (skeyalgo);
+  gcry_cipher_close (cipherhd);
+  xfree (get_membuf (&mb2, NULL));
+  xfree (get_membuf (&mb, NULL));
+  if (fp != es_stdout)
+    es_fclose (fp);
+  return err;
+}
diff --git a/g10/gpg.c b/g10/gpg.c
index 00dbf5283..8c1aa96d4 100644
--- a/g10/gpg.c
+++ b/g10/gpg.c
@@ -1,5758 +1,5772 @@
 /* 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,
+    aExportSecretSshKey,
     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,
     oMinRSALength,
     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,
     oOverrideComplianceCheck,
     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,
     oForbidGenKey,
 
     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 (aExportSecretSshKey, "export-secret-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", "@"),
   ARGPARSE_p_u (oMinRSALength, "min-rsa-length", "@"),
 #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_s_n (oOverrideComplianceCheck, "override-compliance-check", "@"),
 
 
   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", "@"),
   ARGPARSE_s_n (oForbidGenKey,  "forbid-gen-key", "@"),
   /* 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;
 
 /* Collection of options used only in this module.  */
 static struct {
   unsigned int forbid_gen_key;
 } mopt;
 
 
 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 ();
     }
 }
 
 
 static void
 gen_key_forbidden (void)
 {
   write_status_failure ("gen-key", gpg_error (GPG_ERR_NOT_ENABLED));
   log_error (_("This command is not allowed while in %s mode.\n"),
              "forbid-gen-key");
 }
 
 
 /* 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 aExportSecretSshKey:
 	  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:
 	    obsolete_option (configname, pargs.lineno, "secret-keyring");
             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 oMinRSALength: opt.min_rsa_length = pargs.r.ret_ulong; 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 oOverrideComplianceCheck:
             opt.flags.override_compliance_check = 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 oForbidGenKey:
             mopt.forbid_gen_key = 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);
       }
 
     /* We allow overriding the compliance check only in non-batch mode
      * so that the user has a chance to see the message.  */
     if (opt.flags.override_compliance_check && opt.batch)
       {
         opt.flags.override_compliance_check = 0;
         log_info ("Note: '%s' ignored due to batch mode\n",
                   "--override-compliance-check");
       }
 
     set_debug (debug_level);
     gnupg_set_compliance_extra_info (opt.min_rsa_length);
     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 = 22; /* Default to the suggested max of 4 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 : 22))
       {
         opt.chunk_size = (allow_large_chunks? 62 : 22);
         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--;
                     }
                 }
             }
           if (mopt.forbid_gen_key)
             gen_key_forbidden ();
           else
             quick_generate_keypair (ctrl, username, x_algo, x_usage, x_expire);
           xfree (username);
         }
         break;
 
       case aKeygen: /* generate a key */
         if (mopt.forbid_gen_key)
           gen_key_forbidden ();
 	else 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 (mopt.forbid_gen_key)
           gen_key_forbidden ();
 	else 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--;
                    }
                 }
             }
           if (mopt.forbid_gen_key)
             gen_key_forbidden ();
           else
             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 aExportSecretSshKey:
+        if (argc != 1)
+          wrong_args ("--export-secret-ssh-key <user-id>");
+        rc = export_secret_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);
 	free_strlist (sl);
 	if(rc)
           {
             write_status_failure ("fetch-keys", rc);
             log_error ("key fetch failed: %s\n",gpg_strerror (rc));
             if (gpg_err_code (rc) == GPG_ERR_NO_DATA)
               g10_exit (1); /* In this case return 1 and not 2.  */
           }
 	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,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,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, 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/main.h b/g10/main.h
index 05ec8c26a..e5308744a 100644
--- a/g10/main.h
+++ b/g10/main.h
@@ -1,525 +1,526 @@
 /* main.h
  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
  *               2008, 2009, 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/>.
  */
 #ifndef G10_MAIN_H
 #define G10_MAIN_H
 
 #include "../common/types.h"
 #include "../common/iobuf.h"
 #include "../common/util.h"
 #include "keydb.h"
 #include "keyedit.h"
 
 /* It could be argued that the default cipher should be 3DES rather
    than AES128, and the default compression should be 0
    (i.e. uncompressed) rather than 1 (zip).  However, the real world
    issues of speed and size come into play here. */
 
 #if GPG_USE_AES256
 # define DEFAULT_CIPHER_ALGO     CIPHER_ALGO_AES256
 #elif GPG_USE_AES128
 # define DEFAULT_CIPHER_ALGO     CIPHER_ALGO_AES
 #elif GPG_USE_CAST5
 # define DEFAULT_CIPHER_ALGO     CIPHER_ALGO_CAST5
 #else
 # define DEFAULT_CIPHER_ALGO     CIPHER_ALGO_3DES
 #endif
 
 #define DEFAULT_AEAD_ALGO  AEAD_ALGO_OCB
 
 #define DEFAULT_DIGEST_ALGO     ((GNUPG)? DIGEST_ALGO_SHA256:DIGEST_ALGO_SHA1)
 #define DEFAULT_S2K_DIGEST_ALGO DIGEST_ALGO_SHA1
 #ifdef HAVE_ZIP
 # define DEFAULT_COMPRESS_ALGO   COMPRESS_ALGO_ZIP
 #else
 # define DEFAULT_COMPRESS_ALGO   COMPRESS_ALGO_NONE
 #endif
 
 
 #define S2K_DIGEST_ALGO (opt.s2k_digest_algo?opt.s2k_digest_algo:DEFAULT_S2K_DIGEST_ALGO)
 
 
 /* Various data objects.  */
 
 typedef struct
 {
   ctrl_t ctrl;
   int header_okay;
   PK_LIST pk_list;
   DEK *symkey_dek;
   STRING2KEY *symkey_s2k;
   cipher_filter_context_t cfx;
 } encrypt_filter_context_t;
 
 
 struct groupitem
 {
   char *name;
   strlist_t values;
   struct groupitem *next;
 };
 
 struct weakhash
 {
   enum gcry_md_algos algo;
   int rejection_shown;
   struct weakhash *next;
 };
 
 
 /*-- gpg.c --*/
 extern int g10_errors_seen;
 
 #if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 5 )
   void g10_exit(int rc) __attribute__ ((noreturn));
 #else
   void g10_exit(int rc);
 #endif
 void print_pubkey_algo_note (pubkey_algo_t algo);
 void print_cipher_algo_note (cipher_algo_t algo);
 void print_digest_algo_note (digest_algo_t algo);
 void print_digest_rejected_note (enum gcry_md_algos algo);
 void print_sha1_keysig_rejected_note (void);
 void print_reported_error (gpg_error_t err, gpg_err_code_t skip_if_ec);
 void print_further_info (const char *format, ...) GPGRT_ATTR_PRINTF(1,2);
 void additional_weak_digest (const char* digestname);
 int  is_weak_digest (digest_algo_t algo);
 
 /*-- armor.c --*/
 char *make_radix64_string( const byte *data, size_t len );
 
 /*-- misc.c --*/
 void trap_unaligned(void);
 void register_secured_file (const char *fname);
 void unregister_secured_file (const char *fname);
 int  is_secured_file (int fd);
 int  is_secured_filename (const char *fname);
 u16 checksum_u16( unsigned n );
 u16 checksum( const byte *p, unsigned n );
 u16 checksum_mpi( gcry_mpi_t a );
 u32 buffer_to_u32( const byte *buffer );
 const byte *get_session_marker( size_t *rlen );
 
 enum gcry_cipher_algos map_cipher_openpgp_to_gcry (cipher_algo_t algo);
 #define openpgp_cipher_open(_a,_b,_c,_d) \
   gcry_cipher_open((_a),map_cipher_openpgp_to_gcry((_b)),(_c),(_d))
 #define openpgp_cipher_get_algo_keylen(_a) \
   gcry_cipher_get_algo_keylen(map_cipher_openpgp_to_gcry((_a)))
 #define openpgp_cipher_get_algo_blklen(_a) \
   gcry_cipher_get_algo_blklen(map_cipher_openpgp_to_gcry((_a)))
 int openpgp_cipher_blocklen (cipher_algo_t algo);
 int openpgp_cipher_test_algo(cipher_algo_t algo);
 const char *openpgp_cipher_algo_name (cipher_algo_t algo);
 
 gpg_error_t openpgp_aead_test_algo (aead_algo_t algo);
 const char *openpgp_aead_algo_name (aead_algo_t algo);
 gpg_error_t openpgp_aead_algo_info (aead_algo_t algo,
                                     enum gcry_cipher_modes *r_mode,
                                     unsigned int *r_noncelen);
 
 int openpgp_pk_test_algo (pubkey_algo_t algo);
 int openpgp_pk_test_algo2 (pubkey_algo_t algo, unsigned int use);
 int openpgp_pk_algo_usage ( int algo );
 const char *openpgp_pk_algo_name (pubkey_algo_t algo);
 
 enum gcry_md_algos map_md_openpgp_to_gcry (digest_algo_t algo);
 int openpgp_md_test_algo (digest_algo_t algo);
 const char *openpgp_md_algo_name (int algo);
 
 struct expando_args
 {
   PKT_public_key *pk;
   PKT_public_key *pksk;
   byte imagetype;
   int validity_info;
   const char *validity_string;
   const byte *namehash;
 };
 
 char *pct_expando (ctrl_t ctrl, const char *string,struct expando_args *args);
 void deprecated_warning(const char *configname,unsigned int configlineno,
 			const char *option,const char *repl1,const char *repl2);
 void deprecated_command (const char *name);
 void obsolete_scdaemon_option (const char *configname,
                                unsigned int configlineno, const char *name);
 
 int string_to_cipher_algo (const char *string);
 aead_algo_t string_to_aead_algo (const char *string);
 int string_to_digest_algo (const char *string);
 
 const char *compress_algo_to_string(int algo);
 int string_to_compress_algo(const char *string);
 int check_compress_algo(int algo);
 int default_cipher_algo(void);
 aead_algo_t default_aead_algo(void);
 int default_compress_algo(void);
 void compliance_failure(void);
 
 struct parse_options
 {
   char *name;
   unsigned int bit;
   char **value;
   char *help;
 };
 
 char *optsep(char **stringp);
 char *argsplit(char *string);
 int parse_options(char *str,unsigned int *options,
 		  struct parse_options *opts,int noisy);
 const char *get_libexecdir (void);
 int path_access(const char *file,int mode);
 
 int pubkey_get_npkey (pubkey_algo_t algo);
 int pubkey_get_nskey (pubkey_algo_t algo);
 int pubkey_get_nsig (pubkey_algo_t algo);
 int pubkey_get_nenc (pubkey_algo_t algo);
 
 /* Temporary helpers. */
 unsigned int pubkey_nbits( int algo, gcry_mpi_t *pkey );
 int mpi_print (estream_t stream, gcry_mpi_t a, int mode);
 unsigned int ecdsa_qbits_from_Q (unsigned int qbits);
 
 
 /*-- cpr.c --*/
 void set_status_fd ( int fd );
 int  is_status_enabled ( void );
 void write_status ( int no );
 void write_status_error (const char *where, gpg_error_t err);
 void write_status_errcode (const char *where, int errcode);
 void write_status_failure (const char *where, gpg_error_t err);
 void write_status_text ( int no, const char *text );
 void write_status_printf (int no, const char *format,
                           ...) GPGRT_ATTR_PRINTF(2,3);
 void write_status_strings (int no, const char *text,
                            ...) GPGRT_ATTR_SENTINEL(0);
 gpg_error_t write_status_strings2 (ctrl_t dummy, int no,
                                    ...) GPGRT_ATTR_SENTINEL(0);
 void write_status_buffer ( int no,
                            const char *buffer, size_t len, int wrap );
 void write_status_text_and_buffer ( int no, const char *text,
                                     const char *buffer, size_t len, int wrap );
 
 void write_status_begin_signing (gcry_md_hd_t md);
 
 
 int cpr_enabled(void);
 char *cpr_get( const char *keyword, const char *prompt );
 char *cpr_get_no_help( const char *keyword, const char *prompt );
 char *cpr_get_utf8( const char *keyword, const char *prompt );
 char *cpr_get_hidden( const char *keyword, const char *prompt );
 void cpr_kill_prompt(void);
 int  cpr_get_answer_is_yes_def (const char *keyword, const char *prompt,
                                 int def_yes);
 int  cpr_get_answer_is_yes( const char *keyword, const char *prompt );
 int  cpr_get_answer_yes_no_quit( const char *keyword, const char *prompt );
 int  cpr_get_answer_okay_cancel (const char *keyword,
                                  const char *prompt,
                                  int def_answer);
 
 /*-- helptext.c --*/
 void display_online_help( const char *keyword );
 
 /*-- encode.c --*/
 gpg_error_t setup_symkey (STRING2KEY **symkey_s2k,DEK **symkey_dek);
 gpg_error_t encrypt_seskey (DEK *dek, aead_algo_t aead_algo, DEK **r_seskey,
                             void **r_enckey, size_t *r_enckeylen);
 aead_algo_t use_aead (pk_list_t pk_list, int algo);
 int use_mdc (pk_list_t pk_list,int algo);
 int encrypt_symmetric (const char *filename );
 int encrypt_store (const char *filename );
 int encrypt_crypt (ctrl_t ctrl, int filefd, const char *filename,
                    strlist_t remusr, int use_symkey, pk_list_t provided_keys,
                    int outputfd);
 void encrypt_crypt_files (ctrl_t ctrl,
                           int nfiles, char **files, strlist_t remusr);
 int encrypt_filter (void *opaque, int control,
 		    iobuf_t a, byte *buf, size_t *ret_len);
 
 int write_pubkey_enc (ctrl_t ctrl, PKT_public_key *pk, int throw_keyid,
                       DEK *dek, iobuf_t out);
 
 /*-- sign.c --*/
 int sign_file (ctrl_t ctrl, strlist_t filenames, int detached, strlist_t locusr,
 	       int do_encrypt, strlist_t remusr, const char *outfile );
 int clearsign_file (ctrl_t ctrl,
                     const char *fname, strlist_t locusr, const char *outfile);
 int sign_symencrypt_file (ctrl_t ctrl, const char *fname, strlist_t locusr);
 
 /*-- sig-check.c --*/
 void sig_check_dump_stats (void);
 
 /* SIG is a revocation signature.  Check if any of PK's designated
    revokers generated it.  If so, return 0.  Note: this function
    (correctly) doesn't care if the designated revoker is revoked.  */
 int check_revocation_keys (ctrl_t ctrl, PKT_public_key *pk, PKT_signature *sig);
 /* Check that the backsig BACKSIG from the subkey SUB_PK to its
    primary key MAIN_PK is valid.  */
 int check_backsig(PKT_public_key *main_pk,PKT_public_key *sub_pk,
 		  PKT_signature *backsig);
 /* Check that the signature SIG over a key (e.g., a key binding or a
    key revocation) is valid.  (To check signatures over data, use
    check_signature.)  */
 int check_key_signature (ctrl_t ctrl, kbnode_t root, kbnode_t sig,
                          int *is_selfsig );
 /* Like check_key_signature, but with the ability to specify some
    additional parameters and get back additional information.  See the
    documentation for the implementation for details.  */
 int check_key_signature2 (ctrl_t ctrl, kbnode_t root, kbnode_t node,
                           PKT_public_key *check_pk, PKT_public_key *ret_pk,
                           int *is_selfsig, u32 *r_expiredate, int *r_expired);
 
 /* Returns whether SIGNER generated the signature SIG over the packet
    PACKET, which is a key, subkey or uid, and comes from the key block
    KB.  If SIGNER is NULL, it is looked up based on the information in
    SIG.  If not NULL, sets *IS_SELFSIG to indicate whether the
    signature is a self-signature and *RET_PK to a copy of the signer's
    key.  */
 gpg_error_t check_signature_over_key_or_uid (ctrl_t ctrl,
                                              PKT_public_key *signer,
                                              PKT_signature *sig,
                                              KBNODE kb, PACKET *packet,
                                              int *is_selfsig,
                                              PKT_public_key *ret_pk);
 
 
 /*-- delkey.c --*/
 gpg_error_t delete_keys (ctrl_t ctrl,
                          strlist_t names, int secret, int allow_both);
 
 /*-- keygen.c --*/
 const char *get_default_pubkey_algo (void);
 u32 parse_expire_string(const char *string);
 u32 ask_expire_interval(int object,const char *def_expire);
 u32 ask_expiredate(void);
 unsigned int ask_key_flags (int algo, int subkey, unsigned int current);
 const char *ask_curve (int *algo, int *subkey_algo, const char *current);
 void quick_generate_keypair (ctrl_t ctrl, const char *uid, const char *algostr,
                              const char *usagestr, const char *expirestr);
 void generate_keypair (ctrl_t ctrl, int full, const char *fname,
                        const char *card_serialno, int card_backup_key);
 int keygen_set_std_prefs (const char *string,int personal);
 PKT_user_id *keygen_get_std_prefs (void);
 int keygen_add_key_expire( PKT_signature *sig, void *opaque );
 int keygen_add_key_flags (PKT_signature *sig, void *opaque);
 int keygen_add_std_prefs( PKT_signature *sig, void *opaque );
 int keygen_upd_std_prefs( PKT_signature *sig, void *opaque );
 int keygen_add_keyserver_url(PKT_signature *sig, void *opaque);
 int keygen_add_notations(PKT_signature *sig,void *opaque);
 int keygen_add_revkey(PKT_signature *sig, void *opaque);
 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 generate_subkeypair (ctrl_t ctrl, kbnode_t keyblock,
                                  const char *algostr,
                                  const char *usagestr,
                                  const char *expirestr);
 #ifdef ENABLE_CARD_SUPPORT
 gpg_error_t generate_card_subkeypair (ctrl_t ctrl, kbnode_t pub_keyblock,
                                       int keyno, const char *serialno);
 #endif
 
 
 /*-- openfile.c --*/
 int overwrite_filep( const char *fname );
 char *make_outfile_name( const char *iname );
 char *ask_outfile_name( const char *name, size_t namelen );
 int open_outfile (int out_fd, const char *iname, int mode,
                   int restrictedperm, iobuf_t *a);
 char *get_matching_datafile (const char *sigfilename);
 iobuf_t open_sigfile (const char *sigfilename, progress_filter_context_t *pfx);
 void try_make_homedir( const char *fname );
 char *get_openpgp_revocdir (const char *home);
 
 /*-- seskey.c --*/
 void make_session_key( DEK *dek );
 gcry_mpi_t encode_session_key( int openpgp_pk_algo, DEK *dek, unsigned nbits );
 gcry_mpi_t encode_md_value (PKT_public_key *pk,
                             gcry_md_hd_t md, int hash_algo );
 
 /*-- import.c --*/
 struct import_stats_s;
 typedef struct import_stats_s *import_stats_t;
 struct import_filter_s;
 typedef struct import_filter_s *import_filter_t;
 typedef gpg_error_t (*import_screener_t)(kbnode_t keyblock, void *arg);
 
 int parse_import_options(char *str,unsigned int *options,int noisy);
 
 gpg_error_t parse_and_set_import_filter (const char *string);
 import_filter_t save_and_clear_import_filter (void);
 void            restore_import_filter (import_filter_t filt);
 
 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 import_included_key_block (ctrl_t ctrl, kbnode_t keyblock);
 void import_keys (ctrl_t ctrl, char **fnames, int nnames,
 		  import_stats_t stats_hd, unsigned int options,
                   int origin, const char *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 import_old_secring (ctrl_t ctrl, const char *fname);
 import_stats_t import_new_stats_handle (void);
 void import_release_stats_handle (import_stats_t hd);
 void import_print_stats (import_stats_t hd);
 /* Communication for impex_filter_getval */
 struct impex_filter_parm_s
 {
   ctrl_t ctrl;
   kbnode_t node;
   char hexfpr[2*MAX_FINGERPRINT_LEN + 1];
 };
 
 const char *impex_filter_getval (void *cookie, const char *propname);
 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);
 
 int collapse_uids (kbnode_t *keyblock);
 int collapse_subkeys (kbnode_t *keyblock);
 
 int get_revocation_reason (PKT_signature *sig, char **r_reason,
                            char **r_comment, size_t *r_commentlen);
 
 
 /*-- export.c --*/
 struct export_stats_s;
 typedef struct export_stats_s *export_stats_t;
 
 export_stats_t export_new_stats (void);
 void export_release_stats (export_stats_t stats);
 void export_print_stats (export_stats_t stats);
 
 int parse_export_options(char *str,unsigned int *options,int noisy);
 gpg_error_t parse_and_set_export_filter (const char *string);
 void push_export_filters (void);
 void pop_export_filters (void);
 
 int exact_subkey_match_p (KEYDB_SEARCH_DESC *desc, kbnode_t node);
 
 int export_pubkeys (ctrl_t ctrl, strlist_t users, unsigned int options,
                     export_stats_t stats);
 int export_seckeys (ctrl_t ctrl, strlist_t users, unsigned int options,
                     export_stats_t stats);
 int export_secsubkeys (ctrl_t ctrl, strlist_t users, unsigned int options,
                        export_stats_t stats);
 
 gpg_error_t export_pubkey_buffer (ctrl_t ctrl, const char *keyspec,
                                   unsigned int options,
                                   const void *prefix, size_t prefixlen,
                                   export_stats_t stats,
                                   kbnode_t *r_keyblock,
                                   void **r_data, size_t *r_datalen);
 
 gpg_error_t receive_seckey_from_agent (ctrl_t ctrl, gcry_cipher_hd_t cipherhd,
                                        int cleartext,
                                        char **cache_nonce_addr,
                                        const char *hexgrip,
                                        PKT_public_key *pk);
 
 gpg_error_t write_keyblock_to_output (kbnode_t keyblock,
                                       int with_armor, unsigned int options);
 
 gpg_error_t export_ssh_key (ctrl_t ctrl, const char *userid);
+gpg_error_t export_secret_ssh_key (ctrl_t ctrl, const char *userid);
 
 /*-- dearmor.c --*/
 int dearmor_file( const char *fname );
 int enarmor_file( const char *fname );
 
 /*-- revoke.c --*/
 struct revocation_reason_info;
 
 int gen_standard_revoke (ctrl_t ctrl,
                          PKT_public_key *psk, const char *cache_nonce);
 int gen_revoke (ctrl_t ctrl, const char *uname);
 int gen_desig_revoke (ctrl_t ctrl, const char *uname, strlist_t locusr);
 int revocation_reason_build_cb( PKT_signature *sig, void *opaque );
 struct revocation_reason_info *
 		ask_revocation_reason( int key_rev, int cert_rev, int hint );
 struct revocation_reason_info * get_default_uid_revocation_reason (void);
 struct revocation_reason_info * get_default_sig_revocation_reason (void);
 void release_revocation_reason_info (struct revocation_reason_info *reason);
 
 /*-- keylist.c --*/
 void public_key_list (ctrl_t ctrl, strlist_t list,
                       int locate_mode, int no_local);
 void secret_key_list (ctrl_t ctrl, strlist_t list );
 void print_subpackets_colon(PKT_signature *sig);
 void reorder_keyblock (KBNODE keyblock);
 void list_keyblock_direct (ctrl_t ctrl, kbnode_t keyblock, int secret,
                            int has_secret, int fpr, int no_validity);
 int  cmp_signodes (const void *av, const void *bv);
 void print_fingerprint (ctrl_t ctrl, estream_t fp,
                         PKT_public_key *pk, int mode);
 void print_revokers (estream_t fp, PKT_public_key *pk);
 void show_policy_url(PKT_signature *sig,int indent,int mode);
 void show_keyserver_url(PKT_signature *sig,int indent,int mode);
 void show_notation(PKT_signature *sig,int indent,int mode,int which);
 void dump_attribs (const PKT_user_id *uid, PKT_public_key *pk);
 void set_attrib_fd(int fd);
 void print_key_info (ctrl_t ctrl, estream_t fp, int indent,
                      PKT_public_key *pk, int secret);
 void print_key_info_log (ctrl_t ctrl, int loglevel, int indent,
                      PKT_public_key *pk, int secret);
 void print_card_key_info (estream_t fp, KBNODE keyblock);
 void print_key_line (ctrl_t ctrl, estream_t fp, PKT_public_key *pk, int secret);
 
 /*-- verify.c --*/
 void print_file_status( int status, const char *name, int what );
 int verify_signatures (ctrl_t ctrl, int nfiles, char **files );
 int verify_files (ctrl_t ctrl, int nfiles, char **files );
 int gpg_verify (ctrl_t ctrl, int sig_fd, int data_fd, estream_t out_fp);
 
 /*-- decrypt.c --*/
 int decrypt_message (ctrl_t ctrl, const char *filename );
 gpg_error_t decrypt_message_fd (ctrl_t ctrl, int input_fd, int output_fd);
 void decrypt_messages (ctrl_t ctrl, int nfiles, char *files[]);
 
 /*-- plaintext.c --*/
 int hash_datafiles( gcry_md_hd_t md, gcry_md_hd_t md2,
 		    strlist_t files, const char *sigfilename, int textmode);
 int hash_datafile_by_fd ( gcry_md_hd_t md, gcry_md_hd_t md2, int data_fd,
                           int textmode );
 PKT_plaintext *setup_plaintext_name(const char *filename,IOBUF iobuf);
 
 /*-- server.c --*/
 int gpg_server (ctrl_t);
 gpg_error_t gpg_proxy_pinentry_notify (ctrl_t ctrl,
                                        const unsigned char *line);
 
 #ifdef ENABLE_CARD_SUPPORT
 /*-- card-util.c --*/
 void change_pin (int no, int allow_admin);
 void card_status (ctrl_t ctrl, estream_t fp, const char *serialno);
 void card_edit (ctrl_t ctrl, strlist_t commands);
 gpg_error_t  card_generate_subkey (ctrl_t ctrl, kbnode_t pub_keyblock);
 int  card_store_subkey (KBNODE node, int use);
 #endif
 
 /*-- migrate.c --*/
 void migrate_secring (ctrl_t ctrl);
 
 
 #endif /*G10_MAIN_H*/