diff --git a/common/audit.c b/common/audit.c
index 179bf72fe..718f7292e 100644
--- a/common/audit.c
+++ b/common/audit.c
@@ -1,1323 +1,1324 @@
 /* audit.c - GnuPG's audit subsystem
  *	Copyright (C) 2007, 2009 Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
  * GnuPG is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 3 of the License, or
  * (at your option) any later version.
  *
  * GnuPG is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, see <https://www.gnu.org/licenses/>.
  */
 
 #include <config.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdarg.h>
 #include <assert.h>
 
 #include "util.h"
 #include "i18n.h"
 #include "audit.h"
 #include "audit-events.h"
 
 /* A list to maintain a list of helptags.  */
 struct helptag_s
 {
   struct helptag_s *next;
   const char *name;
 };
 typedef struct helptag_s *helptag_t;
 
 
 /* One log entry.  */
 struct log_item_s
 {
   audit_event_t event; /* The event.  */
   gpg_error_t err;     /* The logged error code.  */
   int intvalue;        /* A logged integer value.  */
   char *string;        /* A malloced string or NULL.  */
   ksba_cert_t cert;    /* A certifciate or NULL. */
   int have_err:1;
   int have_intvalue:1;
 };
 typedef struct log_item_s *log_item_t;
 
 
 
 /* The main audit object.  */
 struct audit_ctx_s
 {
   const char *failure;  /* If set a description of the internal failure.  */
   audit_type_t type;
 
   log_item_t log;       /* The table with the log entries.  */
   size_t logsize;       /* The allocated size for LOG.  */
   size_t logused;       /* The used size of LOG.  */
 
   estream_t outstream;  /* The current output stream.  */
   int use_html;         /* The output shall be HTML formatted.  */
   int indentlevel;      /* Current level of indentation.  */
   helptag_t helptags;   /* List of help keys.  */
 };
 
 
 
 
 static void writeout_para (audit_ctx_t ctx,
                            const char *format, ...) GPGRT_ATTR_PRINTF(2,3);
 static void writeout_li (audit_ctx_t ctx, const char *oktext,
                          const char *format, ...) GPGRT_ATTR_PRINTF(3,4);
 static void writeout_rem (audit_ctx_t ctx,
                           const char *format, ...) GPGRT_ATTR_PRINTF(2,3);
 
 
 /* Add NAME to the list of help tags.  NAME needs to be a const string
    an this function merly stores this pointer.  */
 static void
 add_helptag (audit_ctx_t ctx, const char *name)
 {
   helptag_t item;
 
   for (item=ctx->helptags; item; item = item->next)
     if (!strcmp (item->name, name))
       return;  /* Already in the list.  */
   item = xtrycalloc (1, sizeof *item);
   if (!item)
     return;  /* Don't care about memory problems.  */
   item->name = name;
   item->next = ctx->helptags;
   ctx->helptags = item;
 }
 
 
 /* Remove all help tags from the context.  */
 static void
 clear_helptags (audit_ctx_t ctx)
 {
   while (ctx->helptags)
     {
       helptag_t tmp = ctx->helptags->next;
       xfree (ctx->helptags);
       ctx->helptags = tmp;
     }
 }
 
 
 
 static const char *
 event2str (audit_event_t event)
 {
   /* We need the cast so that compiler does not complain about an
      always true comparison (>= 0) for an unsigned value.  */
   int idx = eventstr_msgidxof ((int)event);
   if (idx == -1)
     return "Unknown event";
   else
     return eventstr_msgstr + eventstr_msgidx[idx];
 }
 
 
 
 /* Create a new audit context.  In case of an error NULL is returned
    and errno set appropriately. */
 audit_ctx_t
 audit_new (void)
 {
   audit_ctx_t ctx;
 
   ctx = xtrycalloc (1, sizeof *ctx);
 
   return ctx;
 }
 
 
 /* Release an audit context.  Passing NULL for CTX is allowed and does
    nothing.  */
 void
 audit_release (audit_ctx_t ctx)
 {
   int idx;
   if (!ctx)
     return;
   if (ctx->log)
     {
       for (idx=0; idx < ctx->logused; idx++)
         {
           if (ctx->log[idx].string)
             xfree (ctx->log[idx].string);
           if (ctx->log[idx].cert)
             ksba_cert_release (ctx->log[idx].cert);
         }
       xfree (ctx->log);
     }
   clear_helptags (ctx);
   xfree (ctx);
 }
 
 
 /* Set the type for the audit operation.  If CTX is NULL, this is a
    dummy function.  */
 void
 audit_set_type (audit_ctx_t ctx, audit_type_t type)
 {
   if (!ctx || ctx->failure)
     return;  /* Audit not enabled or an internal error has occurred. */
 
   if (ctx->type && ctx->type != type)
     {
       ctx->failure = "conflict in type initialization";
       return;
     }
   ctx->type = type;
 }
 
 
 /* Create a new log item and put it into the table.  Return that log
    item on success; return NULL on memory failure and mark that in
    CTX. */
 static log_item_t
 create_log_item (audit_ctx_t ctx)
 {
   log_item_t item, table;
   size_t size;
 
   if (!ctx->log)
     {
       size = 10;
       table = xtrymalloc (size * sizeof *table);
       if (!table)
         {
           ctx->failure = "Out of memory in create_log_item";
           return NULL;
         }
       ctx->log = table;
       ctx->logsize = size;
       item = ctx->log + 0;
       ctx->logused = 1;
     }
   else if (ctx->logused >= ctx->logsize)
     {
       size = ctx->logsize + 10;
       table = xtryrealloc (ctx->log, size * sizeof *table);
       if (!table)
         {
           ctx->failure = "Out of memory while reallocating in create_log_item";
           return NULL;
         }
       ctx->log = table;
       ctx->logsize = size;
       item = ctx->log + ctx->logused++;
     }
   else
     item = ctx->log + ctx->logused++;
 
   item->event = AUDIT_NULL_EVENT;
   item->err = 0;
   item->have_err = 0;
   item->intvalue = 0;
   item->have_intvalue = 0;
   item->string = NULL;
   item->cert = NULL;
 
   return item;
 
 }
 
 /* Add a new event to the audit log.  If CTX is NULL, this function
    does nothing.  */
 void
 audit_log (audit_ctx_t ctx, audit_event_t event)
 {
   log_item_t item;
 
   if (!ctx || ctx->failure)
     return;  /* Audit not enabled or an internal error has occurred. */
   if (!event)
     {
       ctx->failure = "Invalid event passed to audit_log";
       return;
     }
   if (!(item = create_log_item (ctx)))
     return;
   item->event = event;
 }
 
 /* Add a new event to the audit log.  If CTX is NULL, this function
    does nothing.  This version also adds the result of the operation
    to the log.  */
 void
 audit_log_ok (audit_ctx_t ctx, audit_event_t event, gpg_error_t err)
 {
   log_item_t item;
 
   if (!ctx || ctx->failure)
     return;  /* Audit not enabled or an internal error has occurred. */
   if (!event)
     {
       ctx->failure = "Invalid event passed to audit_log_ok";
       return;
     }
   if (!(item = create_log_item (ctx)))
     return;
   item->event = event;
   item->err = err;
   item->have_err = 1;
 }
 
 
 /* Add a new event to the audit log.  If CTX is NULL, this function
    does nothing.  This version also add the integer VALUE to the log.  */
 void
 audit_log_i (audit_ctx_t ctx, audit_event_t event, int value)
 {
   log_item_t item;
 
   if (!ctx || ctx->failure)
     return;  /* Audit not enabled or an internal error has occurred. */
   if (!event)
     {
       ctx->failure = "Invalid event passed to audit_log_i";
       return;
     }
   if (!(item = create_log_item (ctx)))
     return;
   item->event = event;
   item->intvalue = value;
   item->have_intvalue = 1;
 }
 
 
 /* Add a new event to the audit log.  If CTX is NULL, this function
    does nothing.  This version also add the integer VALUE to the log.  */
 void
 audit_log_s (audit_ctx_t ctx, audit_event_t event, const char *value)
 {
   log_item_t item;
   char *tmp;
 
   if (!ctx || ctx->failure)
     return;  /* Audit not enabled or an internal error has occurred. */
   if (!event)
     {
       ctx->failure = "Invalid event passed to audit_log_s";
       return;
     }
   tmp = xtrystrdup (value? value : "");
   if (!tmp)
     {
       ctx->failure = "Out of memory in audit_event";
       return;
     }
   if (!(item = create_log_item (ctx)))
     {
       xfree (tmp);
       return;
     }
   item->event = event;
   item->string = tmp;
 }
 
 /* Add a new event to the audit log.  If CTX is NULL, this function
    does nothing.  This version also adds the certificate CERT and the
    result of an operation to the log.  */
 void
 audit_log_cert (audit_ctx_t ctx, audit_event_t event,
                 ksba_cert_t cert, gpg_error_t err)
 {
   log_item_t item;
 
   if (!ctx || ctx->failure)
     return;  /* Audit not enabled or an internal error has occurred. */
   if (!event)
     {
       ctx->failure = "Invalid event passed to audit_log_cert";
       return;
     }
   if (!(item = create_log_item (ctx)))
     return;
   item->event = event;
   item->err = err;
   item->have_err = 1;
   if (cert)
     {
       ksba_cert_ref (cert);
       item->cert = cert;
     }
 }
 
 
 /* Write TEXT to the outstream.  */
 static void
 writeout (audit_ctx_t ctx, const char *text)
 {
   if (ctx->use_html)
     {
       for (; *text; text++)
         {
           if (*text == '<')
             es_fputs ("&lt;", ctx->outstream);
           else if (*text == '&')
             es_fputs ("&amp;", ctx->outstream);
           else
             es_putc (*text, ctx->outstream);
         }
     }
   else
     es_fputs (text, ctx->outstream);
 }
 
 
 /* Write TEXT to the outstream using a variable argument list.  */
 static void
 writeout_v (audit_ctx_t ctx, const char *format, va_list arg_ptr)
 {
   char *buf;
 
   gpgrt_vasprintf (&buf, format, arg_ptr);
   if (buf)
     {
       writeout (ctx, buf);
       xfree (buf);
     }
   else
     writeout (ctx, "[!!Out of core!!]");
 }
 
 
 /* Write TEXT as a paragraph.  */
 static void
 writeout_para (audit_ctx_t ctx, const char *format, ...)
 {
   va_list arg_ptr;
 
   if (ctx->use_html)
     es_fputs ("<p>", ctx->outstream);
   va_start (arg_ptr, format) ;
   writeout_v (ctx, format, arg_ptr);
   va_end (arg_ptr);
   if (ctx->use_html)
     es_fputs ("</p>\n", ctx->outstream);
   else
     es_fputc ('\n', ctx->outstream);
 }
 
 
 static void
 enter_li (audit_ctx_t ctx)
 {
   if (ctx->use_html)
     {
       if (!ctx->indentlevel)
         {
           es_fputs ("<table border=\"0\">\n"
                     "  <colgroup>\n"
                     "    <col width=\"80%\" />\n"
                     "    <col width=\"20%\" />\n"
                     "   </colgroup>\n",
                     ctx->outstream);
         }
     }
   ctx->indentlevel++;
 }
 
 
 static void
 leave_li (audit_ctx_t ctx)
 {
   ctx->indentlevel--;
   if (ctx->use_html)
     {
       if (!ctx->indentlevel)
         es_fputs ("</table>\n", ctx->outstream);
     }
 }
 
 
 /* Write TEXT as a list element.  If OKTEXT is not NULL, append it to
    the last line. */
 static void
 writeout_li (audit_ctx_t ctx, const char *oktext, const char *format, ...)
 {
   va_list arg_ptr;
   const char *color = NULL;
 
   if (ctx->use_html && format && oktext)
     {
       if (!strcmp (oktext, "Yes")
           || !strcmp (oktext, "good") )
         color = "green";
       else if (!strcmp (oktext, "No")
                || !strcmp (oktext, "bad") )
         color = "red";
     }
 
   if (format && oktext)
     {
       const char *s = NULL;
 
       if (!strcmp (oktext, "Yes"))
         oktext = _("Yes");
       else if (!strcmp (oktext, "No"))
         oktext = _("No");
       else if (!strcmp (oktext, "good"))
         {
           /* TRANSLATORS: Copy the prefix between the vertical bars
              verbatim.  It will not be printed.  */
           oktext = _("|audit-log-result|Good");
         }
       else if (!strcmp (oktext, "bad"))
         oktext = _("|audit-log-result|Bad");
       else if (!strcmp (oktext, "unsupported"))
         oktext = _("|audit-log-result|Not supported");
       else if (!strcmp (oktext, "no-cert"))
         oktext = _("|audit-log-result|No certificate");
       else if (!strcmp (oktext, "disabled"))
         oktext = _("|audit-log-result|Not enabled");
       else if (!strcmp (oktext, "error"))
         oktext = _("|audit-log-result|Error");
       else if (!strcmp (oktext, "not-used"))
         oktext = _("|audit-log-result|Not used");
       else if (!strcmp (oktext, "okay"))
         oktext = _("|audit-log-result|Okay");
       else if (!strcmp (oktext, "skipped"))
         oktext = _("|audit-log-result|Skipped");
       else if (!strcmp (oktext, "some"))
         oktext = _("|audit-log-result|Some");
       else
         s = "";
 
       /* If we have set a prefix, skip it.  */
       if (!s && *oktext == '|' && (s=strchr (oktext+1,'|')))
         oktext = s+1;
     }
 
   if (ctx->use_html)
     {
       int i;
 
       es_fputs ("  <tr><td><table><tr><td>", ctx->outstream);
       if (color)
         es_fprintf (ctx->outstream, "<font color=\"%s\">*</font>", color);
       else
         es_fputs ("*", ctx->outstream);
       for (i=1; i < ctx->indentlevel; i++)
         es_fputs ("&nbsp;&nbsp;", ctx->outstream);
       es_fputs ("</td><td>", ctx->outstream);
     }
   else
     es_fprintf (ctx->outstream, "* %*s", (ctx->indentlevel-1)*2, "");
   if (format)
     {
       va_start (arg_ptr, format) ;
       writeout_v (ctx, format, arg_ptr);
       va_end (arg_ptr);
     }
   if (ctx->use_html)
     es_fputs ("</td></tr></table>", ctx->outstream);
   if (format && oktext)
     {
       if (ctx->use_html)
         {
           es_fputs ("</td><td>", ctx->outstream);
           if (color)
             es_fprintf (ctx->outstream, "<font color=\"%s\">", color);
         }
       else
         writeout (ctx, ":         ");
       writeout (ctx, oktext);
       if (color)
         es_fputs ("</font>", ctx->outstream);
     }
 
   if (ctx->use_html)
     es_fputs ("</td></tr>\n", ctx->outstream);
   else
     es_fputc ('\n', ctx->outstream);
 }
 
 
 /* Write a remark line.  */
 static void
 writeout_rem (audit_ctx_t ctx, const char *format, ...)
 {
   va_list arg_ptr;
 
   if (ctx->use_html)
     {
       int i;
 
       es_fputs ("  <tr><td><table><tr><td>*", ctx->outstream);
       for (i=1; i < ctx->indentlevel; i++)
         es_fputs ("&nbsp;&nbsp;", ctx->outstream);
       es_fputs ("&nbsp;&nbsp;&nbsp;</td><td> (", ctx->outstream);
 
     }
   else
     es_fprintf (ctx->outstream, "* %*s  (", (ctx->indentlevel-1)*2, "");
   if (format)
     {
       va_start (arg_ptr, format) ;
       writeout_v (ctx, format, arg_ptr);
       va_end (arg_ptr);
     }
   if (ctx->use_html)
     es_fputs (")</td></tr></table></td></tr>\n", ctx->outstream);
   else
     es_fputs (")\n", ctx->outstream);
 }
 
 
 /* Return the first log item for EVENT.  If STOPEVENT is not 0 never
    look behind that event in the log. If STARTITEM is not NULL start
    search _after_that item.  */
 static log_item_t
 find_next_log_item (audit_ctx_t ctx, log_item_t startitem,
                     audit_event_t event, audit_event_t stopevent)
 {
   int idx;
 
   for (idx=0; idx < ctx->logused; idx++)
     {
       if (startitem)
         {
           if (ctx->log + idx == startitem)
             startitem = NULL;
         }
       else if (stopevent && ctx->log[idx].event == stopevent)
         break;
       else if (ctx->log[idx].event == event)
         return ctx->log + idx;
     }
   return NULL;
 }
 
 
 static log_item_t
 find_log_item (audit_ctx_t ctx, audit_event_t event, audit_event_t stopevent)
 {
   return find_next_log_item (ctx, NULL, event, stopevent);
 }
 
 
 /* Helper to a format a serial number.  */
 static char *
 format_serial (ksba_const_sexp_t sn)
 {
   const char *p = (const char *)sn;
   unsigned long n;
   char *endp;
 
   if (!p)
     return NULL;
   if (*p != '(')
     BUG (); /* Not a valid S-expression. */
   n = strtoul (p+1, &endp, 10);
   p = endp;
   if (*p != ':')
     BUG (); /* Not a valid S-expression. */
   return bin2hex (p+1, n, NULL);
 }
 
 
 /* Return a malloced string with the serial number and the issuer DN
    of the certificate.  */
 static char *
 get_cert_name (ksba_cert_t cert)
 {
   char *result;
   ksba_sexp_t sn;
   char *issuer, *p;
 
   if (!cert)
     return xtrystrdup ("[no certificate]");
 
   issuer = ksba_cert_get_issuer (cert, 0);
   sn = ksba_cert_get_serial (cert);
   if (issuer && sn)
     {
       p = format_serial (sn);
       if (!p)
         result = xtrystrdup ("[invalid S/N]");
       else
         {
           result = xtrymalloc (strlen (p) + strlen (issuer) + 2 + 1);
           if (result)
             {
               *result = '#';
               strcpy (stpcpy (stpcpy (result+1, p),"/"), issuer);
             }
           xfree (p);
         }
     }
   else
     result = xtrystrdup ("[missing S/N or issuer]");
   ksba_free (sn);
   xfree (issuer);
   return result;
 }
 
 /* Return a malloced string with the serial number and the issuer DN
    of the certificate.  */
 static char *
 get_cert_subject (ksba_cert_t cert, int idx)
 {
   char *result;
   char *subject;
 
   if (!cert)
     return xtrystrdup ("[no certificate]");
 
   subject = ksba_cert_get_subject (cert, idx);
   if (subject)
     {
       result = xtrymalloc (strlen (subject) + 1 + 1);
       if (result)
         {
           *result = '/';
           strcpy (result+1, subject);
         }
     }
   else
     result = NULL;
   xfree (subject);
   return result;
 }
 
 
 /* List the given certificiate.  If CERT is NULL, this is a NOP.  */
 static void
 list_cert (audit_ctx_t ctx, ksba_cert_t cert, int with_subj)
 {
   char *name;
   int idx;
 
   name = get_cert_name (cert);
   writeout_rem (ctx, "%s", name);
   xfree (name);
   if (with_subj)
     {
       enter_li (ctx);
       for (idx=0; (name = get_cert_subject (cert, idx)); idx++)
         {
           writeout_rem (ctx, "%s", name);
           xfree (name);
         }
       leave_li (ctx);
     }
 }
 
 
 /* List the chain of certificates from STARTITEM up to STOPEVENT.  The
    certificates are written out as comments.  */
 static void
 list_certchain (audit_ctx_t ctx, log_item_t startitem, audit_event_t stopevent)
 {
   log_item_t item;
 
   startitem = find_next_log_item (ctx, startitem, AUDIT_CHAIN_BEGIN,stopevent);
   writeout_li (ctx, startitem? "Yes":"No", _("Certificate chain available"));
   if (!startitem)
     return;
 
   item = find_next_log_item (ctx, startitem,
                              AUDIT_CHAIN_ROOTCERT, AUDIT_CHAIN_END);
   if (!item)
     writeout_rem (ctx, "%s", _("root certificate missing"));
   else
     {
       list_cert (ctx, item->cert, 0);
     }
   item = startitem;
   while ( ((item = find_next_log_item (ctx, item,
                                        AUDIT_CHAIN_CERT, AUDIT_CHAIN_END))))
     {
       list_cert (ctx, item->cert, 1);
     }
 }
 
 
 
 /* Process an encrypt operation's log.  */
 static void
 proc_type_encrypt (audit_ctx_t ctx)
 {
   log_item_t loopitem, item;
   int recp_no, idx;
   char numbuf[35];
   int algo;
   char *name;
 
   item = find_log_item (ctx, AUDIT_ENCRYPTION_DONE, 0);
   writeout_li (ctx, item?"Yes":"No", "%s", _("Data encryption succeeded"));
 
   enter_li (ctx);
 
   item = find_log_item (ctx, AUDIT_GOT_DATA, 0);
   writeout_li (ctx, item? "Yes":"No", "%s", _("Data available"));
 
   item = find_log_item (ctx, AUDIT_SESSION_KEY, 0);
   writeout_li (ctx, item? "Yes":"No", "%s", _("Session key created"));
   if (item)
     {
       algo = gcry_cipher_map_name (item->string);
       if (algo)
         writeout_rem (ctx, _("algorithm: %s"), gnupg_cipher_algo_name (algo));
       else if (item->string && !strcmp (item->string, "1.2.840.113549.3.2"))
         writeout_rem (ctx, _("unsupported algorithm: %s"), "RC2");
       else if (item->string)
         writeout_rem (ctx, _("unsupported algorithm: %s"), item->string);
       else
         writeout_rem (ctx, _("seems to be not encrypted"));
     }
 
   item = find_log_item (ctx, AUDIT_GOT_RECIPIENTS, 0);
   snprintf (numbuf, sizeof numbuf, "%d",
             item && item->have_intvalue? item->intvalue : 0);
   writeout_li (ctx, numbuf, "%s", _("Number of recipients"));
 
   /* Loop over all recipients.  */
   loopitem = NULL;
   recp_no = 0;
   while ((loopitem=find_next_log_item (ctx, loopitem, AUDIT_ENCRYPTED_TO, 0)))
     {
       recp_no++;
       writeout_li (ctx, NULL, _("Recipient %d"), recp_no);
       if (loopitem->cert)
         {
           name = get_cert_name (loopitem->cert);
           writeout_rem (ctx, "%s", name);
           xfree (name);
           enter_li (ctx);
           for (idx=0; (name = get_cert_subject (loopitem->cert, idx)); idx++)
             {
               writeout_rem (ctx, "%s", name);
               xfree (name);
             }
           leave_li (ctx);
         }
     }
 
   leave_li (ctx);
 }
 
 
 
 /* Process a sign operation's log.  */
 static void
 proc_type_sign (audit_ctx_t ctx)
 {
   log_item_t item, loopitem;
   int signer, idx;
   const char *result;
   ksba_cert_t cert;
   char *name;
   int lastalgo;
 
   item = find_log_item (ctx, AUDIT_SIGNING_DONE, 0);
   writeout_li (ctx, item?"Yes":"No", "%s", _("Data signing succeeded"));
 
   enter_li (ctx);
 
   item = find_log_item (ctx, AUDIT_GOT_DATA, 0);
   writeout_li (ctx, item? "Yes":"No", "%s", _("Data available"));
   /* Write remarks with the data hash algorithms.  We use a very
      simple scheme to avoid some duplicates.  */
   loopitem = NULL;
   lastalgo = 0;
   while ((loopitem = find_next_log_item
           (ctx, loopitem, AUDIT_DATA_HASH_ALGO, AUDIT_NEW_SIG)))
     {
       if (loopitem->intvalue && loopitem->intvalue != lastalgo)
         writeout_rem (ctx, _("data hash algorithm: %s"),
                       gcry_md_algo_name (loopitem->intvalue));
       lastalgo = loopitem->intvalue;
     }
 
   /* Loop over all signer.  */
   loopitem = NULL;
   signer = 0;
   while ((loopitem=find_next_log_item (ctx, loopitem, AUDIT_NEW_SIG, 0)))
     {
       signer++;
 
       item = find_next_log_item (ctx, loopitem, AUDIT_SIGNED_BY, AUDIT_NEW_SIG);
       if (!item)
         result = "error";
       else if (!item->err)
         result = "okay";
       else if (gpg_err_code (item->err) == GPG_ERR_CANCELED)
         result = "skipped";
       else
         result = gpg_strerror (item->err);
       cert = item? item->cert : NULL;
 
       writeout_li (ctx, result, _("Signer %d"), signer);
       item = find_next_log_item (ctx, loopitem,
                                  AUDIT_ATTR_HASH_ALGO, AUDIT_NEW_SIG);
       if (item)
         writeout_rem (ctx, _("attr hash algorithm: %s"),
                       gcry_md_algo_name (item->intvalue));
 
       if (cert)
         {
           name = get_cert_name (cert);
           writeout_rem (ctx, "%s", name);
           xfree (name);
           enter_li (ctx);
           for (idx=0; (name = get_cert_subject (cert, idx)); idx++)
             {
               writeout_rem (ctx, "%s", name);
               xfree (name);
             }
           leave_li (ctx);
         }
     }
 
   leave_li (ctx);
 }
 
 
 
 /* Process a decrypt operation's log.  */
 static void
 proc_type_decrypt (audit_ctx_t ctx)
 {
   log_item_t loopitem, item;
   int algo, recpno;
   char *name;
   char numbuf[35];
   int idx;
 
   item = find_log_item (ctx, AUDIT_DECRYPTION_RESULT, 0);
   writeout_li (ctx, item && !item->err?"Yes":"No",
                "%s", _("Data decryption succeeded"));
 
   enter_li (ctx);
 
   item = find_log_item (ctx, AUDIT_GOT_DATA, 0);
   writeout_li (ctx, item? "Yes":"No", "%s", _("Data available"));
 
   item = find_log_item (ctx, AUDIT_DATA_CIPHER_ALGO, 0);
   algo = item? item->intvalue : 0;
   writeout_li (ctx, algo?"Yes":"No", "%s", _("Encryption algorithm supported"));
   if (algo)
     writeout_rem (ctx, _("algorithm: %s"), gnupg_cipher_algo_name (algo));
 
   item = find_log_item (ctx, AUDIT_BAD_DATA_CIPHER_ALGO, 0);
   if (item && item->string)
     {
       algo = gcry_cipher_map_name (item->string);
       if (algo)
         writeout_rem (ctx, _("algorithm: %s"), gnupg_cipher_algo_name (algo));
       else if (item->string && !strcmp (item->string, "1.2.840.113549.3.2"))
         writeout_rem (ctx, _("unsupported algorithm: %s"), "RC2");
       else if (item->string)
         writeout_rem (ctx, _("unsupported algorithm: %s"), item->string);
       else
         writeout_rem (ctx, _("seems to be not encrypted"));
     }
 
 
   for (recpno = 0, item = NULL;
        (item = find_next_log_item (ctx, item, AUDIT_NEW_RECP, 0)); recpno++)
     ;
   snprintf (numbuf, sizeof numbuf, "%d", recpno);
   writeout_li (ctx, numbuf, "%s", _("Number of recipients"));
 
   /* Loop over all recipients.  */
   loopitem = NULL;
   while ((loopitem = find_next_log_item (ctx, loopitem, AUDIT_NEW_RECP, 0)))
     {
       const char *result;
 
       recpno = loopitem->have_intvalue? loopitem->intvalue : -1;
 
       item = find_next_log_item (ctx, loopitem,
                                  AUDIT_RECP_RESULT, AUDIT_NEW_RECP);
       if (!item)
         result = "not-used";
       else if (!item->err)
         result = "okay";
       else if (gpg_err_code (item->err) == GPG_ERR_CANCELED)
         result = "skipped";
       else
         result = gpg_strerror (item->err);
 
       item = find_next_log_item (ctx, loopitem,
                                  AUDIT_RECP_NAME, AUDIT_NEW_RECP);
       writeout_li (ctx, result, _("Recipient %d"), recpno);
       if (item && item->string)
         writeout_rem (ctx, "%s", item->string);
 
       /* If we have a certificate write out more infos.  */
       item = find_next_log_item (ctx, loopitem,
                                  AUDIT_SAVE_CERT, AUDIT_NEW_RECP);
       if (item && item->cert)
         {
           enter_li (ctx);
           for (idx=0; (name = get_cert_subject (item->cert, idx)); idx++)
             {
               writeout_rem (ctx, "%s", name);
               xfree (name);
             }
           leave_li (ctx);
         }
     }
 
   leave_li (ctx);
 }
 
 
 
 /* Process a verification operation's log.  */
 static void
 proc_type_verify (audit_ctx_t ctx)
 {
   log_item_t loopitem, item;
   int signo, count, idx, n_good, n_bad;
   char numbuf[35];
   const char *result;
 
   /* If there is at least one signature status we claim that the
      verification succeeded.  This does not mean that the data has
      verified okay.  */
   item = find_log_item (ctx, AUDIT_SIG_STATUS, 0);
   writeout_li (ctx, item?"Yes":"No", "%s", _("Data verification succeeded"));
   enter_li (ctx);
 
   item = find_log_item (ctx, AUDIT_GOT_DATA, AUDIT_NEW_SIG);
   writeout_li (ctx, item? "Yes":"No", "%s", _("Data available"));
   if (!item)
     goto leave;
 
   item = find_log_item (ctx, AUDIT_NEW_SIG, 0);
   writeout_li (ctx, item? "Yes":"No", "%s", _("Signature available"));
   if (!item)
     goto leave;
 
   /* Print info about the used data hashing algorithms.  */
   for (idx=0, n_good=n_bad=0; idx < ctx->logused; idx++)
     {
       item = ctx->log + idx;
       if (item->event == AUDIT_NEW_SIG)
         break;
       else if (item->event == AUDIT_DATA_HASH_ALGO)
         n_good++;
       else if (item->event == AUDIT_BAD_DATA_HASH_ALGO)
         n_bad++;
     }
   item = find_log_item (ctx, AUDIT_DATA_HASHING, AUDIT_NEW_SIG);
   if (!item || item->err || !n_good)
     result = "No";
   else if (n_good && !n_bad)
     result = "Yes";
   else
     result = "Some";
   writeout_li (ctx, result, "%s", _("Parsing data succeeded"));
   if (n_good || n_bad)
     {
       for (idx=0; idx < ctx->logused; idx++)
         {
           item = ctx->log + idx;
           if (item->event == AUDIT_NEW_SIG)
             break;
           else if (item->event == AUDIT_DATA_HASH_ALGO)
             writeout_rem (ctx, _("data hash algorithm: %s"),
                           gcry_md_algo_name (item->intvalue));
           else if (item->event == AUDIT_BAD_DATA_HASH_ALGO)
             writeout_rem (ctx, _("bad data hash algorithm: %s"),
                           item->string? item->string:"?");
         }
     }
 
 
   /* Loop over all signatures.  */
   loopitem = find_log_item (ctx, AUDIT_NEW_SIG, 0);
   assert (loopitem);
   do
     {
       signo = loopitem->have_intvalue? loopitem->intvalue : -1;
 
       item = find_next_log_item (ctx, loopitem,
                                  AUDIT_SIG_STATUS, AUDIT_NEW_SIG);
       writeout_li (ctx, item? item->string:"?", _("Signature %d"), signo);
       item = find_next_log_item (ctx, loopitem,
                                  AUDIT_SIG_NAME, AUDIT_NEW_SIG);
       if (item)
         writeout_rem (ctx, "%s", item->string);
 
       item = find_next_log_item (ctx, loopitem,
                                  AUDIT_DATA_HASH_ALGO, AUDIT_NEW_SIG);
       if (item)
         writeout_rem (ctx, _("data hash algorithm: %s"),
                       gcry_md_algo_name (item->intvalue));
       item = find_next_log_item (ctx, loopitem,
                                  AUDIT_ATTR_HASH_ALGO, AUDIT_NEW_SIG);
       if (item)
         writeout_rem (ctx, _("attr hash algorithm: %s"),
                       gcry_md_algo_name (item->intvalue));
 
       enter_li (ctx);
 
       /* List the certificate chain.  */
       list_certchain (ctx, loopitem, AUDIT_NEW_SIG);
 
       /* Show the result of the chain validation.  */
       item = find_next_log_item (ctx, loopitem,
                                  AUDIT_CHAIN_STATUS, AUDIT_NEW_SIG);
       if (item && item->have_err)
         {
           writeout_li (ctx, item->err? "No":"Yes",
                        _("Certificate chain valid"));
           if (item->err)
             writeout_rem (ctx, "%s", gpg_strerror (item->err));
         }
 
       /* Show whether the root certificate is fine.  */
       item = find_next_log_item (ctx, loopitem,
                                  AUDIT_ROOT_TRUSTED, AUDIT_CHAIN_STATUS);
       if (item)
         {
           writeout_li (ctx, item->err?"No":"Yes", "%s",
                        _("Root certificate trustworthy"));
           if (item->err)
             {
               add_helptag (ctx, "gpgsm.root-cert-not-trusted");
               writeout_rem (ctx, "%s", gpg_strerror (item->err));
               list_cert (ctx, item->cert, 0);
             }
         }
 
       /* Show result of the CRL/OCSP check.  */
       item = find_next_log_item (ctx, loopitem,
                                  AUDIT_CRL_CHECK, AUDIT_NEW_SIG);
       if (item)
         {
           const char *ok;
           switch (gpg_err_code (item->err))
             {
             case 0:                    ok = "good"; break;
+            case GPG_ERR_TRUE:         ok = "n/a";  break;
             case GPG_ERR_CERT_REVOKED: ok = "bad"; break;
             case GPG_ERR_NOT_ENABLED:  ok = "disabled"; break;
             case GPG_ERR_NO_CRL_KNOWN:
               ok = _("no CRL found for certificate");
               break;
             case GPG_ERR_CRL_TOO_OLD:
               ok = _("the available CRL is too old");
               break;
             default: ok = gpg_strerror (item->err); break;
             }
 
           writeout_li (ctx, ok, "%s", _("CRL/OCSP check of certificates"));
           if (item->err
               && gpg_err_code (item->err) != GPG_ERR_CERT_REVOKED
               && gpg_err_code (item->err) != GPG_ERR_NOT_ENABLED)
             add_helptag (ctx, "gpgsm.crl-problem");
         }
 
       leave_li (ctx);
     }
   while ((loopitem = find_next_log_item (ctx, loopitem, AUDIT_NEW_SIG, 0)));
 
 
  leave:
   /* Always list the certificates stored in the signature.  */
   item = NULL;
   count = 0;
   while ( ((item = find_next_log_item (ctx, item,
                                        AUDIT_SAVE_CERT, AUDIT_NEW_SIG))))
     count++;
   snprintf (numbuf, sizeof numbuf, "%d", count);
   writeout_li (ctx, numbuf, _("Included certificates"));
   item = NULL;
   while ( ((item = find_next_log_item (ctx, item,
                                        AUDIT_SAVE_CERT, AUDIT_NEW_SIG))))
     {
       char *name = get_cert_name (item->cert);
       writeout_rem (ctx, "%s", name);
       xfree (name);
       enter_li (ctx);
       for (idx=0; (name = get_cert_subject (item->cert, idx)); idx++)
         {
           writeout_rem (ctx, "%s", name);
           xfree (name);
         }
       leave_li (ctx);
     }
   leave_li (ctx);
 }
 
 
 
 
 /* Print the formatted audit result.    THIS IS WORK IN PROGRESS.  */
 void
 audit_print_result (audit_ctx_t ctx, estream_t out, int use_html)
 {
   int idx;
   size_t n;
   log_item_t item;
   helptag_t helptag;
   const char *s;
   int show_raw = 0;
   char *orig_codeset;
 
   if (!ctx)
     return;
 
   orig_codeset = i18n_switchto_utf8 ();
 
   /* We use an environment variable to include some debug info in the
      log.  */
   if ((s = getenv ("gnupg_debug_audit")))
     show_raw = 1;
 
   assert (!ctx->outstream);
   ctx->outstream = out;
   ctx->use_html = use_html;
   ctx->indentlevel = 0;
   clear_helptags (ctx);
 
   if (use_html)
     es_fputs ("<div class=\"" GNUPG_NAME "AuditLog\">\n", ctx->outstream);
 
   if (!ctx->log || !ctx->logused)
     {
       writeout_para (ctx, _("No audit log entries."));
       goto leave;
     }
 
   if (show_raw)
     {
       int maxlen;
 
       for (idx=0,maxlen=0; idx < DIM (eventstr_msgidx); idx++)
         {
           n = strlen (eventstr_msgstr + eventstr_msgidx[idx]);
           if (n > maxlen)
             maxlen = n;
         }
 
       if (use_html)
         es_fputs ("<pre>\n", out);
       for (idx=0; idx < ctx->logused; idx++)
         {
           es_fprintf (out, "log: %-*s",
                       maxlen, event2str (ctx->log[idx].event));
           if (ctx->log[idx].have_intvalue)
             es_fprintf (out, " i=%d", ctx->log[idx].intvalue);
           if (ctx->log[idx].string)
             {
               es_fputs (" s='", out);
               writeout (ctx, ctx->log[idx].string);
               es_fputs ("'", out);
             }
           if (ctx->log[idx].cert)
             es_fprintf (out, " has_cert");
           if (ctx->log[idx].have_err)
             {
               es_fputs (" err='", out);
               writeout (ctx, gpg_strerror (ctx->log[idx].err));
               es_fputs ("'", out);
             }
           es_fputs ("\n", out);
         }
       if (use_html)
         es_fputs ("</pre>\n", out);
       else
         es_fputs ("\n", out);
     }
 
   enter_li (ctx);
   switch (ctx->type)
     {
     case AUDIT_TYPE_NONE:
       writeout_li (ctx, NULL, _("Unknown operation"));
       break;
     case AUDIT_TYPE_ENCRYPT:
       proc_type_encrypt (ctx);
       break;
     case AUDIT_TYPE_SIGN:
       proc_type_sign (ctx);
       break;
     case AUDIT_TYPE_DECRYPT:
       proc_type_decrypt (ctx);
       break;
     case AUDIT_TYPE_VERIFY:
       proc_type_verify (ctx);
       break;
     }
   item = find_log_item (ctx, AUDIT_AGENT_READY, 0);
   if (item && item->have_err)
     {
       writeout_li (ctx, item->err? "No":"Yes", "%s", _("Gpg-Agent usable"));
       if (item->err)
         {
           writeout_rem (ctx, "%s", gpg_strerror (item->err));
           add_helptag (ctx, "gnupg.agent-problem");
         }
     }
   item = find_log_item (ctx, AUDIT_DIRMNGR_READY, 0);
   if (item && item->have_err)
     {
       writeout_li (ctx, item->err? "No":"Yes", "%s", _("Dirmngr usable"));
       if (item->err)
         {
           writeout_rem (ctx, "%s", gpg_strerror (item->err));
           add_helptag (ctx, "gnupg.dirmngr-problem");
         }
     }
   leave_li (ctx);
 
 
   /* Show the help from the collected help tags.  */
   if (ctx->helptags)
     {
       if (use_html)
         {
           es_fputs ("<hr/>\n", ctx->outstream);
           if (ctx->helptags->next)
             es_fputs ("<ul>\n", ctx->outstream);
         }
       else
         es_fputs ("\n\n", ctx->outstream);
     }
   for (helptag = ctx->helptags; helptag; helptag = helptag->next)
     {
       char *text;
 
       if (use_html && ctx->helptags->next)
         es_fputs ("<li>\n", ctx->outstream);
 
       text = gnupg_get_help_string (helptag->name, 0);
       if (text)
         {
           writeout_para (ctx, "%s", text);
           xfree (text);
         }
       else
         writeout_para (ctx, _("No help available for '%s'."), helptag->name);
       if (use_html && ctx->helptags->next)
         es_fputs ("</li>\n", ctx->outstream);
       if (helptag->next)
         es_fputs ("\n", ctx->outstream);
     }
   if (use_html && ctx->helptags && ctx->helptags->next)
     es_fputs ("</ul>\n", ctx->outstream);
 
  leave:
   if (use_html)
     es_fputs ("</div>\n", ctx->outstream);
   ctx->outstream = NULL;
   ctx->use_html = 0;
   clear_helptags (ctx);
   i18n_switchback (orig_codeset);
 }
diff --git a/doc/gpgsm.texi b/doc/gpgsm.texi
index eb3036881..5e9a1b181 100644
--- a/doc/gpgsm.texi
+++ b/doc/gpgsm.texi
@@ -1,1635 +1,1643 @@
 @c Copyright (C) 2002 Free Software Foundation, Inc.
 @c This is part of the GnuPG manual.
 @c For copying conditions, see the file gnupg.texi.
 
 @include defs.inc
 
 @node Invoking GPGSM
 @chapter Invoking GPGSM
 @cindex GPGSM command options
 @cindex command options
 @cindex options, GPGSM command
 
 @manpage gpgsm.1
 @ifset manverb
 .B gpgsm
 \- CMS encryption and signing tool
 @end ifset
 
 @mansect synopsis
 @ifset manverb
 .B  gpgsm
 .RB [ \-\-homedir
 .IR dir ]
 .RB [ \-\-options
 .IR file ]
 .RI [ options ]
 .I command
 .RI [ args ]
 @end ifset
 
 
 @mansect description
 @command{gpgsm} is a tool similar to @command{gpg} to provide digital
 encryption and signing services on X.509 certificates and the CMS
 protocol.  It is mainly used as a backend for S/MIME mail processing.
 @command{gpgsm} includes a full featured certificate management and
 complies with all rules defined for the German Sphinx project.
 
 @manpause
 @xref{Option Index}, for an index to @command{GPGSM}'s commands and options.
 @mancont
 
 @menu
 * GPGSM Commands::        List of all commands.
 * GPGSM Options::         List of all options.
 * GPGSM Configuration::   Configuration files.
 * GPGSM Examples::        Some usage examples.
 
 Developer information:
 * Unattended Usage::      Using @command{gpgsm} from other programs.
 * GPGSM Protocol::        The protocol the server mode uses.
 @end menu
 
 @c *******************************************
 @c ***************            ****************
 @c ***************  COMMANDS  ****************
 @c ***************            ****************
 @c *******************************************
 @mansect commands
 @node GPGSM Commands
 @section Commands
 
 Commands are not distinguished from options except for the fact that
 only one command is allowed.
 
 @menu
 * General GPGSM Commands::        Commands not specific to the functionality.
 * Operational GPGSM Commands::    Commands to select the type of operation.
 * Certificate Management::        How to manage certificates.
 @end menu
 
 
 @c *******************************************
 @c **********  GENERAL COMMANDS  *************
 @c *******************************************
 @node General GPGSM Commands
 @subsection Commands not specific to the function
 
 @table @gnupgtabopt
 @item --version
 @opindex version
 Print the program version and licensing information.  Note that you
 cannot abbreviate this command.
 
 @item --help, -h
 @opindex help
 Print a usage message summarizing the most useful command-line options.
 Note that you cannot abbreviate this command.
 
 @item --warranty
 @opindex warranty
 Print warranty information.  Note that you cannot abbreviate this
 command.
 
 @item --dump-options
 @opindex dump-options
 Print a list of all available options and commands.  Note that you cannot
 abbreviate this command.
 @end table
 
 
 @c *******************************************
 @c ********  OPERATIONAL COMMANDS  ***********
 @c *******************************************
 @node Operational GPGSM Commands
 @subsection Commands to select the type of operation
 
 @table @gnupgtabopt
 @item --encrypt
 @opindex encrypt
 Perform an encryption.  The keys the data is encrypted to must be set
 using the option @option{--recipient}.
 
 @item --decrypt
 @opindex decrypt
 Perform a decryption; the type of input is automatically determined.  It
 may either be in binary form or PEM encoded; automatic determination of
 base-64 encoding is not done.
 
 @item --sign
 @opindex sign
 Create a digital signature.  The key used is either the fist one found
 in the keybox or those set with the @option{--local-user} option.
 
 @item --verify
 @opindex verify
 Check a signature file for validity.  Depending on the arguments a
 detached signature may also be checked.
 
 @item --server
 @opindex server
 Run in server mode and wait for commands on the @code{stdin}.
 
 @item --call-dirmngr @var{command} [@var{args}]
 @opindex call-dirmngr
 Behave as a Dirmngr client issuing the request @var{command} with the
 optional list of @var{args}.  The output of the Dirmngr is printed
 stdout.  Please note that file names given as arguments should have an
 absolute file name (i.e. commencing with @code{/}) because they are
 passed verbatim to the Dirmngr and the working directory of the
 Dirmngr might not be the same as the one of this client.  Currently it
 is not possible to pass data via stdin to the Dirmngr.  @var{command}
 should not contain spaces.
 
 This is command is required for certain maintaining tasks of the dirmngr
 where a dirmngr must be able to call back to @command{gpgsm}.  See the Dirmngr
 manual for details.
 
 @item --call-protect-tool @var{arguments}
 @opindex call-protect-tool
 Certain maintenance operations are done by an external program call
 @command{gpg-protect-tool}; this is usually not installed in a directory
 listed in the PATH variable.  This command provides a simple wrapper to
 access this tool.  @var{arguments} are passed verbatim to this command;
 use @samp{--help} to get a list of supported operations.
 
 
 @end table
 
 
 @c *******************************************
 @c *******  CERTIFICATE MANAGEMENT  **********
 @c *******************************************
 @node Certificate Management
 @subsection How to manage the certificates and keys
 
 @table @gnupgtabopt
 @item --generate-key
 @opindex generate-key
 @itemx --gen-key
 @opindex gen-key
 This command allows the creation of a certificate signing request or a
 self-signed certificate.  It is commonly used along with the
 @option{--output} option to save the created CSR or certificate into a
 file.  If used with the @option{--batch} a parameter file is used to
 create the CSR or certificate and it is further possible to create
 non-self-signed certificates.
 
 @item --list-keys
 @itemx -k
 @opindex list-keys
 List all available certificates stored in the local key database.
 Note that the displayed data might be reformatted for better human
 readability and illegal characters are replaced by safe substitutes.
 
 @item --list-secret-keys
 @itemx -K
 @opindex list-secret-keys
 List all available certificates for which a corresponding a secret key
 is available.
 
 @item --list-external-keys @var{pattern}
 @opindex list-keys
 List certificates matching @var{pattern} using an external server.  This
 utilizes the @code{dirmngr} service.
 
 @item --list-chain
 @opindex list-chain
 Same as @option{--list-keys} but also prints all keys making up the chain.
 
 
 @item --dump-cert
 @itemx --dump-keys
 @opindex dump-cert
 @opindex dump-keys
 List all available certificates stored in the local key database using a
 format useful mainly for debugging.
 
 @item --dump-chain
 @opindex dump-chain
 Same as @option{--dump-keys} but also prints all keys making up the chain.
 
 @item --dump-secret-keys
 @opindex dump-secret-keys
 List all available certificates for which a corresponding a secret key
 is available using a format useful mainly for debugging.
 
 @item --dump-external-keys @var{pattern}
 @opindex dump-external-keys
 List certificates matching @var{pattern} using an external server.
 This utilizes the @code{dirmngr} service.  It uses a format useful
 mainly for debugging.
 
 @item --keydb-clear-some-cert-flags
 @opindex keydb-clear-some-cert-flags
 This is a debugging aid to reset certain flags in the key database
 which are used to cache certain certificate stati.  It is especially
 useful if a bad CRL or a weird running OCSP responder did accidentally
 revoke certificate.  There is no security issue with this command
 because @command{gpgsm} always make sure that the validity of a certificate is
 checked right before it is used.
 
 @item --delete-keys @var{pattern}
 @opindex delete-keys
 Delete the keys matching @var{pattern}.  Note that there is no command
 to delete the secret part of the key directly.  In case you need to do
 this, you should run the command @code{gpgsm --dump-secret-keys KEYID}
 before you delete the key, copy the string of hex-digits in the
 ``keygrip'' line and delete the file consisting of these hex-digits
 and the suffix @code{.key} from the @file{private-keys-v1.d} directory
 below our GnuPG home directory (usually @file{~/.gnupg}).
 
 @item --export [@var{pattern}]
 @opindex export
 Export all certificates stored in the Keybox or those specified by the
 optional @var{pattern}. Those pattern consist of a list of user ids
 (@pxref{how-to-specify-a-user-id}).  When used along with the
 @option{--armor} option a few informational lines are prepended before
 each block.  There is one limitation: As there is no commonly agreed
 upon way to pack more than one certificate into an ASN.1 structure,
 the binary export (i.e. without using @option{armor}) works only for
 the export of one certificate.  Thus it is required to specify a
 @var{pattern} which yields exactly one certificate.  Ephemeral
 certificate are only exported if all @var{pattern} are given as
 fingerprints or keygrips.
 
 @item --export-secret-key-p12 @var{key-id}
 @opindex export-secret-key-p12
 Export the private key and the certificate identified by @var{key-id}
 using the PKCS#12 format.  When used with the @code{--armor} option a few
 informational lines are prepended to the output.  Note, that the PKCS#12
 format is not very secure and proper transport security should be used
 to convey the exported key.  (@xref{option --p12-charset}.)
 
 @item --export-secret-key-p8 @var{key-id}
 @itemx --export-secret-key-raw @var{key-id}
 @opindex export-secret-key-p8
 @opindex export-secret-key-raw
 Export the private key of the certificate identified by @var{key-id}
 with any encryption stripped.  The @code{...-raw} command exports in
 PKCS#1 format; the @code{...-p8} command exports in PKCS#8 format.
 When used with the @code{--armor} option a few informational lines are
 prepended to the output.  These commands are useful to prepare a key
 for use on a TLS server.
 
 @item --import [@var{files}]
 @opindex import
 Import the certificates from the PEM or binary encoded files as well as
 from signed-only messages.  This command may also be used to import a
 secret key from a PKCS#12 file.
 
 @item --learn-card
 @opindex learn-card
 Read information about the private keys from the smartcard and import
 the certificates from there.  This command utilizes the @command{gpg-agent}
 and in turn the @command{scdaemon}.
 
 @item --change-passphrase @var{user_id}
 @opindex change-passphrase
 @itemx --passwd @var{user_id}
 @opindex passwd
 Change the passphrase of the private key belonging to the certificate
 specified as @var{user_id}.  Note, that changing the passphrase/PIN of a
 smartcard is not yet supported.
 
 @end table
 
 
 @c *******************************************
 @c ***************            ****************
 @c ***************  OPTIONS   ****************
 @c ***************            ****************
 @c *******************************************
 @mansect options
 @node GPGSM Options
 @section Option Summary
 
 @command{GPGSM} features a bunch of options to control the exact behaviour
 and to change the default configuration.
 
 @menu
 * Configuration Options::   How to change the configuration.
 * Certificate Options::     Certificate related options.
 * Input and Output::        Input and Output.
 * CMS Options::             How to change how the CMS is created.
 * Esoteric Options::        Doing things one usually do not want to do.
 @end menu
 
 
 @c *******************************************
 @c ********  CONFIGURATION OPTIONS  **********
 @c *******************************************
 @node Configuration Options
 @subsection How to change the configuration
 
 These options are used to change the configuration and are usually found
 in the option file.
 
 @table @gnupgtabopt
 
 @anchor{gpgsm-option --options}
 @item --options @var{file}
 @opindex options
 Reads configuration from @var{file} instead of from the default
 per-user configuration file.  The default configuration file is named
 @file{gpgsm.conf} and expected in the @file{.gnupg} directory directly
 below the home directory of the user.
 
 @include opt-homedir.texi
 
 
 @item -v
 @item --verbose
 @opindex v
 @opindex verbose
 Outputs additional information while running.
 You can increase the verbosity by giving several
 verbose commands to @command{gpgsm}, such as @samp{-vv}.
 
 @item --policy-file @var{filename}
 @opindex policy-file
 Change the default name of the policy file to @var{filename}.
 
 @item --agent-program @var{file}
 @opindex agent-program
 Specify an agent program to be used for secret key operations.  The
 default value is determined by running the command @command{gpgconf}.
 Note that the pipe symbol (@code{|}) is used for a regression test
 suite hack and may thus not be used in the file name.
 
 @item --dirmngr-program @var{file}
 @opindex dirmngr-program
 Specify a dirmngr program to be used for @acronym{CRL} checks.  The
 default value is @file{@value{BINDIR}/dirmngr}.
 
 @item --prefer-system-dirmngr
 @opindex prefer-system-dirmngr
 This option is obsolete and ignored.
 
 @item --disable-dirmngr
 Entirely disable the use of the Dirmngr.
 
 @item --no-autostart
 @opindex no-autostart
 Do not start the gpg-agent or the dirmngr if it has not yet been
 started and its service is required.  This option is mostly useful on
 machines where the connection to gpg-agent has been redirected to
 another machines.  If dirmngr is required on the remote machine, it
 may be started manually using @command{gpgconf --launch dirmngr}.
 
 @item --no-secmem-warning
 @opindex no-secmem-warning
 Do not print a warning when the so called "secure memory" cannot be used.
 
 @item --log-file @var{file}
 @opindex log-file
 When running in server mode, append all logging output to @var{file}.
 Use @file{socket://} to log to socket.
 
 @end table
 
 
 @c *******************************************
 @c ********  CERTIFICATE OPTIONS  ************
 @c *******************************************
 @node Certificate Options
 @subsection Certificate related options
 
 @table @gnupgtabopt
 
 @item  --enable-policy-checks
 @itemx --disable-policy-checks
 @opindex enable-policy-checks
 @opindex disable-policy-checks
 By default policy checks are enabled.  These options may be used to
 change it.
 
 @item  --enable-crl-checks
 @itemx --disable-crl-checks
 @opindex enable-crl-checks
 @opindex disable-crl-checks
 By default the @acronym{CRL} checks are enabled and the DirMngr is used
 to check for revoked certificates.  The disable option is most useful
 with an off-line network connection to suppress this check.
 
 @item  --enable-trusted-cert-crl-check
 @itemx --disable-trusted-cert-crl-check
 @opindex enable-trusted-cert-crl-check
 @opindex disable-trusted-cert-crl-check
 By default the @acronym{CRL} for trusted root certificates are checked
 like for any other certificates.  This allows a CA to revoke its own
 certificates voluntary without the need of putting all ever issued
 certificates into a CRL.  The disable option may be used to switch this
 extra check off.  Due to the caching done by the Dirmngr, there will not be
 any noticeable performance gain.  Note, that this also disables possible
 OCSP checks for trusted root certificates.  A more specific way of
 disabling this check is by adding the ``relax'' keyword to the root CA
 line of the @file{trustlist.txt}
 
 
 @item --force-crl-refresh
 @opindex force-crl-refresh
 Tell the dirmngr to reload the CRL for each request.  For better
 performance, the dirmngr will actually optimize this by suppressing
 the loading for short time intervals (e.g. 30 minutes). This option
 is useful to make sure that a fresh CRL is available for certificates
 hold in the keybox.  The suggested way of doing this is by using it
 along with the option @option{--with-validation} for a key listing
 command.  This option should not be used in a configuration file.
 
+@item --enable-issuer-based-crl-check
+@opindex enable-issuer-based-crl-check
+Run a CRL check even for certificates which do not have any CRL
+distribution point.  This requires that a suitable LDAP server has
+been configured in Dirmngr and that the CRL can be found using the
+issuer.  This option reverts to what GnuPG did up to version 2.2.20.
+This option is in general not useful.
+
 @item  --enable-ocsp
 @itemx --disable-ocsp
 @opindex enable-ocsp
 @opindex disable-ocsp
 By default @acronym{OCSP} checks are disabled.  The enable option may
 be used to enable OCSP checks via Dirmngr.  If @acronym{CRL} checks
 are also enabled, CRLs will be used as a fallback if for some reason an
 OCSP request will not succeed.  Note, that you have to allow OCSP
 requests in Dirmngr's configuration too (option
 @option{--allow-ocsp}) and configure Dirmngr properly.  If you do not do
 so you will get the error code @samp{Not supported}.
 
 @item --auto-issuer-key-retrieve
 @opindex auto-issuer-key-retrieve
 If a required certificate is missing while validating the chain of
 certificates, try to load that certificate from an external location.
 This usually means that Dirmngr is employed to search for the
 certificate.  Note that this option makes a "web bug" like behavior
 possible.  LDAP server operators can see which keys you request, so by
 sending you a message signed by a brand new key (which you naturally
 will not have on your local keybox), the operator can tell both your IP
 address and the time when you verified the signature.
 
 
 @anchor{gpgsm-option --validation-model}
 @item --validation-model @var{name}
 @opindex validation-model
 This option changes the default validation model.  The only possible
 values are "shell" (which is the default), "chain" which forces the
 use of the chain model and "steed" for a new simplified model.  The
 chain model is also used if an option in the @file{trustlist.txt} or
 an attribute of the certificate requests it.  However the standard
 model (shell) is in that case always tried first.
 
 @item --ignore-cert-extension @var{oid}
 @opindex ignore-cert-extension
 Add @var{oid} to the list of ignored certificate extensions.  The
 @var{oid} is expected to be in dotted decimal form, like
 @code{2.5.29.3}.  This option may be used more than once.  Critical
 flagged certificate extensions matching one of the OIDs in the list
 are treated as if they are actually handled and thus the certificate
 will not be rejected due to an unknown critical extension.  Use this
 option with care because extensions are usually flagged as critical
 for a reason.
 
 @end table
 
 @c *******************************************
 @c ***********  INPUT AND OUTPUT  ************
 @c *******************************************
 @node Input and Output
 @subsection Input and Output
 
 @table @gnupgtabopt
 @item --armor
 @itemx -a
 @opindex armor
 Create PEM encoded output.  Default is binary output.
 
 @item --base64
 @opindex base64
 Create Base-64 encoded output; i.e. PEM without the header lines.
 
 @item --assume-armor
 @opindex assume-armor
 Assume the input data is PEM encoded.  Default is to autodetect the
 encoding but this is may fail.
 
 @item --assume-base64
 @opindex assume-base64
 Assume the input data is plain base-64 encoded.
 
 @item --assume-binary
 @opindex assume-binary
 Assume the input data is binary encoded.
 
 @anchor{option --p12-charset}
 @item --p12-charset @var{name}
 @opindex p12-charset
 @command{gpgsm} uses the UTF-8 encoding when encoding passphrases for
 PKCS#12 files.  This option may be used to force the passphrase to be
 encoded in the specified encoding @var{name}.  This is useful if the
 application used to import the key uses a different encoding and thus
 will not be able to import a file generated by @command{gpgsm}.  Commonly
 used values for @var{name} are @code{Latin1} and @code{CP850}.  Note
 that @command{gpgsm} itself automagically imports any file with a
 passphrase encoded to the most commonly used encodings.
 
 
 @item --default-key @var{user_id}
 @opindex default-key
 Use @var{user_id} as the standard key for signing.  This key is used if
 no other key has been defined as a signing key.  Note, that the first
 @option{--local-users} option also sets this key if it has not yet been
 set; however @option{--default-key} always overrides this.
 
 
 @item --local-user @var{user_id}
 @item -u @var{user_id}
 @opindex local-user
 Set the user(s) to be used for signing.  The default is the first
 secret key found in the database.
 
 
 @item --recipient @var{name}
 @itemx -r
 @opindex recipient
 Encrypt to the user id @var{name}.  There are several ways a user id
 may be given (@pxref{how-to-specify-a-user-id}).
 
 
 @item --output @var{file}
 @itemx -o @var{file}
 @opindex output
 Write output to @var{file}.  The default is to write it to stdout.
 
 
 @anchor{gpgsm-option --with-key-data}
 @item --with-key-data
 @opindex with-key-data
 Displays extra information with the @code{--list-keys} commands.  Especially
 a line tagged @code{grp} is printed which tells you the keygrip of a
 key.  This string is for example used as the file name of the
 secret key.  Implies @code{--with-colons}.
 
 @anchor{gpgsm-option --with-validation}
 @item --with-validation
 @opindex with-validation
 When doing a key listing, do a full validation check for each key and
 print the result.  This is usually a slow operation because it
 requires a CRL lookup and other operations.
 
 When used along with @option{--import}, a validation of the certificate to
 import is done and only imported if it succeeds the test.  Note that
 this does not affect an already available certificate in the DB.
 This option is therefore useful to simply verify a certificate.
 
 
 @item --with-md5-fingerprint
 For standard key listings, also print the MD5 fingerprint of the
 certificate.
 
 @item --with-keygrip
 Include the keygrip in standard key listings.  Note that the keygrip is
 always listed in @option{--with-colons} mode.
 
 @item --with-secret
 @opindex with-secret
 Include info about the presence of a secret key in public key listings
 done with @code{--with-colons}.
 
 @end table
 
 @c *******************************************
 @c *************  CMS OPTIONS  ***************
 @c *******************************************
 @node CMS Options
 @subsection How to change how the CMS is created
 
 @table @gnupgtabopt
 @item --include-certs @var{n}
 @opindex include-certs
 Using @var{n} of -2 includes all certificate except for the root cert,
 -1 includes all certs, 0 does not include any certs, 1 includes only the
 signers cert and all other positive values include up to @var{n}
 certificates starting with the signer cert.  The default is -2.
 
 @item --cipher-algo @var{oid}
 @opindex cipher-algo
 Use the cipher algorithm with the ASN.1 object identifier @var{oid} for
 encryption.  For convenience the strings @code{3DES}, @code{AES} and
 @code{AES256} may be used instead of their OIDs.  The default is
 @code{AES} (2.16.840.1.101.3.4.1.2).
 
 @item --digest-algo @code{name}
 Use @code{name} as the message digest algorithm.  Usually this
 algorithm is deduced from the respective signing certificate.  This
 option forces the use of the given algorithm and may lead to severe
 interoperability problems.
 
 @end table
 
 
 
 @c *******************************************
 @c ********  ESOTERIC OPTIONS  ***************
 @c *******************************************
 @node Esoteric Options
 @subsection Doing things one usually do not want to do
 
 
 @table @gnupgtabopt
 
 @item --extra-digest-algo @var{name}
 @opindex extra-digest-algo
 Sometimes signatures are broken in that they announce a different digest
 algorithm than actually used.  @command{gpgsm} uses a one-pass data
 processing model and thus needs to rely on the announced digest
 algorithms to properly hash the data.  As a workaround this option may
 be used to tell @command{gpgsm} to also hash the data using the algorithm
 @var{name}; this slows processing down a little bit but allows verification of
 such broken signatures.  If @command{gpgsm} prints an error like
 ``digest algo 8 has not been enabled'' you may want to try this option,
 with @samp{SHA256} for @var{name}.
 
 
 @item --faked-system-time @var{epoch}
 @opindex faked-system-time
 This option is only useful for testing; it sets the system time back or
 forth to @var{epoch} which is the number of seconds elapsed since the year
 1970.  Alternatively @var{epoch} may be given as a full ISO time string
 (e.g. "20070924T154812").
 
 @item --with-ephemeral-keys
 @opindex with-ephemeral-keys
 Include ephemeral flagged keys in the output of key listings.  Note
 that they are included anyway if the key specification for a listing
 is given as fingerprint or keygrip.
 
 @item --debug-level @var{level}
 @opindex debug-level
 Select the debug level for investigating problems. @var{level} may be
 a numeric value or by a keyword:
 
 @table @code
 @item none
 No debugging at all.  A value of less than 1 may be used instead of
 the keyword.
 @item basic
 Some basic debug messages.  A value between 1 and 2 may be used
 instead of the keyword.
 @item advanced
 More verbose debug messages.  A value between 3 and 5 may be used
 instead of the keyword.
 @item expert
 Even more detailed messages.  A value between 6 and 8 may be used
 instead of the keyword.
 @item guru
 All of the debug messages you can get. A value greater than 8 may be
 used instead of the keyword.  The creation of hash tracing files is
 only enabled if the keyword is used.
 @end table
 
 How these messages are mapped to the actual debugging flags is not
 specified and may change with newer releases of this program. They are
 however carefully selected to best aid in debugging.
 
 @item --debug @var{flags}
 @opindex debug
 This option is only useful for debugging and the behaviour may change
 at any time without notice; using @code{--debug-levels} is the
 preferred method to select the debug verbosity.  FLAGS are bit encoded
 and may be given in usual C-Syntax. The currently defined bits are:
 
 @table @code
 @item 0  (1)
 X.509 or OpenPGP protocol related data
 @item 1  (2)
 values of big number integers
 @item 2  (4)
 low level crypto operations
 @item 5  (32)
 memory allocation
 @item 6  (64)
 caching
 @item 7  (128)
 show memory statistics
 @item 9  (512)
 write hashed data to files named @code{dbgmd-000*}
 @item 10 (1024)
 trace Assuan protocol
 @end table
 
 Note, that all flags set using this option may get overridden by
 @code{--debug-level}.
 
 @item --debug-all
 @opindex debug-all
 Same as @code{--debug=0xffffffff}
 
 @item --debug-allow-core-dump
 @opindex debug-allow-core-dump
 Usually @command{gpgsm} tries to avoid dumping core by well written code and by
 disabling core dumps for security reasons.  However, bugs are pretty
 durable beasts and to squash them it is sometimes useful to have a core
 dump.  This option enables core dumps unless the Bad Thing happened
 before the option parsing.
 
 @item --debug-no-chain-validation
 @opindex debug-no-chain-validation
 This is actually not a debugging option but only useful as such.  It
 lets @command{gpgsm} bypass all certificate chain validation checks.
 
 @item --debug-ignore-expiration
 @opindex debug-ignore-expiration
 This is actually not a debugging option but only useful as such.  It
 lets @command{gpgsm} ignore all notAfter dates, this is used by the regression
 tests.
 
 @item --passphrase-fd @code{n}
 @opindex passphrase-fd
 Read the passphrase from file descriptor @code{n}. Only the first line
 will be read from file descriptor @code{n}. If you use 0 for @code{n},
 the passphrase will be read from STDIN. This can only be used if only
 one passphrase is supplied.
 
 Note that this passphrase is only used if the option @option{--batch}
 has also been given.
 
 @item --pinentry-mode @code{mode}
 @opindex pinentry-mode
 Set the pinentry mode to @code{mode}.  Allowed values for @code{mode}
 are:
 @table @asis
   @item default
   Use the default of the agent, which is @code{ask}.
   @item ask
   Force the use of the Pinentry.
   @item cancel
   Emulate use of Pinentry's cancel button.
   @item error
   Return a Pinentry error (``No Pinentry'').
   @item loopback
   Redirect Pinentry queries to the caller.  Note that in contrast to
   Pinentry the user is not prompted again if he enters a bad password.
 @end table
 
 @item --request-origin @var{origin}
 @opindex request-origin
 Tell gpgsm to assume that the operation ultimately originated at
 @var{origin}.  Depending on the origin certain restrictions are applied
 and the Pinentry may include an extra note on the origin.  Supported
 values for @var{origin} are: @code{local} which is the default,
 @code{remote} to indicate a remote origin or @code{browser} for an
 operation requested by a web browser.
 
 @item --no-common-certs-import
 @opindex no-common-certs-import
 Suppress the import of common certificates on keybox creation.
 
 @end table
 
 All the long options may also be given in the configuration file after
 stripping off the two leading dashes.
 
 @c *******************************************
 @c ***************            ****************
 @c ***************  USER ID   ****************
 @c ***************            ****************
 @c *******************************************
 @mansect how to specify a user id
 @ifset isman
 @include specify-user-id.texi
 @end ifset
 
 @c *******************************************
 @c ***************            ****************
 @c ***************   FILES    ****************
 @c ***************            ****************
 @c *******************************************
 @mansect files
 @node GPGSM Configuration
 @section Configuration files
 
 There are a few configuration files to control certain aspects of
 @command{gpgsm}'s operation. Unless noted, they are expected in the
 current home directory (@pxref{option --homedir}).
 
 @table @file
 
 @item gpgsm.conf
 @efindex gpgsm.conf
 This is the standard configuration file read by @command{gpgsm} on
 startup.  It may contain any valid long option; the leading two dashes
 may not be entered and the option may not be abbreviated.  This default
 name may be changed on the command line (@pxref{gpgsm-option --options}).
 You should backup this file.
 
 
 @item policies.txt
 @efindex policies.txt
 This is a list of allowed CA policies.  This file should list the
 object identifiers of the policies line by line.  Empty lines and
 lines starting with a hash mark are ignored.  Policies missing in this
 file and not marked as critical in the certificate will print only a
 warning; certificates with policies marked as critical and not listed
 in this file will fail the signature verification.  You should backup
 this file.
 
 For example, to allow only the policy 2.289.9.9, the file should look
 like this:
 
 @c man:.RS
 @example
 # Allowed policies
 2.289.9.9
 @end example
 @c man:.RE
 
 @item qualified.txt
 @efindex qualified.txt
 This is the list of root certificates used for qualified certificates.
 They are defined as certificates capable of creating legally binding
 signatures in the same way as handwritten signatures are.  Comments
 start with a hash mark and empty lines are ignored.  Lines do have a
 length limit but this is not a serious limitation as the format of the
 entries is fixed and checked by @command{gpgsm}: A non-comment line starts with
 optional whitespace, followed by exactly 40 hex characters, white space
 and a lowercased 2 letter country code.  Additional data delimited with
 by a white space is current ignored but might late be used for other
 purposes.
 
 Note that even if a certificate is listed in this file, this does not
 mean that the certificate is trusted; in general the certificates listed
 in this file need to be listed also in @file{trustlist.txt}.
 
 This is a global file an installed in the data directory
 (e.g. @file{@value{DATADIR}/qualified.txt}).  GnuPG installs a suitable
 file with root certificates as used in Germany.  As new Root-CA
 certificates may be issued over time, these entries may need to be
 updated; new distributions of this software should come with an updated
 list but it is still the responsibility of the Administrator to check
 that this list is correct.
 
 Every time @command{gpgsm} uses a certificate for signing or verification
 this file will be consulted to check whether the certificate under
 question has ultimately been issued by one of these CAs.  If this is the
 case the user will be informed that the verified signature represents a
 legally binding (``qualified'') signature.  When creating a signature
 using such a certificate an extra prompt will be issued to let the user
 confirm that such a legally binding signature shall really be created.
 
 Because this software has not yet been approved for use with such
 certificates, appropriate notices will be shown to indicate this fact.
 
 @item help.txt
 @efindex help.txt
 This is plain text file with a few help entries used with
 @command{pinentry} as well as a large list of help items for
 @command{gpg} and @command{gpgsm}.  The standard file has English help
 texts; to install localized versions use filenames like @file{help.LL.txt}
 with LL denoting the locale.  GnuPG comes with a set of predefined help
 files in the data directory (e.g. @file{@value{DATADIR}/gnupg/help.de.txt})
 and allows overriding of any help item by help files stored in the
 system configuration directory (e.g. @file{@value{SYSCONFDIR}/help.de.txt}).
 For a reference of the help file's syntax, please see the installed
 @file{help.txt} file.
 
 
 @item com-certs.pem
 @efindex com-certs.pem
 This file is a collection of common certificates used to populated a
 newly created @file{pubring.kbx}.  An administrator may replace this
 file with a custom one.  The format is a concatenation of PEM encoded
 X.509 certificates.  This global file is installed in the data directory
 (e.g. @file{@value{DATADIR}/com-certs.pem}).
 
 @end table
 
 @c man:.RE
 Note that on larger installations, it is useful to put predefined files
 into the directory @file{/etc/skel/.gnupg/} so that newly created users
 start up with a working configuration.  For existing users a small
 helper script is provided to create these files (@pxref{addgnupghome}).
 
 For internal purposes @command{gpgsm} creates and maintains a few other files;
 they all live in the current home directory (@pxref{option
 --homedir}).  Only @command{gpgsm} may modify these files.
 
 
 @table @file
 @item pubring.kbx
 @efindex pubring.kbx
 This a database file storing the certificates as well as meta
 information.  For debugging purposes the tool @command{kbxutil} may be
 used to show the internal structure of this file.  You should backup
 this file.
 
 @item random_seed
 @efindex random_seed
 This content of this file is used to maintain the internal state of the
 random number generator across invocations.  The same file is used by
 other programs of this software too.
 
 @item S.gpg-agent
 @efindex S.gpg-agent
 If this file exists
 @command{gpgsm} will first try to connect to this socket for
 accessing @command{gpg-agent} before starting a new @command{gpg-agent}
 instance.  Under Windows this socket (which in reality be a plain file
 describing a regular TCP listening port) is the standard way of
 connecting the @command{gpg-agent}.
 
 @end table
 
 
 @c *******************************************
 @c ***************            ****************
 @c ***************  EXAMPLES  ****************
 @c ***************            ****************
 @c *******************************************
 @mansect examples
 @node GPGSM Examples
 @section Examples
 
 @example
 $ gpgsm -er goo@@bar.net <plaintext >ciphertext
 @end example
 
 
 @c *******************************************
 @c ***************              **************
 @c ***************  UNATTENDED  **************
 @c ***************              **************
 @c *******************************************
 @manpause
 @node Unattended Usage
 @section Unattended Usage
 
 @command{gpgsm} is often used as a backend engine by other software.  To help
 with this a machine interface has been defined to have an unambiguous
 way to do this.  This is most likely used with the @code{--server} command
 but may also be used in the standard operation mode by using the
 @code{--status-fd} option.
 
 @menu
 * Automated signature checking::  Automated signature checking.
 * CSR and certificate creation::  CSR and certificate creation.
 @end menu
 
 @node Automated signature checking
 @subsection Automated signature checking
 
 It is very important to understand the semantics used with signature
 verification.  Checking a signature is not as simple as it may sound and
 so the operation is a bit complicated.  In most cases it is required
 to look at several status lines.  Here is a table of all cases a signed
 message may have:
 
 @table @asis
 @item The signature is valid
 This does mean that the signature has been successfully verified, the
 certificates are all sane.  However there are two subcases with
 important information:  One of the certificates may have expired or a
 signature of a message itself as expired.  It is a sound practise to
 consider such a signature still as valid but additional information
 should be displayed.  Depending on the subcase @command{gpgsm} will issue
 these status codes:
   @table @asis
   @item signature valid and nothing did expire
   @code{GOODSIG}, @code{VALIDSIG}, @code{TRUST_FULLY}
   @item signature valid but at least one certificate has expired
   @code{EXPKEYSIG}, @code{VALIDSIG}, @code{TRUST_FULLY}
   @item signature valid but expired
   @code{EXPSIG}, @code{VALIDSIG}, @code{TRUST_FULLY}
   Note, that this case is currently not implemented.
   @end table
 
 @item The signature is invalid
 This means that the signature verification failed (this is an indication
 of a transfer error, a program error or tampering with the message).
 @command{gpgsm} issues one of these status codes sequences:
   @table @code
   @item  @code{BADSIG}
   @item  @code{GOODSIG}, @code{VALIDSIG} @code{TRUST_NEVER}
   @end table
 
 @item Error verifying a signature
 For some reason the signature could not be verified, i.e. it cannot be
 decided whether the signature is valid or invalid.  A common reason for
 this is a missing certificate.
 
 @end table
 
 @node CSR and certificate creation
 @subsection CSR and certificate creation
 
 The command @option{--generate-key} may be used along with the option
 @option{--batch} to either create a certificate signing request (CSR)
 or an X.509 certificate.  This is controlled by a parameter file; the
 format of this file is as follows:
 
 @itemize @bullet
 @item Text only, line length is limited to about 1000 characters.
 @item UTF-8 encoding must be used to specify non-ASCII characters.
 @item Empty lines are ignored.
 @item Leading and trailing while space is ignored.
 @item A hash sign as the first non white space character indicates
 a comment line.
 @item Control statements are indicated by a leading percent sign, the
 arguments are separated by white space from the keyword.
 @item Parameters are specified by a keyword, followed by a colon.  Arguments
 are separated by white space.
 @item The first parameter must be @samp{Key-Type}, control statements
 may be placed anywhere.
 @item
 The order of the parameters does not matter except for @samp{Key-Type}
 which must be the first parameter.  The parameters are only used for
 the generated CSR/certificate; parameters from previous sets are not
 used.  Some syntactically checks may be performed.
 @item
 Key generation takes place when either the end of the parameter file
 is reached, the next @samp{Key-Type} parameter is encountered or at the
 control statement @samp{%commit} is encountered.
 @end itemize
 
 @noindent
 Control statements:
 
 @table @asis
 
 @item %echo @var{text}
 Print @var{text} as diagnostic.
 
 @item %dry-run
 Suppress actual key generation (useful for syntax checking).
 
 @item %commit
 Perform the key generation.  Note that an implicit commit is done at
 the next @asis{Key-Type} parameter.
 
 @c  %certfile <filename>
 @c      [Not yet implemented!]
 @c	Do not write the certificate to the keyDB but to <filename>.
 @c      This must be given before the first
 @c	commit to take place, duplicate specification of the same filename
 @c	is ignored, the last filename before a commit is used.
 @c	The filename is used until a new filename is used (at commit points)
 @c	and all keys are written to that file.	If a new filename is given,
 @c	this file is created (and overwrites an existing one).
 @c	Both control statements must be given.
 @end table
 
 @noindent
 General Parameters:
 
 @table @asis
 
 @item Key-Type: @var{algo}
 Starts a new parameter block by giving the type of the primary
 key. The algorithm must be capable of signing.  This is a required
 parameter.  The only supported value for @var{algo} is @samp{rsa}.
 
 @item Key-Length: @var{nbits}
 The requested length of a generated key in bits.  Defaults to 3072.
 
 @item Key-Grip: @var{hexstring}
 This is optional and used to generate a CSR or certificate for an
 already existing key.  Key-Length will be ignored when given.
 
 @item Key-Usage: @var{usage-list}
 Space or comma delimited list of key usage, allowed values are
 @samp{encrypt}, @samp{sign} and @samp{cert}.  This is used to generate
 the keyUsage extension.  Please make sure that the algorithm is
 capable of this usage.  Default is to allow encrypt and sign.
 
 @item Name-DN: @var{subject-name}
 This is the Distinguished Name (DN) of the subject in RFC-2253 format.
 
 @item Name-Email: @var{string}
 This is an email address for the altSubjectName.  This parameter is
 optional but may occur several times to add several email addresses to
 a certificate.
 
 @item Name-DNS: @var{string}
 The is an DNS name for the altSubjectName.  This parameter is optional
 but may occur several times to add several DNS names to a certificate.
 
 @item Name-URI: @var{string}
 This is an URI for the altSubjectName.  This parameter is optional but
 may occur several times to add several URIs to a certificate.
 @end table
 
 @noindent
 Additional parameters used to create a certificate (in contrast to a
 certificate signing request):
 
 @table @asis
 
 @item Serial: @var{sn}
 If this parameter is given an X.509 certificate will be generated.
 @var{sn} is expected to be a hex string representing an unsigned
 integer of arbitrary length.  The special value @samp{random} can be
 used to create a 64 bit random serial number.
 
 @item Issuer-DN: @var{issuer-name}
 This is the DN name of the issuer in RFC-2253 format.  If it is not set
 it will default to the subject DN and a special GnuPG extension will
 be included in the certificate to mark it as a standalone certificate.
 
 @item Creation-Date: @var{iso-date}
 @itemx Not-Before: @var{iso-date}
 Set the notBefore date of the certificate.  Either a date like
 @samp{1986-04-26} or @samp{1986-04-26 12:00} or a standard ISO
 timestamp like @samp{19860426T042640} may be used.  The time is
 considered to be UTC.  If it is not given the current date is used.
 
 @item Expire-Date: @var{iso-date}
 @itemx Not-After: @var{iso-date}
 Set the notAfter date of the certificate.  Either a date like
 @samp{2063-04-05} or @samp{2063-04-05 17:00} or a standard ISO
 timestamp like @samp{20630405T170000} may be used.  The time is
 considered to be UTC.  If it is not given a default value in the not
 too far future is used.
 
 @item Signing-Key: @var{keygrip}
 This gives the keygrip of the key used to sign the certificate.  If it
 is not given a self-signed certificate will be created.  For
 compatibility with future versions, it is suggested to prefix the
 keygrip with a @samp{&}.
 
 @item Hash-Algo: @var{hash-algo}
 Use @var{hash-algo} for this CSR or certificate.  The supported hash
 algorithms are: @samp{sha1}, @samp{sha256}, @samp{sha384} and
 @samp{sha512}; they may also be specified with uppercase letters.  The
 default is @samp{sha256}.
 
 @end table
 
 @c *******************************************
 @c ***************           *****************
 @c ***************  ASSSUAN  *****************
 @c ***************           *****************
 @c *******************************************
 @node GPGSM Protocol
 @section The Protocol the Server Mode Uses
 
 Description of the protocol used to access @command{GPGSM}.
 @command{GPGSM} does implement the Assuan protocol and in addition
 provides a regular command line interface which exhibits a full client
 to this protocol (but uses internal linking).  To start
 @command{gpgsm} as a server the command line the option
 @code{--server} must be used.  Additional options are provided to
 select the communication method (i.e. the name of the socket).
 
 We assume that the connection has already been established; see the
 Assuan manual for details.
 
 @menu
 * GPGSM ENCRYPT::         Encrypting a message.
 * GPGSM DECRYPT::         Decrypting a message.
 * GPGSM SIGN::            Signing a message.
 * GPGSM VERIFY::          Verifying a message.
 * GPGSM GENKEY::          Generating a key.
 * GPGSM LISTKEYS::        List available keys.
 * GPGSM EXPORT::          Export certificates.
 * GPGSM IMPORT::          Import certificates.
 * GPGSM DELETE::          Delete certificates.
 * GPGSM GETAUDITLOG::     Retrieve an audit log.
 * GPGSM GETINFO::         Information about the process
 * GPGSM OPTION::          Session options.
 @end menu
 
 
 @node GPGSM ENCRYPT
 @subsection Encrypting a Message
 
 Before encryption can be done the recipient must be set using the
 command:
 
 @example
   RECIPIENT @var{userID}
 @end example
 
 Set the recipient for the encryption.  @var{userID} should be the
 internal representation of the key; the server may accept any other way
 of specification.  If this is a valid and trusted recipient the server
 does respond with OK, otherwise the return is an ERR with the reason why
 the recipient cannot be used, the encryption will then not be done for
 this recipient.  If the policy is not to encrypt at all if not all
 recipients are valid, the client has to take care of this.  All
 @code{RECIPIENT} commands are cumulative until a @code{RESET} or an
 successful @code{ENCRYPT} command.
 
 @example
   INPUT FD[=@var{n}] [--armor|--base64|--binary]
 @end example
 
 Set the file descriptor for the message to be encrypted to @var{n}.
 Obviously the pipe must be open at that point, the server establishes
 its own end.  If the server returns an error the client should consider
 this session failed.  If @var{n} is not given, this commands uses the
 last file descriptor passed to the application.
 @xref{fun-assuan_sendfd, ,the assuan_sendfd function,assuan,the Libassuan
 manual}, on how to do descriptor passing.
 
 The @code{--armor} option may be used to advice the server that the
 input data is in @acronym{PEM} format, @code{--base64} advices that a
 raw base-64 encoding is used, @code{--binary} advices of raw binary
 input (@acronym{BER}).  If none of these options is used, the server
 tries to figure out the used encoding, but this may not always be
 correct.
 
 @example
   OUTPUT FD[=@var{n}] [--armor|--base64]
 @end example
 
 Set the file descriptor to be used for the output (i.e. the encrypted
 message). Obviously the pipe must be open at that point, the server
 establishes its own end.  If the server returns an error the client
 should consider this session failed.
 
 The option @option{--armor} encodes the output in @acronym{PEM} format, the
 @option{--base64} option applies just a base-64 encoding.  No option
 creates binary output (@acronym{BER}).
 
 The actual encryption is done using the command
 
 @example
   ENCRYPT
 @end example
 
 It takes the plaintext from the @code{INPUT} command, writes to the
 ciphertext to the file descriptor set with the @code{OUTPUT} command,
 take the recipients from all the recipients set so far.  If this command
 fails the clients should try to delete all output currently done or
 otherwise mark it as invalid.  @command{GPGSM} does ensure that there
 will not be any
 security problem with leftover data on the output in this case.
 
 This command should in general not fail, as all necessary checks have
 been done while setting the recipients.  The input and output pipes are
 closed.
 
 
 @node GPGSM DECRYPT
 @subsection Decrypting a message
 
 Input and output FDs are set the same way as in encryption, but
 @code{INPUT} refers to the ciphertext and @code{OUTPUT} to the plaintext. There
 is no need to set recipients.  @command{GPGSM} automatically strips any
 @acronym{S/MIME} headers from the input, so it is valid to pass an
 entire MIME part to the INPUT pipe.
 
 The decryption is done by using the command
 
 @example
   DECRYPT
 @end example
 
 It performs the decrypt operation after doing some check on the internal
 state (e.g. that all needed data has been set).  Because it utilizes
 the GPG-Agent for the session key decryption, there is no need to ask
 the client for a protecting passphrase - GpgAgent takes care of this by
 requesting this from the user.
 
 
 @node GPGSM SIGN
 @subsection Signing a Message
 
 Signing is usually done with these commands:
 
 @example
   INPUT FD[=@var{n}] [--armor|--base64|--binary]
 @end example
 
 This tells @command{GPGSM} to read the data to sign from file descriptor @var{n}.
 
 @example
   OUTPUT FD[=@var{m}] [--armor|--base64]
 @end example
 
 Write the output to file descriptor @var{m}.  If a detached signature is
 requested, only the signature is written.
 
 @example
   SIGN [--detached]
 @end example
 
 Sign the data set with the @code{INPUT} command and write it to the sink set by
 @code{OUTPUT}.  With @code{--detached}, a detached signature is created
 (surprise).
 
 The key used for signing is the default one or the one specified in
 the configuration file.  To get finer control over the keys, it is
 possible to use the command
 
 @example
   SIGNER @var{userID}
 @end example
 
 to set the signer's key.  @var{userID} should be the
 internal representation of the key; the server may accept any other way
 of specification.  If this is a valid and trusted recipient the server
 does respond with OK, otherwise the return is an ERR with the reason why
 the key cannot be used, the signature will then not be created using
 this key.  If the policy is not to sign at all if not all
 keys are valid, the client has to take care of this.  All
 @code{SIGNER} commands are cumulative until a @code{RESET} is done.
 Note that a @code{SIGN} does not reset this list of signers which is in
 contrast to the @code{RECIPIENT} command.
 
 
 @node GPGSM VERIFY
 @subsection Verifying a Message
 
 To verify a message the command:
 
 @example
   VERIFY
 @end example
 
 is used. It does a verify operation on the message send to the input FD.
 The result is written out using status lines.  If an output FD was
 given, the signed text will be written to that.  If the signature is a
 detached one, the server will inquire about the signed material and the
 client must provide it.
 
 @node GPGSM GENKEY
 @subsection Generating a Key
 
 This is used to generate a new keypair, store the secret part in the
 @acronym{PSE} and the public key in the key database.  We will probably
 add optional commands to allow the client to select whether a hardware
 token is used to store the key.  Configuration options to
 @command{GPGSM} can be used to restrict the use of this command.
 
 @example
   GENKEY
 @end example
 
 @command{GPGSM} checks whether this command is allowed and then does an
 INQUIRY to get the key parameters, the client should then send the
 key parameters in the native format:
 
 @example
     S: INQUIRE KEY_PARAM native
     C: D foo:fgfgfg
     C: D bar
     C: END
 @end example
 
 Please note that the server may send Status info lines while reading the
 data lines from the client.  After this the key generation takes place
 and the server eventually does send an ERR or OK response.  Status lines
 may be issued as a progress indicator.
 
 
 @node GPGSM LISTKEYS
 @subsection List available keys
 @anchor{gpgsm-cmd listkeys}
 
 To list the keys in the internal database or using an external key
 provider, the command:
 
 @example
   LISTKEYS  @var{pattern}
 @end example
 
 is used.  To allow multiple patterns (which are ORed during the search)
 quoting is required: Spaces are to be translated into "+" or into "%20";
 in turn this requires that the usual escape quoting rules are done.
 
 @example
   LISTSECRETKEYS @var{pattern}
 @end example
 
 Lists only the keys where a secret key is available.
 
 The list commands are affected by the option
 
 @example
   OPTION list-mode=@var{mode}
 @end example
 
 where mode may be:
 @table @code
 @item 0
 Use default (which is usually the same as 1).
 @item 1
 List only the internal keys.
 @item 2
 List only the external keys.
 @item 3
 List internal and external keys.
 @end table
 
 Note that options are valid for the entire session.
 
 
 @node GPGSM EXPORT
 @subsection Export certificates
 
 To export certificate from the internal key database the command:
 
 @example
   EXPORT [--data [--armor] [--base64]] [--] @var{pattern}
 @end example
 
 is used.  To allow multiple patterns (which are ORed) quoting is
 required: Spaces are to be translated into "+" or into "%20"; in turn
 this requires that the usual escape quoting rules are done.
 
 If the @option{--data} option has not been given, the format of the
 output depends on what was set with the @code{OUTPUT} command.  When using
 @acronym{PEM} encoding a few informational lines are prepended.
 
 If the @option{--data} has been given, a target set via @code{OUTPUT} is
 ignored and the data is returned inline using standard
 @code{D}-lines. This avoids the need for an extra file descriptor.  In
 this case the options @option{--armor} and @option{--base64} may be used
 in the same way as with the @code{OUTPUT} command.
 
 
 @node GPGSM IMPORT
 @subsection Import certificates
 
 To import certificates into the internal key database, the command
 
 @example
   IMPORT [--re-import]
 @end example
 
 is used.  The data is expected on the file descriptor set with the
 @code{INPUT} command.  Certain checks are performed on the
 certificate.  Note that the code will also handle PKCS#12 files and
 import private keys; a helper program is used for that.
 
 With the option @option{--re-import} the input data is expected to a be
 a linefeed separated list of fingerprints.  The command will re-import
 the corresponding certificates; that is they are made permanent by
 removing their ephemeral flag.
 
 
 @node GPGSM DELETE
 @subsection Delete certificates
 
 To delete a certificate the command
 
 @example
   DELKEYS @var{pattern}
 @end example
 
 is used.  To allow multiple patterns (which are ORed) quoting is
 required: Spaces are to be translated into "+" or into "%20"; in turn
 this requires that the usual escape quoting rules are done.
 
 The certificates must be specified unambiguously otherwise an error is
 returned.
 
 @node GPGSM GETAUDITLOG
 @subsection Retrieve an audit log
 @anchor{gpgsm-cmd getauditlog}
 
 This command is used to retrieve an audit log.
 
 @example
 GETAUDITLOG [--data] [--html]
 @end example
 
 If @option{--data} is used, the audit log is send using D-lines
 instead of being sent to the file descriptor given by an @code{OUTPUT}
 command.  If @option{--html} is used, the output is formatted as an
 XHTML block. This is designed to be incorporated into a HTML
 document.
 
 
 @node GPGSM GETINFO
 @subsection  Return information about the process
 
 This is a multipurpose function to return a variety of information.
 
 @example
 GETINFO @var{what}
 @end example
 
 The value of @var{what} specifies the kind of information returned:
 @table @code
 @item version
 Return the version of the program.
 @item pid
 Return the process id of the process.
 @item agent-check
 Return OK if the agent is running.
 @item cmd_has_option @var{cmd} @var{opt}
 Return OK if the command @var{cmd} implements the option @var{opt}.
 The leading two dashes usually used with @var{opt} shall not be given.
 @item offline
 Return OK if the connection is in offline mode.  This may be either
 due to a @code{OPTION offline=1} or due to @command{gpgsm} being
 started with option @option{--disable-dirmngr}.
 @end table
 
 @node GPGSM OPTION
 @subsection  Session options
 
 The standard Assuan option handler supports these options.
 
 @example
 OPTION @var{name}[=@var{value}]
 @end example
 
 These @var{name}s are recognized:
 
 @table @code
 
 @item putenv
 Change the session's environment to be passed via gpg-agent to
 Pinentry.  @var{value} is a string of the form
 @code{<KEY>[=[<STRING>]]}.  If only @code{<KEY>} is given the
 environment variable @code{<KEY>} is removed from the session
 environment, if @code{<KEY>=} is given that environment variable is
 set to the empty string, and if @code{<STRING>} is given it is set to
 that string.
 
 @item display
 @efindex DISPLAY
 Set the session environment variable @code{DISPLAY} is set to @var{value}.
 @item ttyname
 @efindex GPG_TTY
 Set the session environment variable @code{GPG_TTY} is set to @var{value}.
 @item ttytype
 @efindex TERM
 Set the session environment variable @code{TERM} is set to @var{value}.
 @item lc-ctype
 @efindex LC_CTYPE
 Set the session environment variable @code{LC_CTYPE} is set to @var{value}.
 @item lc-messages
 @efindex LC_MESSAGES
 Set the session environment variable @code{LC_MESSAGES} is set to @var{value}.
 @item xauthority
 @efindex XAUTHORITY
 Set the session environment variable @code{XAUTHORITY} is set to @var{value}.
 @item pinentry-user-data
 @efindex PINENTRY_USER_DATA
 Set the session environment variable @code{PINENTRY_USER_DATA} is set
 to @var{value}.
 
 @item include-certs
 This option overrides the command line option
 @option{--include-certs}.  A @var{value} of -2 includes all
 certificates except for the root certificate, -1 includes all
 certificates, 0 does not include any certificates, 1 includes only the
 signers certificate and all other positive values include up to
 @var{value} certificates starting with the signer cert.
 
 @item list-mode
 @xref{gpgsm-cmd listkeys}.
 
 @item list-to-output
 If @var{value} is true the output of the list commands
 (@pxref{gpgsm-cmd listkeys}) is written to the file descriptor set
 with the last @code{OUTPUT} command.  If @var{value} is false the output is
 written via data lines; this is the default.
 
 @item with-validation
 If @var{value} is true for each listed certificate the validation
 status is printed.  This may result in the download of a CRL or the
 user being asked about the trustworthiness of a root certificate.  The
 default is given by a command line option (@pxref{gpgsm-option
 --with-validation}).
 
 
 @item with-secret
 If @var{value} is true certificates with a corresponding private key
 are marked by the list commands.
 
 @item validation-model
 This option overrides the command line option
 @option{validation-model} for the session.
 (@xref{gpgsm-option --validation-model}.)
 
 @item with-key-data
 This option globally enables the command line option
 @option{--with-key-data}.  (@xref{gpgsm-option --with-key-data}.)
 
 @item enable-audit-log
 If @var{value} is true data to write an audit log is gathered.
 (@xref{gpgsm-cmd getauditlog}.)
 
 @item allow-pinentry-notify
 If this option is used notifications about the launch of a Pinentry
 are passed back to the client.
 
 @item with-ephemeral-keys
 If @var{value} is true ephemeral certificates are included in the
 output of the list commands.
 
 @item no-encrypt-to
 If this option is used all keys set by the command line option
 @option{--encrypt-to} are ignored.
 
 @item offline
 If @var{value} is true or @var{value} is not given all network access
 is disabled for this session.  This is the same as the command line
 option @option{--disable-dirmngr}.
 
 @end table
 
 @mansect see also
 @ifset isman
 @command{gpg2}(1),
 @command{gpg-agent}(1)
 @end ifset
 @include see-also-note.texi
diff --git a/sm/certchain.c b/sm/certchain.c
index f59dc7573..c71397b4d 100644
--- a/sm/certchain.c
+++ b/sm/certchain.c
@@ -1,2224 +1,2242 @@
 /* certchain.c - certificate chain validation
  * Copyright (C) 2001, 2002, 2003, 2004, 2005,
  *               2006, 2007, 2008, 2011 Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
  * GnuPG is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 3 of the License, or
  * (at your option) any later version.
  *
  * GnuPG is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, see <https://www.gnu.org/licenses/>.
  */
 
 #include <config.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <errno.h>
 #include <unistd.h>
 #include <time.h>
 #include <stdarg.h>
 #include <assert.h>
 
 #include "gpgsm.h"
 #include <gcrypt.h>
 #include <ksba.h>
 
 #include "keydb.h"
 #include "../kbx/keybox.h" /* for KEYBOX_FLAG_* */
 #include "../common/i18n.h"
 #include "../common/tlv.h"
 
 
 /* Object to keep track of certain root certificates. */
 struct marktrusted_info_s
 {
   struct marktrusted_info_s *next;
   unsigned char fpr[20];
 };
 static struct marktrusted_info_s *marktrusted_info;
 
 
 /* While running the validation function we want to keep track of the
    certificates in the chain.  This type is used for that.  */
 struct chain_item_s
 {
   struct chain_item_s *next;
   ksba_cert_t cert;      /* The certificate.  */
   int is_root;           /* The certificate is the root certificate.  */
 };
 typedef struct chain_item_s *chain_item_t;
 
 
 static int is_root_cert (ksba_cert_t cert,
                          const char *issuerdn, const char *subjectdn);
 static int get_regtp_ca_info (ctrl_t ctrl, ksba_cert_t cert, int *chainlen);
 
 
 /* This function returns true if we already asked during this session
    whether the root certificate CERT shall be marked as trusted.  */
 static int
 already_asked_marktrusted (ksba_cert_t cert)
 {
   unsigned char fpr[20];
   struct marktrusted_info_s *r;
 
   gpgsm_get_fingerprint (cert, GCRY_MD_SHA1, fpr, NULL);
   /* No context switches in the loop! */
   for (r=marktrusted_info; r; r= r->next)
     if (!memcmp (r->fpr, fpr, 20))
       return 1;
   return 0;
 }
 
 /* Flag certificate CERT as already asked whether it shall be marked
    as trusted.  */
 static void
 set_already_asked_marktrusted (ksba_cert_t cert)
 {
  unsigned char fpr[20];
  struct marktrusted_info_s *r;
 
  gpgsm_get_fingerprint (cert, GCRY_MD_SHA1, fpr, NULL);
  for (r=marktrusted_info; r; r= r->next)
    if (!memcmp (r->fpr, fpr, 20))
      return; /* Already marked. */
  r = xtrycalloc (1, sizeof *r);
  if (!r)
    return;
  memcpy (r->fpr, fpr, 20);
  r->next = marktrusted_info;
  marktrusted_info = r;
 }
 
 /* If LISTMODE is true, print FORMAT using LISTMODE to FP.  If
    LISTMODE is false, use the string to print an log_info or, if
    IS_ERROR is true, and log_error. */
 static void
 do_list (int is_error, int listmode, estream_t fp, const char *format, ...)
 {
   va_list arg_ptr;
 
   va_start (arg_ptr, format) ;
   if (listmode)
     {
       if (fp)
         {
           es_fputs ("  [", fp);
           es_vfprintf (fp, format, arg_ptr);
           es_fputs ("]\n", fp);
         }
     }
   else
     {
       log_logv (is_error? GPGRT_LOG_ERROR: GPGRT_LOG_INFO, format, arg_ptr);
       log_printf ("\n");
     }
   va_end (arg_ptr);
 }
 
 /* Return 0 if A and B are equal. */
 static int
 compare_certs (ksba_cert_t a, ksba_cert_t b)
 {
   const unsigned char *img_a, *img_b;
   size_t len_a, len_b;
 
   img_a = ksba_cert_get_image (a, &len_a);
   if (!img_a)
     return 1;
   img_b = ksba_cert_get_image (b, &len_b);
   if (!img_b)
     return 1;
   return !(len_a == len_b && !memcmp (img_a, img_b, len_a));
 }
 
 
 /* Return true if CERT has the validityModel extensions and defines
    the use of the chain model.  */
 static int
 has_validation_model_chain (ksba_cert_t cert, int listmode, estream_t listfp)
 {
   gpg_error_t err;
   int idx, yes;
   const char *oid;
   size_t off, derlen, objlen, hdrlen;
   const unsigned char *der;
   int class, tag, constructed, ndef;
   char *oidbuf;
 
   for (idx=0; !(err=ksba_cert_get_extension (cert, idx,
                                              &oid, NULL, &off, &derlen));idx++)
     if (!strcmp (oid, "1.3.6.1.4.1.8301.3.5") )
       break;
   if (err)
     return 0; /* Not found.  */
   der = ksba_cert_get_image (cert, NULL);
   if (!der)
     {
       err = gpg_error (GPG_ERR_INV_OBJ); /* Oops  */
       goto leave;
     }
   der += off;
 
   err = parse_ber_header (&der, &derlen, &class, &tag, &constructed,
                           &ndef, &objlen, &hdrlen);
   if (!err && (objlen > derlen || tag != TAG_SEQUENCE))
     err = gpg_error (GPG_ERR_INV_OBJ);
   if (err)
     goto leave;
   derlen = objlen;
   err = parse_ber_header (&der, &derlen, &class, &tag, &constructed,
                           &ndef, &objlen, &hdrlen);
   if (!err && (objlen > derlen || tag != TAG_OBJECT_ID))
     err = gpg_error (GPG_ERR_INV_OBJ);
   if (err)
     goto leave;
   oidbuf = ksba_oid_to_str (der, objlen);
   if (!oidbuf)
     {
       err = gpg_error_from_syserror ();
       goto leave;
     }
 
   if (opt.verbose)
     do_list (0, listmode, listfp,
              _("validation model requested by certificate: %s"),
               !strcmp (oidbuf, "1.3.6.1.4.1.8301.3.5.1")? _("chain") :
               !strcmp (oidbuf, "1.3.6.1.4.1.8301.3.5.2")? _("shell") :
               /* */                                       oidbuf);
   yes = !strcmp (oidbuf, "1.3.6.1.4.1.8301.3.5.1");
   ksba_free (oidbuf);
   return yes;
 
 
  leave:
   log_error ("error parsing validityModel: %s\n", gpg_strerror (err));
   return 0;
 }
 
 
 
 static int
 unknown_criticals (ksba_cert_t cert, int listmode, estream_t fp)
 {
   static const char *known[] = {
     "2.5.29.15", /* keyUsage */
     "2.5.29.17", /* subjectAltName
                     Japanese DoCoMo certs mark them as critical.  PKIX
                     only requires them as critical if subjectName is
                     empty.  I don't know whether our code gracefully
                     handles such empry subjectNames but that is
                     another story. */
     "2.5.29.19", /* basic Constraints */
     "2.5.29.32", /* certificatePolicies */
     "2.5.29.37", /* extendedKeyUsage - handled by certlist.c */
     "1.3.6.1.4.1.8301.3.5", /* validityModel - handled here. */
     NULL
   };
   int rc = 0, i, idx, crit;
   const char *oid;
   gpg_error_t err;
   int unsupported;
   strlist_t sl;
 
   for (idx=0; !(err=ksba_cert_get_extension (cert, idx,
                                              &oid, &crit, NULL, NULL));idx++)
     {
       if (!crit)
         continue;
       for (i=0; known[i] && strcmp (known[i],oid); i++)
         ;
       unsupported = !known[i];
 
       /* If this critical extension is not supported.  Check the list
          of to be ignored extensions to see whether we claim that it
          is supported.  */
       if (unsupported && opt.ignored_cert_extensions)
         {
           for (sl=opt.ignored_cert_extensions;
                sl && strcmp (sl->d, oid); sl = sl->next)
             ;
           if (sl)
             unsupported = 0;
         }
       if (unsupported)
         {
           do_list (1, listmode, fp,
                    _("critical certificate extension %s is not supported"),
                    oid);
           rc = gpg_error (GPG_ERR_UNSUPPORTED_CERT);
         }
     }
   /* We ignore the error codes EOF as well as no-value. The later will
      occur for certificates with no extensions at all. */
   if (err
       && gpg_err_code (err) != GPG_ERR_EOF
       && gpg_err_code (err) != GPG_ERR_NO_VALUE)
     rc = err;
 
   return rc;
 }
 
 
 /* Check whether CERT is an allowed certificate.  This requires that
    CERT matches all requirements for such a CA, i.e. the
    BasicConstraints extension.  The function returns 0 on success and
    the allowed length of the chain at CHAINLEN. */
 static int
 allowed_ca (ctrl_t ctrl,
             ksba_cert_t cert, int *chainlen, int listmode, estream_t fp)
 {
   gpg_error_t err;
   int flag;
 
   err = ksba_cert_is_ca (cert, &flag, chainlen);
   if (err)
     return err;
   if (!flag)
     {
       if (get_regtp_ca_info (ctrl, cert, chainlen))
         {
           /* Note that dirmngr takes a different way to cope with such
              certs. */
           return 0; /* RegTP issued certificate. */
         }
 
       do_list (1, listmode, fp,_("issuer certificate is not marked as a CA"));
       return gpg_error (GPG_ERR_BAD_CA_CERT);
     }
   return 0;
 }
 
 
 static int
 check_cert_policy (ksba_cert_t cert, int listmode, estream_t fplist)
 {
   gpg_error_t err;
   char *policies;
   FILE *fp;
   int any_critical;
 
   err = ksba_cert_get_cert_policies (cert, &policies);
   if (gpg_err_code (err) == GPG_ERR_NO_DATA)
     return 0; /* No policy given. */
   if (err)
     return err;
 
   /* STRING is a line delimited list of certificate policies as stored
      in the certificate.  The line itself is colon delimited where the
      first field is the OID of the policy and the second field either
      N or C for normal or critical extension */
 
   if (opt.verbose > 1 && !listmode)
     log_info ("certificate's policy list: %s\n", policies);
 
   /* The check is very minimal but won't give false positives */
   any_critical = !!strstr (policies, ":C");
 
   if (!opt.policy_file)
     {
       xfree (policies);
       if (any_critical)
         {
           do_list (1, listmode, fplist,
                    _("critical marked policy without configured policies"));
           return gpg_error (GPG_ERR_NO_POLICY_MATCH);
         }
       return 0;
     }
 
   fp = fopen (opt.policy_file, "r");
   if (!fp)
     {
       if (opt.verbose || errno != ENOENT)
         log_info (_("failed to open '%s': %s\n"),
                   opt.policy_file, strerror (errno));
       xfree (policies);
       /* With no critical policies this is only a warning */
       if (!any_critical)
         {
           if (!opt.quiet)
             do_list (0, listmode, fplist,
                      _("Note: non-critical certificate policy not allowed"));
           return 0;
         }
       do_list (1, listmode, fplist,
                _("certificate policy not allowed"));
       return gpg_error (GPG_ERR_NO_POLICY_MATCH);
     }
 
   for (;;)
     {
       int c;
       char *p, line[256];
       char *haystack, *allowed;
 
       /* read line */
       do
         {
           if (!fgets (line, DIM(line)-1, fp) )
             {
               gpg_error_t tmperr = gpg_error (gpg_err_code_from_errno (errno));
 
               xfree (policies);
               if (feof (fp))
                 {
                   fclose (fp);
                   /* With no critical policies this is only a warning */
                   if (!any_critical)
                     {
                       do_list (0, listmode, fplist,
                      _("Note: non-critical certificate policy not allowed"));
                       return 0;
                     }
                   do_list (1, listmode, fplist,
                            _("certificate policy not allowed"));
                   return gpg_error (GPG_ERR_NO_POLICY_MATCH);
                 }
               fclose (fp);
               return tmperr;
             }
 
           if (!*line || line[strlen(line)-1] != '\n')
             {
               /* eat until end of line */
               while ( (c=getc (fp)) != EOF && c != '\n')
                 ;
               fclose (fp);
               xfree (policies);
               return gpg_error (*line? GPG_ERR_LINE_TOO_LONG
                                      : GPG_ERR_INCOMPLETE_LINE);
             }
 
           /* Allow for empty lines and spaces */
           for (p=line; spacep (p); p++)
             ;
         }
       while (!*p || *p == '\n' || *p == '#');
 
       /* Parse line.  Note that the line has always a LF and spacep
          does not consider a LF a space.  Thus strpbrk will always
          succeed.  */
       for (allowed=line; spacep (allowed); allowed++)
         ;
       p = strpbrk (allowed, " :\n");
       if (!*p || p == allowed)
         {
           fclose (fp);
           xfree (policies);
           return gpg_error (GPG_ERR_CONFIGURATION);
         }
       *p = 0; /* strip the rest of the line */
       /* See whether we find ALLOWED (which is an OID) in POLICIES */
       for (haystack=policies; (p=strstr (haystack, allowed)); haystack = p+1)
         {
           if ( !(p == policies || p[-1] == '\n') )
             continue; /* Does not match the begin of a line. */
           if (p[strlen (allowed)] != ':')
             continue; /* The length does not match. */
           /* Yep - it does match so return okay. */
           fclose (fp);
           xfree (policies);
           return 0;
         }
     }
 }
 
 
 /* Helper function for find_up.  This resets the key handle and search
    for an issuer ISSUER with a subjectKeyIdentifier of KEYID.  Returns
    0 on success or -1 when not found. */
 static int
 find_up_search_by_keyid (ctrl_t ctrl, KEYDB_HANDLE kh,
                          const char *issuer, ksba_sexp_t keyid)
 {
   int rc;
   ksba_cert_t cert = NULL;
   ksba_sexp_t subj = NULL;
   ksba_isotime_t not_before, not_after, last_not_before, ne_last_not_before;
   ksba_cert_t found_cert = NULL;
   ksba_cert_t ne_found_cert = NULL;
 
   keydb_search_reset (kh);
   while (!(rc = keydb_search_subject (ctrl, kh, issuer)))
     {
       ksba_cert_release (cert); cert = NULL;
       rc = keydb_get_cert (kh, &cert);
       if (rc)
         {
           log_error ("keydb_get_cert() failed: rc=%d\n", rc);
           rc = -1;
           goto leave;
         }
       xfree (subj);
       if (!ksba_cert_get_subj_key_id (cert, NULL, &subj))
         {
           if (!cmp_simple_canon_sexp (keyid, subj))
             {
               /* Found matching cert. */
               rc = ksba_cert_get_validity (cert, 0, not_before);
               if (!rc)
                 rc = ksba_cert_get_validity (cert, 1, not_after);
               if (rc)
                 {
                   log_error ("keydb_get_validity() failed: rc=%d\n", rc);
                   rc = -1;
                   goto leave;
                 }
 
               if (!found_cert
                   || strcmp (last_not_before, not_before) < 0)
                 {
                   /* This certificate is the first one found or newer
                    * than the previous one.  This copes with
                    * re-issuing CA certificates while keeping the same
                    * key information.  */
                   gnupg_copy_time (last_not_before, not_before);
                   ksba_cert_release (found_cert);
                   ksba_cert_ref ((found_cert = cert));
                   keydb_push_found_state (kh);
                 }
 
               if (*not_after && strcmp (ctrl->current_time, not_after) > 0 )
                 ; /* CERT has expired - don't consider it.  */
               else if (!ne_found_cert
                        || strcmp (ne_last_not_before, not_before) < 0)
                 {
                   /* This certificate is the first non-expired one
                    * found or newer than the previous non-expired one.  */
                   gnupg_copy_time (ne_last_not_before, not_before);
                   ksba_cert_release (ne_found_cert);
                   ksba_cert_ref ((ne_found_cert = cert));
                 }
             }
         }
     }
 
   if (!found_cert)
     goto leave;
 
   /* Take the last saved one.  Note that push/pop_found_state are
    * misnomers because there is no stack of states.  Renaming them to
    * save/restore_found_state would be better.  */
   keydb_pop_found_state (kh);
   rc = 0;  /* Ignore EOF or other error after the first cert.  */
 
   /* We need to consider some corner cases.  It is possible that we
    * have a long term certificate (e.g. valid from 2008 to 2033) as
    * well as a re-issued (i.e. using the same key material) short term
    * certificate (say from 2016 to 2019).  Using the short term
    * certificate is the proper solution.  But we need to take care if
    * there is no re-issued new short term certificate (e.g. from 2020
    * to 2023) available.  In that case it is better to use the long
    * term certificate which is still valid.  The code may run into
    * minor problems in the case of the chain validation mode.  Given
    * that this corner case is due to non-diligent PKI management we
    * ignore this problem.  */
 
   /* The most common case is that the found certificate is not expired
    * and thus identical to the one found from the list of non-expired
    * certs.  We can stop here.  */
   if (found_cert == ne_found_cert)
     goto leave;
   /* If we do not have a non expired certificate the actual cert is
    * expired and we can also stop here.  */
   if (!ne_found_cert)
     goto leave;
   /* Now we need to see whether the found certificate is expired and
    * only in this case we return the certificate found in the list of
    * non-expired certs.  */
   rc = ksba_cert_get_validity (found_cert, 1, not_after);
   if (rc)
     {
       log_error ("keydb_get_validity() failed: rc=%d\n", rc);
       rc = -1;
       goto leave;
     }
   if (*not_after && strcmp (ctrl->current_time, not_after) > 0 )
     { /* CERT has expired.  Use the NE_FOUND_CERT.  Because we have no
        * found state for this we need to search for it again.  */
       unsigned char fpr[20];
 
       gpgsm_get_fingerprint (ne_found_cert, GCRY_MD_SHA1, fpr, NULL);
       keydb_search_reset (kh);
       rc = keydb_search_fpr (ctrl, kh, fpr);
       if (rc)
         {
           log_error ("keydb_search_fpr() failed: rc=%d\n", rc);
           rc = -1;
           goto leave;
         }
       /* Ready.  The NE_FOUND_CERT is availabale via keydb_get_cert.  */
     }
 
  leave:
   ksba_cert_release (found_cert);
   ksba_cert_release (ne_found_cert);
   ksba_cert_release (cert);
   xfree (subj);
   return rc? -1:0;
 }
 
 
 struct find_up_store_certs_s
 {
   ctrl_t ctrl;
   int count;
 };
 
 static void
 find_up_store_certs_cb (void *cb_value, ksba_cert_t cert)
 {
   struct find_up_store_certs_s *parm = cb_value;
 
   if (keydb_store_cert (parm->ctrl, cert, 1, NULL))
     log_error ("error storing issuer certificate as ephemeral\n");
   parm->count++;
 }
 
 
 /* Helper for find_up().  Locate the certificate for ISSUER using an
    external lookup.  KH is the keydb context we are currently using.
    On success 0 is returned and the certificate may be retrieved from
    the keydb using keydb_get_cert().  KEYID is the keyIdentifier from
    the AKI or NULL.  */
 static int
 find_up_external (ctrl_t ctrl, KEYDB_HANDLE kh,
                   const char *issuer, ksba_sexp_t keyid)
 {
   int rc;
   strlist_t names = NULL;
   struct find_up_store_certs_s find_up_store_certs_parm;
   char *pattern;
   const char *s;
 
   find_up_store_certs_parm.ctrl = ctrl;
   find_up_store_certs_parm.count = 0;
 
   if (opt.verbose)
     log_info (_("looking up issuer at external location\n"));
   /* The Dirmngr process is confused about unknown attributes.  As a
      quick and ugly hack we locate the CN and use the issuer string
      starting at this attribite.  Fixme: we should have far better
      parsing for external lookups in the Dirmngr. */
   s = strstr (issuer, "CN=");
   if (!s || s == issuer || s[-1] != ',')
     s = issuer;
   pattern = xtrymalloc (strlen (s)+2);
   if (!pattern)
     return gpg_error_from_syserror ();
   strcpy (stpcpy (pattern, "/"), s);
   add_to_strlist (&names, pattern);
   xfree (pattern);
 
   rc = gpgsm_dirmngr_lookup (ctrl, names, 0, find_up_store_certs_cb,
                              &find_up_store_certs_parm);
   free_strlist (names);
 
   if (opt.verbose)
     log_info (_("number of issuers matching: %d\n"),
               find_up_store_certs_parm.count);
   if (rc)
     {
       log_error ("external key lookup failed: %s\n", gpg_strerror (rc));
       rc = -1;
     }
   else if (!find_up_store_certs_parm.count)
     rc = -1;
   else
     {
       int old;
       /* The issuers are currently stored in the ephemeral key DB, so
          we temporary switch to ephemeral mode. */
       old = keydb_set_ephemeral (kh, 1);
       if (keyid)
         rc = find_up_search_by_keyid (ctrl, kh, issuer, keyid);
       else
         {
           keydb_search_reset (kh);
           rc = keydb_search_subject (ctrl, kh, issuer);
         }
       keydb_set_ephemeral (kh, old);
     }
   return rc;
 }
 
 
 /* Helper for find_up().  Ask the dirmngr for the certificate for
    ISSUER with optional SERIALNO.  KH is the keydb context we are
    currently using.  With SUBJECT_MODE set, ISSUER is searched as the
    subject.  On success 0 is returned and the certificate is available
    in the ephemeral DB.  */
 static int
 find_up_dirmngr (ctrl_t ctrl, KEYDB_HANDLE kh,
                  ksba_sexp_t serialno, const char *issuer, int subject_mode)
 {
   int rc;
   strlist_t names = NULL;
   struct find_up_store_certs_s find_up_store_certs_parm;
   char *pattern;
 
   (void)kh;
 
   find_up_store_certs_parm.ctrl = ctrl;
   find_up_store_certs_parm.count = 0;
 
   if (opt.verbose)
     log_info (_("looking up issuer from the Dirmngr cache\n"));
   if (subject_mode)
     {
       pattern = xtrymalloc (strlen (issuer)+2);
       if (pattern)
         strcpy (stpcpy (pattern, "/"), issuer);
     }
   else if (serialno)
     pattern = gpgsm_format_sn_issuer (serialno, issuer);
   else
     {
       pattern = xtrymalloc (strlen (issuer)+3);
       if (pattern)
         strcpy (stpcpy (pattern, "#/"), issuer);
     }
   if (!pattern)
     return gpg_error_from_syserror ();
   add_to_strlist (&names, pattern);
   xfree (pattern);
 
   rc = gpgsm_dirmngr_lookup (ctrl, names, 1, find_up_store_certs_cb,
                              &find_up_store_certs_parm);
   free_strlist (names);
 
   if (opt.verbose)
     log_info (_("number of matching certificates: %d\n"),
               find_up_store_certs_parm.count);
   if (rc && !opt.quiet)
     log_info (_("dirmngr cache-only key lookup failed: %s\n"),
               gpg_strerror (rc));
   return (!rc && find_up_store_certs_parm.count)? 0 : -1;
 }
 
 
 
 /* Locate issuing certificate for CERT. ISSUER is the name of the
    issuer used as a fallback if the other methods don't work.  If
    FIND_NEXT is true, the function shall return the next possible
    issuer.  The certificate itself is not directly returned but a
    keydb_get_cert on the keydb context KH will return it.  Returns 0
    on success, -1 if not found or an error code.  */
 static int
 find_up (ctrl_t ctrl, KEYDB_HANDLE kh,
          ksba_cert_t cert, const char *issuer, int find_next)
 {
   ksba_name_t authid;
   ksba_sexp_t authidno;
   ksba_sexp_t keyid;
   int rc = -1;
 
   if (DBG_X509)
     log_debug ("looking for parent certificate\n");
   if (!ksba_cert_get_auth_key_id (cert, &keyid, &authid, &authidno))
     {
       const char *s = ksba_name_enum (authid, 0);
       if (s && *authidno)
         {
           rc = keydb_search_issuer_sn (ctrl, kh, s, authidno);
           if (rc)
             keydb_search_reset (kh);
 
           if (!rc && DBG_X509)
             log_debug ("  found via authid and sn+issuer\n");
 
           /* In case of an error, try to get the certificate from the
              dirmngr.  That is done by trying to put that certifcate
              into the ephemeral DB and let the code below do the
              actual retrieve.  Thus there is no error checking.
              Skipped in find_next mode as usual. */
           if (rc == -1 && !find_next)
             find_up_dirmngr (ctrl, kh, authidno, s, 0);
 
           /* In case of an error try the ephemeral DB.  We can't do
              that in find_next mode because we can't keep the search
              state then. */
           if (rc == -1 && !find_next)
             {
               int old = keydb_set_ephemeral (kh, 1);
               if (!old)
                 {
                   rc = keydb_search_issuer_sn (ctrl, kh, s, authidno);
                   if (rc)
                     keydb_search_reset (kh);
 
                   if (!rc && DBG_X509)
                     log_debug ("  found via authid and sn+issuer (ephem)\n");
                 }
               keydb_set_ephemeral (kh, old);
             }
           if (rc)
             rc = -1; /* Need to make sure to have this error code. */
         }
 
       if (rc == -1 && keyid && !find_next)
         {
           /* Not found by AKI.issuer_sn.  Lets try the AKI.ki
              instead. Loop over all certificates with that issuer as
              subject and stop for the one with a matching
              subjectKeyIdentifier. */
           /* Fixme: Should we also search in the dirmngr?  */
           rc = find_up_search_by_keyid (ctrl, kh, issuer, keyid);
           if (!rc && DBG_X509)
             log_debug ("  found via authid and keyid\n");
           if (rc)
             {
               int old = keydb_set_ephemeral (kh, 1);
               if (!old)
                 rc = find_up_search_by_keyid (ctrl, kh, issuer, keyid);
               if (!rc && DBG_X509)
                 log_debug ("  found via authid and keyid (ephem)\n");
               keydb_set_ephemeral (kh, old);
             }
           if (rc)
             rc = -1; /* Need to make sure to have this error code. */
         }
 
       /* If we still didn't found it, try to find it via the subject
          from the dirmngr-cache.  */
       if (rc == -1 && !find_next)
         {
           if (!find_up_dirmngr (ctrl, kh, NULL, issuer, 1))
             {
               int old = keydb_set_ephemeral (kh, 1);
               if (keyid)
                 rc = find_up_search_by_keyid (ctrl, kh, issuer, keyid);
               else
                 {
                   keydb_search_reset (kh);
                   rc = keydb_search_subject (ctrl, kh, issuer);
                 }
               keydb_set_ephemeral (kh, old);
             }
           if (rc)
             rc = -1; /* Need to make sure to have this error code. */
 
           if (!rc && DBG_X509)
             log_debug ("  found via authid and issuer from dirmngr cache\n");
         }
 
       /* If we still didn't found it, try an external lookup.  */
       if (rc == -1 && opt.auto_issuer_key_retrieve && !find_next)
         {
           rc = find_up_external (ctrl, kh, issuer, keyid);
           if (!rc && DBG_X509)
             log_debug ("  found via authid and external lookup\n");
         }
 
 
       /* Print a note so that the user does not feel too helpless when
          an issuer certificate was found and gpgsm prints BAD
          signature because it is not the correct one. */
       if (rc == -1 && opt.quiet)
         ;
       else if (rc == -1)
         {
           log_info ("%sissuer certificate ", find_next?"next ":"");
           if (keyid)
             {
               log_printf ("{");
               gpgsm_dump_serial (keyid);
               log_printf ("} ");
             }
           if (authidno)
             {
               log_printf ("(#");
               gpgsm_dump_serial (authidno);
               log_printf ("/");
               gpgsm_dump_string (s);
               log_printf (") ");
             }
           log_printf ("not found using authorityKeyIdentifier\n");
         }
       else if (rc)
         log_error ("failed to find authorityKeyIdentifier: rc=%d\n", rc);
       xfree (keyid);
       ksba_name_release (authid);
       xfree (authidno);
     }
 
   if (rc) /* Not found via authorithyKeyIdentifier, try regular issuer name. */
     rc = keydb_search_subject (ctrl, kh, issuer);
   if (rc == -1 && !find_next)
     {
       int old;
 
       /* Also try to get it from the Dirmngr cache.  The function
          merely puts it into the ephemeral database.  */
       find_up_dirmngr (ctrl, kh, NULL, issuer, 0);
 
       /* Not found, let us see whether we have one in the ephemeral key DB. */
       old = keydb_set_ephemeral (kh, 1);
       if (!old)
         {
           keydb_search_reset (kh);
           rc = keydb_search_subject (ctrl, kh, issuer);
         }
       keydb_set_ephemeral (kh, old);
 
       if (!rc && DBG_X509)
         log_debug ("  found via issuer\n");
     }
 
   /* Still not found.  If enabled, try an external lookup.  */
   if (rc == -1 && opt.auto_issuer_key_retrieve && !find_next)
     {
       rc = find_up_external (ctrl, kh, issuer, NULL);
       if (!rc && DBG_X509)
         log_debug ("  found via issuer and external lookup\n");
     }
 
   return rc;
 }
 
 
 /* Return the next certificate up in the chain starting at START.
    Returns -1 when there are no more certificates. */
 int
 gpgsm_walk_cert_chain (ctrl_t ctrl, ksba_cert_t start, ksba_cert_t *r_next)
 {
   int rc = 0;
   char *issuer = NULL;
   char *subject = NULL;
   KEYDB_HANDLE kh = keydb_new ();
 
   *r_next = NULL;
   if (!kh)
     {
       log_error (_("failed to allocate keyDB handle\n"));
       rc = gpg_error (GPG_ERR_GENERAL);
       goto leave;
     }
 
   issuer = ksba_cert_get_issuer (start, 0);
   subject = ksba_cert_get_subject (start, 0);
   if (!issuer)
     {
       log_error ("no issuer found in certificate\n");
       rc = gpg_error (GPG_ERR_BAD_CERT);
       goto leave;
     }
   if (!subject)
     {
       log_error ("no subject found in certificate\n");
       rc = gpg_error (GPG_ERR_BAD_CERT);
       goto leave;
     }
 
   if (is_root_cert (start, issuer, subject))
     {
       rc = -1; /* we are at the root */
       goto leave;
     }
 
   rc = find_up (ctrl, kh, start, issuer, 0);
   if (rc)
     {
       /* It is quite common not to have a certificate, so better don't
          print an error here.  */
       if (rc != -1 && opt.verbose > 1)
         log_error ("failed to find issuer's certificate: rc=%d\n", rc);
       rc = gpg_error (GPG_ERR_MISSING_ISSUER_CERT);
       goto leave;
     }
 
   rc = keydb_get_cert (kh, r_next);
   if (rc)
     {
       log_error ("keydb_get_cert() failed: rc=%d\n", rc);
       rc = gpg_error (GPG_ERR_GENERAL);
     }
 
  leave:
   xfree (issuer);
   xfree (subject);
   keydb_release (kh);
   return rc;
 }
 
 
 /* Helper for gpgsm_is_root_cert.  This one is used if the subject and
    issuer DNs are already known.  */
 static int
 is_root_cert (ksba_cert_t cert, const char *issuerdn, const char *subjectdn)
 {
   gpg_error_t err;
   int result = 0;
   ksba_sexp_t serialno;
   ksba_sexp_t ak_keyid;
   ksba_name_t ak_name;
   ksba_sexp_t ak_sn;
   const char *ak_name_str;
   ksba_sexp_t subj_keyid = NULL;
 
   if (!issuerdn || !subjectdn)
     return 0;  /* No.  */
 
   if (strcmp (issuerdn, subjectdn))
     return 0;  /* No.  */
 
   err = ksba_cert_get_auth_key_id (cert, &ak_keyid, &ak_name, &ak_sn);
   if (err)
     {
       if (gpg_err_code (err) == GPG_ERR_NO_DATA)
         return 1; /* Yes. Without a authorityKeyIdentifier this needs
                      to be the Root certifcate (our trust anchor).  */
       log_error ("error getting authorityKeyIdentifier: %s\n",
                  gpg_strerror (err));
       return 0; /* Well, it is broken anyway.  Return No. */
     }
 
   serialno = ksba_cert_get_serial (cert);
   if (!serialno)
     {
       log_error ("error getting serialno: %s\n", gpg_strerror (err));
       goto leave;
     }
 
   /* Check whether the auth name's matches the issuer name+sn.  If
      that is the case this is a root certificate.  */
   ak_name_str = ksba_name_enum (ak_name, 0);
   if (ak_name_str
       && !strcmp (ak_name_str, issuerdn)
       && !cmp_simple_canon_sexp (ak_sn, serialno))
     {
       result = 1;  /* Right, CERT is self-signed.  */
       goto leave;
     }
 
   /* Similar for the ak_keyid. */
   if (ak_keyid && !ksba_cert_get_subj_key_id (cert, NULL, &subj_keyid)
       && !cmp_simple_canon_sexp (ak_keyid, subj_keyid))
     {
       result = 1;  /* Right, CERT is self-signed.  */
       goto leave;
     }
 
 
  leave:
   ksba_free (subj_keyid);
   ksba_free (ak_keyid);
   ksba_name_release (ak_name);
   ksba_free (ak_sn);
   ksba_free (serialno);
   return result;
 }
 
 
 
 /* Check whether the CERT is a root certificate.  Returns True if this
    is the case. */
 int
 gpgsm_is_root_cert (ksba_cert_t cert)
 {
   char *issuer;
   char *subject;
   int yes;
 
   issuer = ksba_cert_get_issuer (cert, 0);
   subject = ksba_cert_get_subject (cert, 0);
   yes = is_root_cert (cert, issuer, subject);
   xfree (issuer);
   xfree (subject);
   return yes;
 }
 
 
 /* This is a helper for gpgsm_validate_chain. */
 static gpg_error_t
 is_cert_still_valid (ctrl_t ctrl, int force_ocsp, int lm, estream_t fp,
                      ksba_cert_t subject_cert, ksba_cert_t issuer_cert,
                      int *any_revoked, int *any_no_crl, int *any_crl_too_old)
 {
   gpg_error_t err;
 
   if (ctrl->offline || (opt.no_crl_check && !ctrl->use_ocsp))
     {
       audit_log_ok (ctrl->audit, AUDIT_CRL_CHECK,
                     gpg_error (GPG_ERR_NOT_ENABLED));
       return 0;
     }
 
+
+  if (!(force_ocsp || ctrl->use_ocsp)
+      && !opt.enable_issuer_based_crl_check)
+    {
+      err = ksba_cert_get_crl_dist_point (subject_cert, 0, NULL, NULL, NULL);
+      if (gpg_err_code (err) == GPG_ERR_EOF)
+        {
+          /* No DP specified in the certificate.  Thus the CA does not
+           * consider a CRL useful and the user of the certificate
+           * also does not consider this to be a critical thing.  In
+           * this case we can conclude that the certificate shall not
+           * be revocable.  Note that we reach this point here only if
+           * no OCSP responder shall be used.  */
+          audit_log_ok (ctrl->audit, AUDIT_CRL_CHECK, gpg_error (GPG_ERR_TRUE));
+          return 0;
+        }
+    }
+
   err = gpgsm_dirmngr_isvalid (ctrl,
                                subject_cert, issuer_cert,
                                force_ocsp? 2 : !!ctrl->use_ocsp);
   audit_log_ok (ctrl->audit, AUDIT_CRL_CHECK, err);
 
   if (err)
     {
       if (!lm)
         gpgsm_cert_log_name (NULL, subject_cert);
       switch (gpg_err_code (err))
         {
         case GPG_ERR_CERT_REVOKED:
           do_list (1, lm, fp, _("certificate has been revoked"));
           *any_revoked = 1;
           /* Store that in the keybox so that key listings are able to
              return the revoked flag.  We don't care about error,
              though. */
           keydb_set_cert_flags (ctrl, subject_cert, 1, KEYBOX_FLAG_VALIDITY, 0,
                                 ~0, VALIDITY_REVOKED);
           break;
 
         case GPG_ERR_NO_CRL_KNOWN:
           do_list (1, lm, fp, _("no CRL found for certificate"));
           *any_no_crl = 1;
           break;
 
         case GPG_ERR_NO_DATA:
           do_list (1, lm, fp, _("the status of the certificate is unknown"));
           *any_no_crl = 1;
           break;
 
         case GPG_ERR_CRL_TOO_OLD:
           do_list (1, lm, fp, _("the available CRL is too old"));
           if (!lm)
             log_info (_("please make sure that the "
                         "\"dirmngr\" is properly installed\n"));
           *any_crl_too_old = 1;
           break;
 
         default:
           do_list (1, lm, fp, _("checking the CRL failed: %s"),
                    gpg_strerror (err));
           return err;
         }
     }
   return 0;
 }
 
 
 /* Helper for gpgsm_validate_chain to check the validity period of
    SUBJECT_CERT.  The caller needs to pass EXPTIME which will be
    updated to the nearest expiration time seen.  A DEPTH of 0 indicates
    the target certificate, -1 the final root certificate and other
    values intermediate certificates. */
 static gpg_error_t
 check_validity_period (ksba_isotime_t current_time,
                        ksba_cert_t subject_cert,
                        ksba_isotime_t exptime,
                        int listmode, estream_t listfp, int depth)
 {
   gpg_error_t err;
   ksba_isotime_t not_before, not_after;
 
   err = ksba_cert_get_validity (subject_cert, 0, not_before);
   if (!err)
     err = ksba_cert_get_validity (subject_cert, 1, not_after);
   if (err)
     {
       do_list (1, listmode, listfp,
                _("certificate with invalid validity: %s"), gpg_strerror (err));
       return gpg_error (GPG_ERR_BAD_CERT);
     }
 
   if (*not_after)
     {
       if (!*exptime)
         gnupg_copy_time (exptime, not_after);
       else if (strcmp (not_after, exptime) < 0 )
         gnupg_copy_time (exptime, not_after);
     }
 
   if (*not_before && strcmp (current_time, not_before) < 0 )
     {
       do_list (1, listmode, listfp,
                depth ==  0 ? _("certificate not yet valid") :
                depth == -1 ? _("root certificate not yet valid") :
                /* other */   _("intermediate certificate not yet valid"));
       if (!listmode)
         {
           log_info ("  (valid from ");
           dump_isotime (not_before);
           log_printf (")\n");
         }
       return gpg_error (GPG_ERR_CERT_TOO_YOUNG);
     }
 
   if (*not_after && strcmp (current_time, not_after) > 0 )
     {
       do_list (opt.ignore_expiration?0:1, listmode, listfp,
                depth == 0  ? _("certificate has expired") :
                depth == -1 ? _("root certificate has expired") :
                /* other  */  _("intermediate certificate has expired"));
       if (!listmode)
         {
           log_info ("  (expired at ");
           dump_isotime (not_after);
           log_printf (")\n");
         }
       if (opt.ignore_expiration)
         log_info ("WARNING: ignoring expiration\n");
       else
         return gpg_error (GPG_ERR_CERT_EXPIRED);
     }
 
   return 0;
 }
 
 /* This is a variant of check_validity_period used with the chain
    model.  The dextra contraint here is that notBefore and notAfter
    must exists and if the additional argument CHECK_TIME is given this
    time is used to check the validity period of SUBJECT_CERT.  */
 static gpg_error_t
 check_validity_period_cm (ksba_isotime_t current_time,
                           ksba_isotime_t check_time,
                           ksba_cert_t subject_cert,
                           ksba_isotime_t exptime,
                           int listmode, estream_t listfp, int depth)
 {
   gpg_error_t err;
   ksba_isotime_t not_before, not_after;
 
   err = ksba_cert_get_validity (subject_cert, 0, not_before);
   if (!err)
     err = ksba_cert_get_validity (subject_cert, 1, not_after);
   if (err)
     {
       do_list (1, listmode, listfp,
                _("certificate with invalid validity: %s"), gpg_strerror (err));
       return gpg_error (GPG_ERR_BAD_CERT);
     }
   if (!*not_before || !*not_after)
     {
       do_list (1, listmode, listfp,
                _("required certificate attributes missing: %s%s%s"),
                !*not_before? "notBefore":"",
                (!*not_before && !*not_after)? ", ":"",
                !*not_before? "notAfter":"");
       return gpg_error (GPG_ERR_BAD_CERT);
     }
   if (strcmp (not_before, not_after) > 0 )
     {
       do_list (1, listmode, listfp,
                _("certificate with invalid validity"));
       log_info ("  (valid from ");
       dump_isotime (not_before);
       log_printf (" expired at ");
       dump_isotime (not_after);
       log_printf (")\n");
       return gpg_error (GPG_ERR_BAD_CERT);
     }
 
   if (!*exptime)
     gnupg_copy_time (exptime, not_after);
   else if (strcmp (not_after, exptime) < 0 )
     gnupg_copy_time (exptime, not_after);
 
   if (strcmp (current_time, not_before) < 0 )
     {
       do_list (1, listmode, listfp,
                depth ==  0 ? _("certificate not yet valid") :
                depth == -1 ? _("root certificate not yet valid") :
                /* other */   _("intermediate certificate not yet valid"));
       if (!listmode)
         {
           log_info ("  (valid from ");
           dump_isotime (not_before);
           log_printf (")\n");
         }
       return gpg_error (GPG_ERR_CERT_TOO_YOUNG);
     }
 
   if (*check_time
       && (strcmp (check_time, not_before) < 0
           || strcmp (check_time, not_after) > 0))
     {
       /* Note that we don't need a case for the root certificate
          because its own consitency has already been checked.  */
       do_list(opt.ignore_expiration?0:1, listmode, listfp,
               depth == 0 ?
               _("signature not created during lifetime of certificate") :
               depth == 1 ?
               _("certificate not created during lifetime of issuer") :
               _("intermediate certificate not created during lifetime "
                 "of issuer"));
       if (!listmode)
         {
           log_info (depth== 0? _("  (  signature created at ") :
                     /* */      _("  (certificate created at ") );
           dump_isotime (check_time);
           log_printf (")\n");
           log_info (depth==0? _("  (certificate valid from ") :
                     /* */     _("  (     issuer valid from ") );
           dump_isotime (not_before);
           log_info (" to ");
           dump_isotime (not_after);
           log_printf (")\n");
         }
       if (opt.ignore_expiration)
         log_info ("WARNING: ignoring expiration\n");
       else
         return gpg_error (GPG_ERR_CERT_EXPIRED);
     }
 
   return 0;
 }
 
 
 
 /* Ask the user whether he wants to mark the certificate CERT trusted.
    Returns true if the CERT is the trusted.  We also check whether the
    agent is at all enabled to allow marktrusted and don't call it in
    this session again if it is not.  */
 static int
 ask_marktrusted (ctrl_t ctrl, ksba_cert_t cert, int listmode)
 {
   static int no_more_questions;
   int rc;
   char *fpr;
   int success = 0;
 
   fpr = gpgsm_get_fingerprint_string (cert, GCRY_MD_SHA1);
   log_info (_("fingerprint=%s\n"), fpr? fpr : "?");
   xfree (fpr);
 
   if (no_more_questions)
     rc = gpg_error (GPG_ERR_NOT_SUPPORTED);
   else
     rc = gpgsm_agent_marktrusted (ctrl, cert);
   if (!rc)
     {
       log_info (_("root certificate has now been marked as trusted\n"));
       success = 1;
     }
   else if (!listmode)
     {
       gpgsm_dump_cert ("issuer", cert);
       log_info ("after checking the fingerprint, you may want "
                 "to add it manually to the list of trusted certificates.\n");
     }
 
   if (gpg_err_code (rc) == GPG_ERR_NOT_SUPPORTED)
     {
       if (!no_more_questions)
         log_info (_("interactive marking as trusted "
                     "not enabled in gpg-agent\n"));
       no_more_questions = 1;
     }
   else if (gpg_err_code (rc) == GPG_ERR_CANCELED)
     {
       log_info (_("interactive marking as trusted "
                   "disabled for this session\n"));
       no_more_questions = 1;
     }
   else
     set_already_asked_marktrusted (cert);
 
   return success;
 }
 
 
 
 
 /* Validate a chain and optionally return the nearest expiration time
    in R_EXPTIME. With LISTMODE set to 1 a special listmode is
    activated where only information about the certificate is printed
    to LISTFP and no output is send to the usual log stream.  If
    CHECKTIME_ARG is set, it is used only in the chain model instead of the
    current time.
 
    Defined flag bits
 
    VALIDATE_FLAG_NO_DIRMNGR  - Do not do any dirmngr isvalid checks.
    VALIDATE_FLAG_CHAIN_MODEL - Check according to chain model.
    VALIDATE_FLAG_STEED       - Check according to the STEED model.
 */
 static int
 do_validate_chain (ctrl_t ctrl, ksba_cert_t cert, ksba_isotime_t checktime_arg,
                    ksba_isotime_t r_exptime,
                    int listmode, estream_t listfp, unsigned int flags,
                    struct rootca_flags_s *rootca_flags)
 {
   int rc = 0, depth, maxdepth;
   char *issuer = NULL;
   char *subject = NULL;
   KEYDB_HANDLE kh = NULL;
   ksba_cert_t subject_cert = NULL, issuer_cert = NULL;
   ksba_isotime_t current_time;
   ksba_isotime_t check_time;
   ksba_isotime_t exptime;
   int any_expired = 0;
   int any_revoked = 0;
   int any_no_crl = 0;
   int any_crl_too_old = 0;
   int any_no_policy_match = 0;
   int is_qualified = -1; /* Indicates whether the certificate stems
                             from a qualified root certificate.
                             -1 = unknown, 0 = no, 1 = yes. */
   chain_item_t chain = NULL; /* A list of all certificates in the chain.  */
 
 
   gnupg_get_isotime (current_time);
   gnupg_copy_time (ctrl->current_time, current_time);
 
   if ( (flags & VALIDATE_FLAG_CHAIN_MODEL) )
     {
       if (!strcmp (checktime_arg, "19700101T000000"))
         {
           do_list (1, listmode, listfp,
                    _("WARNING: creation time of signature not known - "
                      "assuming current time"));
           gnupg_copy_time (check_time, current_time);
         }
       else
         gnupg_copy_time (check_time, checktime_arg);
     }
   else
     *check_time = 0;
 
   if (r_exptime)
     *r_exptime = 0;
   *exptime = 0;
 
   if (opt.no_chain_validation && !listmode)
     {
       log_info ("WARNING: bypassing certificate chain validation\n");
       return 0;
     }
 
   kh = keydb_new ();
   if (!kh)
     {
       log_error (_("failed to allocate keyDB handle\n"));
       rc = gpg_error (GPG_ERR_GENERAL);
       goto leave;
     }
 
   if (DBG_X509 && !listmode)
     gpgsm_dump_cert ("target", cert);
 
   subject_cert = cert;
   ksba_cert_ref (subject_cert);
   maxdepth = 50;
   depth = 0;
 
   for (;;)
     {
       int is_root;
       gpg_error_t istrusted_rc = -1;
 
       /* Put the certificate on our list.  */
       {
         chain_item_t ci;
 
         ci = xtrycalloc (1, sizeof *ci);
         if (!ci)
           {
             rc = gpg_error_from_syserror ();
             goto leave;
           }
         ksba_cert_ref (subject_cert);
         ci->cert = subject_cert;
         ci->next = chain;
         chain = ci;
       }
 
       xfree (issuer);
       xfree (subject);
       issuer = ksba_cert_get_issuer (subject_cert, 0);
       subject = ksba_cert_get_subject (subject_cert, 0);
 
       if (!issuer)
         {
           do_list (1, listmode, listfp,  _("no issuer found in certificate"));
           rc = gpg_error (GPG_ERR_BAD_CERT);
           goto leave;
         }
 
 
       /* Is this a self-issued certificate (i.e. the root certificate)?  */
       is_root = is_root_cert (subject_cert, issuer, subject);
       if (is_root)
         {
           chain->is_root = 1;
           /* Check early whether the certificate is listed as trusted.
              We used to do this only later but changed it to call the
              check right here so that we can access special flags
              associated with that specific root certificate.  */
           if (gpgsm_cert_has_well_known_private_key (subject_cert))
             {
               memset (rootca_flags, 0, sizeof *rootca_flags);
               istrusted_rc = ((flags & VALIDATE_FLAG_STEED)
                               ? 0 : gpg_error (GPG_ERR_NOT_TRUSTED));
             }
           else
             istrusted_rc = gpgsm_agent_istrusted (ctrl, subject_cert, NULL,
                                                   rootca_flags);
           audit_log_cert (ctrl->audit, AUDIT_ROOT_TRUSTED,
                           subject_cert, istrusted_rc);
           /* If the chain model extended attribute is used, make sure
              that our chain model flag is set. */
           if (!(flags & VALIDATE_FLAG_STEED)
               && has_validation_model_chain (subject_cert, listmode, listfp))
             rootca_flags->chain_model = 1;
         }
 
 
       /* Check the validity period. */
       if ( (flags & VALIDATE_FLAG_CHAIN_MODEL) )
         rc = check_validity_period_cm (current_time, check_time, subject_cert,
                                        exptime, listmode, listfp,
                                        (depth && is_root)? -1: depth);
       else
         rc = check_validity_period (current_time, subject_cert,
                                     exptime, listmode, listfp,
                                     (depth && is_root)? -1: depth);
       if (gpg_err_code (rc) == GPG_ERR_CERT_EXPIRED)
         any_expired = 1;
       else if (rc)
         goto leave;
 
 
       /* Assert that we understand all critical extensions. */
       rc = unknown_criticals (subject_cert, listmode, listfp);
       if (rc)
         goto leave;
 
       /* Do a policy check. */
       if (!opt.no_policy_check)
         {
           rc = check_cert_policy (subject_cert, listmode, listfp);
           if (gpg_err_code (rc) == GPG_ERR_NO_POLICY_MATCH)
             {
               any_no_policy_match = 1;
               rc = 1;  /* Be on the safe side and set RC.  */
             }
           else if (rc)
             goto leave;
         }
 
 
       /* If this is the root certificate we are at the end of the chain.  */
       if (is_root)
         {
           if (!istrusted_rc)
             ; /* No need to check the certificate for a trusted one. */
           else if (gpgsm_check_cert_sig (subject_cert, subject_cert) )
             {
               /* We only check the signature if the certificate is not
                  trusted for better diagnostics. */
               do_list (1, listmode, listfp,
                        _("self-signed certificate has a BAD signature"));
               if (DBG_X509)
                 {
                   gpgsm_dump_cert ("self-signing cert", subject_cert);
                 }
               rc = gpg_error (depth? GPG_ERR_BAD_CERT_CHAIN
                                    : GPG_ERR_BAD_CERT);
               goto leave;
             }
           if (!rootca_flags->relax)
             {
               rc = allowed_ca (ctrl, subject_cert, NULL, listmode, listfp);
               if (rc)
                 goto leave;
             }
 
 
           /* Set the flag for qualified signatures.  This flag is
              deduced from a list of root certificates allowed for
              qualified signatures. */
           if (is_qualified == -1 && !(flags & VALIDATE_FLAG_STEED))
             {
               gpg_error_t err;
               size_t buflen;
               char buf[1];
 
               if (!ksba_cert_get_user_data (cert, "is_qualified",
                                             &buf, sizeof (buf),
                                             &buflen) && buflen)
                 {
                   /* We already checked this for this certificate,
                      thus we simply take it from the user data. */
                   is_qualified = !!*buf;
                 }
               else
                 {
                   /* Need to consult the list of root certificates for
                      qualified signatures. */
                   err = gpgsm_is_in_qualified_list (ctrl, subject_cert, NULL);
                   if (!err)
                     is_qualified = 1;
                   else if ( gpg_err_code (err) == GPG_ERR_NOT_FOUND)
                     is_qualified = 0;
                   else
                     log_error ("checking the list of qualified "
                                "root certificates failed: %s\n",
                                gpg_strerror (err));
                   if ( is_qualified != -1 )
                     {
                       /* Cache the result but don't care too much
                          about an error. */
                       buf[0] = !!is_qualified;
                       err = ksba_cert_set_user_data (subject_cert,
                                                      "is_qualified", buf, 1);
                       if (err)
                         log_error ("set_user_data(is_qualified) failed: %s\n",
                                    gpg_strerror (err));
                     }
                 }
             }
 
 
           /* Act on the check for a trusted root certificates. */
           rc = istrusted_rc;
           if (!rc)
             ;
           else if (gpg_err_code (rc) == GPG_ERR_NOT_TRUSTED)
             {
               do_list (0, listmode, listfp,
                        _("root certificate is not marked trusted"));
               /* If we already figured out that the certificate is
                  expired it does not make much sense to ask the user
                  whether they want to trust the root certificate.  We
                  should do this only if the certificate under question
                  will then be usable.  If the certificate has a well
                  known private key asking the user does not make any
                  sense.  */
               if ( !any_expired
                    && !gpgsm_cert_has_well_known_private_key (subject_cert)
                    && (!listmode || !already_asked_marktrusted (subject_cert))
                    && ask_marktrusted (ctrl, subject_cert, listmode) )
                 rc = 0;
             }
           else
             {
               log_error (_("checking the trust list failed: %s\n"),
                          gpg_strerror (rc));
             }
 
           if (rc)
             goto leave;
 
           /* Check for revocations etc. */
           if ((flags & VALIDATE_FLAG_NO_DIRMNGR))
             ;
           else if ((flags & VALIDATE_FLAG_STEED))
             ; /* Fixme: check revocations via DNS.  */
           else if (opt.no_trusted_cert_crl_check || rootca_flags->relax)
             ;
           else
             rc = is_cert_still_valid (ctrl,
                                       (flags & VALIDATE_FLAG_CHAIN_MODEL),
                                       listmode, listfp,
                                       subject_cert, subject_cert,
                                       &any_revoked, &any_no_crl,
                                       &any_crl_too_old);
           if (rc)
             goto leave;
 
           break;  /* Okay: a self-signed certicate is an end-point. */
         } /* End is_root.  */
 
 
       /* Take care that the chain does not get too long. */
       if ((depth+1) > maxdepth)
         {
           do_list (1, listmode, listfp, _("certificate chain too long\n"));
           rc = gpg_error (GPG_ERR_BAD_CERT_CHAIN);
           goto leave;
         }
 
       /* Find the next cert up the tree. */
       keydb_search_reset (kh);
       rc = find_up (ctrl, kh, subject_cert, issuer, 0);
       if (rc)
         {
           if (rc == -1)
             {
               do_list (0, listmode, listfp, _("issuer certificate not found"));
               if (!listmode)
                 {
                   log_info ("issuer certificate: #/");
                   gpgsm_dump_string (issuer);
                   log_printf ("\n");
                 }
             }
           else
             log_error ("failed to find issuer's certificate: rc=%d\n", rc);
           rc = gpg_error (GPG_ERR_MISSING_ISSUER_CERT);
           goto leave;
         }
 
       ksba_cert_release (issuer_cert); issuer_cert = NULL;
       rc = keydb_get_cert (kh, &issuer_cert);
       if (rc)
         {
           log_error ("keydb_get_cert() failed: rc=%d\n", rc);
           rc = gpg_error (GPG_ERR_GENERAL);
           goto leave;
         }
 
     try_another_cert:
       if (DBG_X509)
         {
           log_debug ("got issuer's certificate:\n");
           gpgsm_dump_cert ("issuer", issuer_cert);
         }
 
       rc = gpgsm_check_cert_sig (issuer_cert, subject_cert);
       if (rc)
         {
           do_list (0, listmode, listfp, _("certificate has a BAD signature"));
           if (DBG_X509)
             {
               gpgsm_dump_cert ("signing issuer", issuer_cert);
               gpgsm_dump_cert ("signed subject", subject_cert);
             }
           if (gpg_err_code (rc) == GPG_ERR_BAD_SIGNATURE)
             {
               /* We now try to find other issuer certificates which
                  might have been used.  This is required because some
                  CAs are reusing the issuer and subject DN for new
                  root certificates. */
               /* FIXME: Do this only if we don't have an
                  AKI.keyIdentifier */
               rc = find_up (ctrl, kh, subject_cert, issuer, 1);
               if (!rc)
                 {
                   ksba_cert_t tmp_cert;
 
                   rc = keydb_get_cert (kh, &tmp_cert);
                   if (rc || !compare_certs (issuer_cert, tmp_cert))
                     {
                       /* The find next did not work or returned an
                          identical certificate.  We better stop here
                          to avoid infinite checks. */
                       /* No need to set RC because it is not used:
                          rc = gpg_error (GPG_ERR_BAD_SIGNATURE);  */
                       ksba_cert_release (tmp_cert);
                     }
                   else
                     {
                       do_list (0, listmode, listfp,
                                _("found another possible matching "
                                  "CA certificate - trying again"));
                       ksba_cert_release (issuer_cert);
                       issuer_cert = tmp_cert;
                       goto try_another_cert;
                     }
                 }
             }
 
           /* We give a more descriptive error code than the one
              returned from the signature checking. */
           rc = gpg_error (GPG_ERR_BAD_CERT_CHAIN);
           goto leave;
         }
 
       is_root = gpgsm_is_root_cert (issuer_cert);
       istrusted_rc = -1;
 
 
       /* Check that a CA is allowed to issue certificates. */
       {
         int chainlen;
 
         rc = allowed_ca (ctrl, issuer_cert, &chainlen, listmode, listfp);
         if (rc)
           {
             /* Not allowed.  Check whether this is a trusted root
                certificate and whether we allow special exceptions.
                We could carry the result of the test over to the
                regular root check at the top of the loop but for
                clarity we won't do that.  Given that the majority of
                certificates carry proper BasicContraints our way of
                overriding an error in the way is justified for
                performance reasons. */
             if (is_root)
               {
                 if (gpgsm_cert_has_well_known_private_key (issuer_cert))
                   {
                     memset (rootca_flags, 0, sizeof *rootca_flags);
                     istrusted_rc = ((flags & VALIDATE_FLAG_STEED)
                                     ? 0 : gpg_error (GPG_ERR_NOT_TRUSTED));
                   }
                 else
                   istrusted_rc = gpgsm_agent_istrusted
                     (ctrl, issuer_cert, NULL, rootca_flags);
 
                 if (!istrusted_rc && rootca_flags->relax)
                   {
                     /* Ignore the error due to the relax flag.  */
                     rc = 0;
                     chainlen = -1;
                   }
               }
           }
         if (rc)
           goto leave;
         if (chainlen >= 0 && depth > chainlen)
           {
             do_list (1, listmode, listfp,
                      _("certificate chain longer than allowed by CA (%d)"),
                      chainlen);
             rc = gpg_error (GPG_ERR_BAD_CERT_CHAIN);
             goto leave;
           }
       }
 
       /* Is the certificate allowed to sign other certificates. */
       if (!listmode)
         {
           rc = gpgsm_cert_use_cert_p (issuer_cert);
           if (rc)
             {
               char numbuf[50];
               sprintf (numbuf, "%d", rc);
               gpgsm_status2 (ctrl, STATUS_ERROR, "certcert.issuer.keyusage",
                              numbuf, NULL);
               goto leave;
             }
         }
 
       /* Check for revocations etc.  Note that for a root certificate
          this test is done a second time later. This should eventually
          be fixed. */
       if ((flags & VALIDATE_FLAG_NO_DIRMNGR))
         rc = 0;
       else if ((flags & VALIDATE_FLAG_STEED))
         rc = 0; /* Fixme: XXX */
       else if (is_root && (opt.no_trusted_cert_crl_check
                            || (!istrusted_rc && rootca_flags->relax)))
         rc = 0;
       else
         rc = is_cert_still_valid (ctrl,
                                   (flags & VALIDATE_FLAG_CHAIN_MODEL),
                                   listmode, listfp,
                                   subject_cert, issuer_cert,
                                   &any_revoked, &any_no_crl, &any_crl_too_old);
       if (rc)
         goto leave;
 
 
       if (opt.verbose && !listmode)
         log_info (depth == 0 ? _("certificate is good\n") :
                   !is_root   ? _("intermediate certificate is good\n") :
                   /* other */  _("root certificate is good\n"));
 
       /* Under the chain model the next check time is the creation
          time of the subject certificate.  */
       if ( (flags & VALIDATE_FLAG_CHAIN_MODEL) )
         {
           rc = ksba_cert_get_validity (subject_cert, 0, check_time);
           if (rc)
             {
               /* That will never happen as we have already checked
                  this above.  */
               BUG ();
             }
         }
 
       /* For the next round the current issuer becomes the new subject.  */
       keydb_search_reset (kh);
       ksba_cert_release (subject_cert);
       subject_cert = issuer_cert;
       issuer_cert = NULL;
       depth++;
     } /* End chain traversal. */
 
   if (!listmode && !opt.quiet)
     {
       if (opt.no_policy_check)
         log_info ("policies not checked due to %s option\n",
                   "--disable-policy-checks");
       if (ctrl->offline || (opt.no_crl_check && !ctrl->use_ocsp))
         log_info ("CRLs not checked due to %s option\n",
                   ctrl->offline ? "offline" : "--disable-crl-checks");
     }
 
   if (!rc)
     { /* If we encountered an error somewhere during the checks, set
          the error code to the most critical one */
       if (any_revoked)
         rc = gpg_error (GPG_ERR_CERT_REVOKED);
       else if (any_expired)
         rc = gpg_error (GPG_ERR_CERT_EXPIRED);
       else if (any_no_crl)
         rc = gpg_error (GPG_ERR_NO_CRL_KNOWN);
       else if (any_crl_too_old)
         rc = gpg_error (GPG_ERR_CRL_TOO_OLD);
       else if (any_no_policy_match)
         rc = gpg_error (GPG_ERR_NO_POLICY_MATCH);
     }
 
  leave:
   /* If we have traversed a complete chain up to the root we will
      reset the ephemeral flag for all these certificates.  This is done
      regardless of any error because those errors may only be
      transient. */
   if (chain && chain->is_root)
     {
       gpg_error_t err;
       chain_item_t ci;
 
       for (ci = chain; ci; ci = ci->next)
         {
           /* Note that it is possible for the last certificate in the
              chain (i.e. our target certificate) that it has not yet
              been stored in the keybox and thus the flag can't be set.
              We ignore this error because it will later be stored
              anyway.  */
           err = keydb_set_cert_flags (ctrl, ci->cert, 1, KEYBOX_FLAG_BLOB, 0,
                                       KEYBOX_FLAG_BLOB_EPHEMERAL, 0);
           if (!ci->next && gpg_err_code (err) == GPG_ERR_NOT_FOUND)
             ;
           else if (err)
             log_error ("clearing ephemeral flag failed: %s\n",
                        gpg_strerror (err));
         }
     }
 
   /* If we have figured something about the qualified signature
      capability of the certificate under question, store the result as
      user data in all certificates of the chain.  We do this even if the
      validation itself failed.  */
   if (is_qualified != -1 && !(flags & VALIDATE_FLAG_STEED))
     {
       gpg_error_t err;
       chain_item_t ci;
       char buf[1];
 
       buf[0] = !!is_qualified;
 
       for (ci = chain; ci; ci = ci->next)
         {
           err = ksba_cert_set_user_data (ci->cert, "is_qualified", buf, 1);
           if (err)
             {
               log_error ("set_user_data(is_qualified) failed: %s\n",
                          gpg_strerror (err));
               if (!rc)
                 rc = err;
             }
         }
     }
 
   /* If auditing has been enabled, record what is in the chain.  */
   if (ctrl->audit)
     {
       chain_item_t ci;
 
       audit_log (ctrl->audit, AUDIT_CHAIN_BEGIN);
       for (ci = chain; ci; ci = ci->next)
         {
           audit_log_cert (ctrl->audit,
                           ci->is_root? AUDIT_CHAIN_ROOTCERT : AUDIT_CHAIN_CERT,
                           ci->cert, 0);
         }
       audit_log (ctrl->audit, AUDIT_CHAIN_END);
     }
 
   if (r_exptime)
     gnupg_copy_time (r_exptime, exptime);
   xfree (issuer);
   xfree (subject);
   keydb_release (kh);
   while (chain)
     {
       chain_item_t ci_next = chain->next;
       ksba_cert_release (chain->cert);
       xfree (chain);
       chain = ci_next;
     }
   ksba_cert_release (issuer_cert);
   ksba_cert_release (subject_cert);
   return rc;
 }
 
 
 /* Validate a certificate chain.  For a description see
    do_validate_chain.  This function is a wrapper to handle a root
    certificate with the chain_model flag set.  If RETFLAGS is not
    NULL, flags indicating now the verification was done are stored
    there.  The only defined vits for RETFLAGS are
    VALIDATE_FLAG_CHAIN_MODEL and VALIDATE_FLAG_STEED.
 
    If you are verifying a signature you should set CHECKTIME to the
    creation time of the signature.  If your are verifying a
    certificate, set it nil (i.e. the empty string).  If the creation
    date of the signature is not known use the special date
    "19700101T000000" which is treated in a special way here. */
 int
 gpgsm_validate_chain (ctrl_t ctrl, ksba_cert_t cert, ksba_isotime_t checktime,
                       ksba_isotime_t r_exptime,
                       int listmode, estream_t listfp, unsigned int flags,
                       unsigned int *retflags)
 {
   int rc;
   struct rootca_flags_s rootca_flags;
   unsigned int dummy_retflags;
 
   if (!retflags)
     retflags = &dummy_retflags;
 
   /* If the session requested a certain validation mode make sure the
      corresponding flags are set.  */
   if (ctrl->validation_model == 1)
     flags |= VALIDATE_FLAG_CHAIN_MODEL;
   else if (ctrl->validation_model == 2)
     flags |= VALIDATE_FLAG_STEED;
 
   /* If the chain model was forced, set this immediately into
      RETFLAGS.  */
   *retflags = (flags & VALIDATE_FLAG_CHAIN_MODEL);
 
   memset (&rootca_flags, 0, sizeof rootca_flags);
 
   rc = do_validate_chain (ctrl, cert, checktime,
                           r_exptime, listmode, listfp, flags,
                           &rootca_flags);
   if (!rc && (flags & VALIDATE_FLAG_STEED))
     {
       *retflags |= VALIDATE_FLAG_STEED;
     }
   else if (gpg_err_code (rc) == GPG_ERR_CERT_EXPIRED
       && !(flags & VALIDATE_FLAG_CHAIN_MODEL)
       && (rootca_flags.valid && rootca_flags.chain_model))
     {
       do_list (0, listmode, listfp, _("switching to chain model"));
       rc = do_validate_chain (ctrl, cert, checktime,
                               r_exptime, listmode, listfp,
                               (flags |= VALIDATE_FLAG_CHAIN_MODEL),
                               &rootca_flags);
       *retflags |= VALIDATE_FLAG_CHAIN_MODEL;
     }
 
   if (opt.verbose)
     do_list (0, listmode, listfp, _("validation model used: %s"),
              (*retflags & VALIDATE_FLAG_STEED)?
              "steed" :
              (*retflags & VALIDATE_FLAG_CHAIN_MODEL)?
              _("chain"):_("shell"));
 
   return rc;
 }
 
 
 /* Check that the given certificate is valid but DO NOT check any
    constraints.  We assume that the issuers certificate is already in
    the DB and that this one is valid; which it should be because it
    has been checked using this function. */
 int
 gpgsm_basic_cert_check (ctrl_t ctrl, ksba_cert_t cert)
 {
   int rc = 0;
   char *issuer = NULL;
   char *subject = NULL;
   KEYDB_HANDLE kh;
   ksba_cert_t issuer_cert = NULL;
 
   if (opt.no_chain_validation)
     {
       log_info ("WARNING: bypassing basic certificate checks\n");
       return 0;
     }
 
   kh = keydb_new ();
   if (!kh)
     {
       log_error (_("failed to allocate keyDB handle\n"));
       rc = gpg_error (GPG_ERR_GENERAL);
       goto leave;
     }
 
   issuer = ksba_cert_get_issuer (cert, 0);
   subject = ksba_cert_get_subject (cert, 0);
   if (!issuer)
     {
       log_error ("no issuer found in certificate\n");
       rc = gpg_error (GPG_ERR_BAD_CERT);
       goto leave;
     }
 
   if (is_root_cert (cert, issuer, subject))
     {
       rc = gpgsm_check_cert_sig (cert, cert);
       if (rc)
         {
           log_error ("self-signed certificate has a BAD signature: %s\n",
                      gpg_strerror (rc));
           if (DBG_X509)
             {
               gpgsm_dump_cert ("self-signing cert", cert);
             }
           rc = gpg_error (GPG_ERR_BAD_CERT);
           goto leave;
         }
     }
   else
     {
       /* Find the next cert up the tree. */
       keydb_search_reset (kh);
       rc = find_up (ctrl, kh, cert, issuer, 0);
       if (rc)
         {
           if (rc == -1)
             {
               log_info ("issuer certificate (#/");
               gpgsm_dump_string (issuer);
               log_printf (") not found\n");
             }
           else
             log_error ("failed to find issuer's certificate: rc=%d\n", rc);
           rc = gpg_error (GPG_ERR_MISSING_ISSUER_CERT);
           goto leave;
         }
 
       ksba_cert_release (issuer_cert); issuer_cert = NULL;
       rc = keydb_get_cert (kh, &issuer_cert);
       if (rc)
         {
           log_error ("keydb_get_cert() failed: rc=%d\n", rc);
           rc = gpg_error (GPG_ERR_GENERAL);
           goto leave;
         }
 
       rc = gpgsm_check_cert_sig (issuer_cert, cert);
       if (rc)
         {
           log_error ("certificate has a BAD signature: %s\n",
                      gpg_strerror (rc));
           if (DBG_X509)
             {
               gpgsm_dump_cert ("signing issuer", issuer_cert);
               gpgsm_dump_cert ("signed subject", cert);
             }
           rc = gpg_error (GPG_ERR_BAD_CERT);
           goto leave;
         }
       if (opt.verbose)
         log_info (_("certificate is good\n"));
     }
 
  leave:
   xfree (issuer);
   xfree (subject);
   keydb_release (kh);
   ksba_cert_release (issuer_cert);
   return rc;
 }
 
 
 
 /* Check whether the certificate CERT has been issued by the German
    authority for qualified signature.  They do not set the
    basicConstraints and thus we need this workaround.  It works by
    looking up the root certificate and checking whether that one is
    listed as a qualified certificate for Germany.
 
    We also try to cache this data but as long as don't keep a
    reference to the certificate this won't be used.
 
    Returns: True if CERT is a RegTP issued CA cert (i.e. the root
    certificate itself or one of the CAs).  In that case CHAINLEN will
    receive the length of the chain which is either 0 or 1.
 */
 static int
 get_regtp_ca_info (ctrl_t ctrl, ksba_cert_t cert, int *chainlen)
 {
   gpg_error_t err;
   ksba_cert_t next;
   int rc = 0;
   int i, depth;
   char country[3];
   ksba_cert_t array[4];
   char buf[2];
   size_t buflen;
   int dummy_chainlen;
 
   if (!chainlen)
     chainlen = &dummy_chainlen;
 
   *chainlen = 0;
   err = ksba_cert_get_user_data (cert, "regtp_ca_chainlen",
                                  &buf, sizeof (buf), &buflen);
   if (!err)
     {
       /* Got info. */
       if (buflen < 2 || !*buf)
         return 0; /* Nothing found. */
       *chainlen = buf[1];
       return 1; /* This is a regtp CA. */
     }
   else if (gpg_err_code (err) != GPG_ERR_NOT_FOUND)
     {
       log_error ("ksba_cert_get_user_data(%s) failed: %s\n",
                  "regtp_ca_chainlen", gpg_strerror (err));
       return 0; /* Nothing found.  */
     }
 
   /* Need to gather the info.  This requires to walk up the chain
      until we have found the root.  Because we are only interested in
      German Bundesnetzagentur (former RegTP) derived certificates 3
      levels are enough.  (The German signature law demands a 3 tier
      hierarchy; thus there is only one CA between the EE and the Root
      CA.)  */
   memset (&array, 0, sizeof array);
 
   depth = 0;
   ksba_cert_ref (cert);
   array[depth++] = cert;
   ksba_cert_ref (cert);
   while (depth < DIM(array) && !(rc=gpgsm_walk_cert_chain (ctrl, cert, &next)))
     {
       ksba_cert_release (cert);
       ksba_cert_ref (next);
       array[depth++] = next;
       cert = next;
     }
   ksba_cert_release (cert);
   if (rc != -1 || !depth || depth == DIM(array) )
     {
       /* We did not reached the root. */
       goto leave;
     }
 
   /* If this is a German signature law issued certificate, we store
      additional information. */
   if (!gpgsm_is_in_qualified_list (NULL, array[depth-1], country)
       && !strcmp (country, "de"))
     {
       /* Setting the pathlen for the root CA and the CA flag for the
          next one is all what we need to do. */
       err = ksba_cert_set_user_data (array[depth-1], "regtp_ca_chainlen",
                                      "\x01\x01", 2);
       if (!err && depth > 1)
         err = ksba_cert_set_user_data (array[depth-2], "regtp_ca_chainlen",
                                        "\x01\x00", 2);
       if (err)
         log_error ("ksba_set_user_data(%s) failed: %s\n",
                    "regtp_ca_chainlen", gpg_strerror (err));
       for (i=0; i < depth; i++)
         ksba_cert_release (array[i]);
       *chainlen = (depth>1? 0:1);
       return 1;
     }
 
  leave:
   /* Nothing special with this certificate. Mark the target
      certificate anyway to avoid duplicate lookups. */
   err = ksba_cert_set_user_data (cert, "regtp_ca_chainlen", "", 1);
   if (err)
     log_error ("ksba_set_user_data(%s) failed: %s\n",
                "regtp_ca_chainlen", gpg_strerror (err));
   for (i=0; i < depth; i++)
     ksba_cert_release (array[i]);
   return 0;
 }
diff --git a/sm/gpgsm.c b/sm/gpgsm.c
index 387e4d2e4..bb2767283 100644
--- a/sm/gpgsm.c
+++ b/sm/gpgsm.c
@@ -1,2314 +1,2320 @@
 /* gpgsm.c - GnuPG for S/MIME
  * Copyright (C) 2001-2008, 2010  Free Software Foundation, Inc.
  * Copyright (C) 2001-2008, 2010  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 <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <ctype.h>
 #include <unistd.h>
 #include <fcntl.h>
 /*#include <mcheck.h>*/
 
 #define INCLUDED_BY_MAIN_MODULE 1
 
 #include "gpgsm.h"
 #include <gcrypt.h>
 #include <assuan.h> /* malloc hooks */
 
 #include "passphrase.h"
 #include "../common/shareddefs.h"
 #include "../kbx/keybox.h" /* malloc hooks */
 #include "../common/i18n.h"
 #include "keydb.h"
 #include "../common/sysutils.h"
 #include "../common/gc-opt-flags.h"
 #include "../common/asshelp.h"
 #include "../common/init.h"
 #include "../common/compliance.h"
 
 
 #ifndef O_BINARY
 #define O_BINARY 0
 #endif
 
 enum cmd_and_opt_values {
   aNull = 0,
   oArmor        = 'a',
   aDetachedSign = 'b',
   aSym	        = 'c',
   aDecrypt	= 'd',
   aEncr	        = 'e',
   aListKeys	= 'k',
   aListSecretKeys = 'K',
   oDryRun	= 'n',
   oOutput	= 'o',
   oQuiet	= 'q',
   oRecipient	= 'r',
   aSign	        = 's',
   oUser	        = 'u',
   oVerbose	= 'v',
   oBatch	= 500,
   aClearsign,
   aKeygen,
   aSignEncr,
   aDeleteKey,
   aImport,
   aVerify,
   aListExternalKeys,
   aListChain,
   aSendKeys,
   aRecvKeys,
   aExport,
   aExportSecretKeyP12,
   aExportSecretKeyP8,
   aExportSecretKeyRaw,
   aServer,
   aLearnCard,
   aCallDirmngr,
   aCallProtectTool,
   aPasswd,
   aGPGConfList,
   aGPGConfTest,
   aDumpKeys,
   aDumpChain,
   aDumpSecretKeys,
   aDumpExternalKeys,
   aKeydbClearSomeCertFlags,
   aFingerprint,
 
   oOptions,
   oDebug,
   oDebugLevel,
   oDebugAll,
   oDebugNone,
   oDebugWait,
   oDebugAllowCoreDump,
   oDebugNoChainValidation,
   oDebugIgnoreExpiration,
   oLogFile,
   oNoLogFile,
   oAuditLog,
   oHtmlAuditLog,
 
   oEnableSpecialFilenames,
 
   oAgentProgram,
   oDisplay,
   oTTYname,
   oTTYtype,
   oLCctype,
   oLCmessages,
   oXauthority,
 
   oPreferSystemDirmngr,
   oDirmngrProgram,
   oDisableDirmngr,
   oProtectToolProgram,
   oFakedSystemTime,
 
   oPassphraseFD,
   oPinentryMode,
   oRequestOrigin,
 
   oAssumeArmor,
   oAssumeBase64,
   oAssumeBinary,
 
   oBase64,
   oNoArmor,
   oP12Charset,
 
   oCompliance,
 
   oDisableCRLChecks,
   oEnableCRLChecks,
   oDisableTrustedCertCRLCheck,
   oEnableTrustedCertCRLCheck,
   oForceCRLRefresh,
+  oEnableIssuerBasedCRLCheck,
 
   oDisableOCSP,
   oEnableOCSP,
 
   oIncludeCerts,
   oPolicyFile,
   oDisablePolicyChecks,
   oEnablePolicyChecks,
   oAutoIssuerKeyRetrieve,
 
   oWithFingerprint,
   oWithMD5Fingerprint,
   oWithKeygrip,
   oWithSecret,
   oAnswerYes,
   oAnswerNo,
   oKeyring,
   oDefaultKey,
   oDefRecipient,
   oDefRecipientSelf,
   oNoDefRecipient,
   oStatusFD,
   oCipherAlgo,
   oDigestAlgo,
   oExtraDigestAlgo,
   oNoVerbose,
   oNoSecmemWarn,
   oNoDefKeyring,
   oNoGreeting,
   oNoTTY,
   oNoOptions,
   oNoBatch,
   oHomedir,
   oWithColons,
   oWithKeyData,
   oWithValidation,
   oWithEphemeralKeys,
   oSkipVerify,
   oValidationModel,
   oKeyServer,
   oEncryptTo,
   oNoEncryptTo,
   oLoggerFD,
   oDisableCipherAlgo,
   oDisablePubkeyAlgo,
   oIgnoreTimeConflict,
   oNoRandomSeedFile,
   oNoCommonCertsImport,
   oIgnoreCertExtension,
   oNoAutostart
  };
 
 
 static ARGPARSE_OPTS opts[] = {
 
   ARGPARSE_group (300, N_("@Commands:\n ")),
 
   ARGPARSE_c (aSign, "sign", N_("make a signature")),
 /*ARGPARSE_c (aClearsign, "clearsign", N_("make a clear text signature") ),*/
   ARGPARSE_c (aDetachedSign, "detach-sign", N_("make a detached signature")),
   ARGPARSE_c (aEncr, "encrypt", N_("encrypt data")),
 /*ARGPARSE_c (aSym, "symmetric", N_("encryption only with symmetric cipher")),*/
   ARGPARSE_c (aDecrypt, "decrypt", N_("decrypt data (default)")),
   ARGPARSE_c (aVerify, "verify",  N_("verify a signature")),
   ARGPARSE_c (aListKeys, "list-keys", N_("list keys")),
   ARGPARSE_c (aListExternalKeys, "list-external-keys",
               N_("list external keys")),
   ARGPARSE_c (aListSecretKeys, "list-secret-keys", N_("list secret keys")),
   ARGPARSE_c (aListChain,   "list-chain",  N_("list certificate chain")),
   ARGPARSE_c (aFingerprint, "fingerprint", N_("list keys and fingerprints")),
   ARGPARSE_c (aKeygen, "generate-key", N_("generate a new key pair")),
   ARGPARSE_c (aKeygen, "gen-key", "@"),
   ARGPARSE_c (aDeleteKey, "delete-keys",
               N_("remove keys from the public keyring")),
 /*ARGPARSE_c (aSendKeys, "send-keys", N_("export keys to a keyserver")),*/
 /*ARGPARSE_c (aRecvKeys, "recv-keys", N_("import keys from a keyserver")),*/
   ARGPARSE_c (aImport, "import", N_("import certificates")),
   ARGPARSE_c (aExport, "export", N_("export certificates")),
 
   /* We use -raw and not -p1 for pkcs#1 secret key export so that it
      won't accidentally be used in case -p12 was intended.  */
   ARGPARSE_c (aExportSecretKeyP12, "export-secret-key-p12", "@"),
   ARGPARSE_c (aExportSecretKeyP8,  "export-secret-key-p8", "@"),
   ARGPARSE_c (aExportSecretKeyRaw, "export-secret-key-raw", "@"),
 
   ARGPARSE_c (aLearnCard, "learn-card", N_("register a smartcard")),
   ARGPARSE_c (aServer, "server", N_("run in server mode")),
   ARGPARSE_c (aCallDirmngr, "call-dirmngr",
               N_("pass a command to the dirmngr")),
   ARGPARSE_c (aCallProtectTool, "call-protect-tool",
               N_("invoke gpg-protect-tool")),
   ARGPARSE_c (aPasswd, "change-passphrase", N_("change a passphrase")),
   ARGPARSE_c (aPasswd, "passwd", "@"),
   ARGPARSE_c (aGPGConfList, "gpgconf-list", "@"),
   ARGPARSE_c (aGPGConfTest, "gpgconf-test", "@"),
 
   ARGPARSE_c (aDumpKeys, "dump-cert", "@"),
   ARGPARSE_c (aDumpKeys, "dump-keys", "@"),
   ARGPARSE_c (aDumpChain, "dump-chain", "@"),
   ARGPARSE_c (aDumpExternalKeys, "dump-external-keys", "@"),
   ARGPARSE_c (aDumpSecretKeys, "dump-secret-keys", "@"),
   ARGPARSE_c (aKeydbClearSomeCertFlags, "keydb-clear-some-cert-flags", "@"),
 
   ARGPARSE_group (301, N_("@\nOptions:\n ")),
 
   ARGPARSE_s_n (oArmor, "armor", N_("create ascii armored output")),
   ARGPARSE_s_n (oArmor, "armour", "@"),
   ARGPARSE_s_n (oBase64, "base64", N_("create base-64 encoded output")),
 
   ARGPARSE_s_s (oP12Charset, "p12-charset", "@"),
 
   ARGPARSE_s_i (oPassphraseFD,    "passphrase-fd", "@"),
   ARGPARSE_s_s (oPinentryMode,    "pinentry-mode", "@"),
   ARGPARSE_s_s (oRequestOrigin,   "request-origin", "@"),
 
   ARGPARSE_s_n (oAssumeArmor, "assume-armor",
                 N_("assume input is in PEM format")),
   ARGPARSE_s_n (oAssumeBase64, "assume-base64",
                 N_("assume input is in base-64 format")),
   ARGPARSE_s_n (oAssumeBinary, "assume-binary",
                 N_("assume input is in binary format")),
 
   ARGPARSE_s_s (oRecipient, "recipient", N_("|USER-ID|encrypt for USER-ID")),
 
   ARGPARSE_s_n (oPreferSystemDirmngr,"prefer-system-dirmngr", "@"),
 
   ARGPARSE_s_n (oDisableCRLChecks, "disable-crl-checks",
                 N_("never consult a CRL")),
   ARGPARSE_s_n (oEnableCRLChecks, "enable-crl-checks", "@"),
   ARGPARSE_s_n (oDisableTrustedCertCRLCheck,
                 "disable-trusted-cert-crl-check", "@"),
   ARGPARSE_s_n (oEnableTrustedCertCRLCheck,
                 "enable-trusted-cert-crl-check", "@"),
 
   ARGPARSE_s_n (oForceCRLRefresh, "force-crl-refresh", "@"),
 
   ARGPARSE_s_n (oDisableOCSP, "disable-ocsp", "@"),
   ARGPARSE_s_n (oEnableOCSP,  "enable-ocsp", N_("check validity using OCSP")),
 
   ARGPARSE_s_s (oValidationModel, "validation-model", "@"),
 
   ARGPARSE_s_i (oIncludeCerts, "include-certs",
                 N_("|N|number of certificates to include") ),
 
   ARGPARSE_s_s (oPolicyFile, "policy-file",
                 N_("|FILE|take policy information from FILE")),
 
   ARGPARSE_s_n (oDisablePolicyChecks, "disable-policy-checks",
                 N_("do not check certificate policies")),
   ARGPARSE_s_n (oEnablePolicyChecks, "enable-policy-checks", "@"),
 
   ARGPARSE_s_n (oAutoIssuerKeyRetrieve, "auto-issuer-key-retrieve",
                 N_("fetch missing issuer certificates")),
 
   ARGPARSE_s_s (oEncryptTo, "encrypt-to", "@"),
   ARGPARSE_s_n (oNoEncryptTo, "no-encrypt-to", "@"),
 
   ARGPARSE_s_s (oUser, "local-user",
                 N_("|USER-ID|use USER-ID to sign or decrypt")),
 
   ARGPARSE_s_s (oOutput, "output", N_("|FILE|write output to FILE")),
   ARGPARSE_s_n (oVerbose, "verbose", N_("verbose")),
   ARGPARSE_s_n (oQuiet,	"quiet",  N_("be somewhat more quiet")),
   ARGPARSE_s_n (oNoTTY, "no-tty", N_("don't use the terminal at all")),
   ARGPARSE_s_s (oLogFile, "log-file",
                 N_("|FILE|write a server mode log to FILE")),
   ARGPARSE_s_n (oNoLogFile, "no-log-file", "@"),
   ARGPARSE_s_i (oLoggerFD, "logger-fd", "@"),
 
   ARGPARSE_s_s (oAuditLog, "audit-log",
                 N_("|FILE|write an audit log to FILE")),
   ARGPARSE_s_s (oHtmlAuditLog, "html-audit-log", "@"),
   ARGPARSE_s_n (oDryRun, "dry-run", N_("do not make any changes")),
   ARGPARSE_s_n (oBatch, "batch", N_("batch mode: never ask")),
   ARGPARSE_s_n (oAnswerYes, "yes", N_("assume yes on most questions")),
   ARGPARSE_s_n (oAnswerNo,  "no",  N_("assume no on most questions")),
 
   ARGPARSE_s_s (oKeyring, "keyring",
                 N_("|FILE|add keyring to the list of keyrings")),
 
   ARGPARSE_s_s (oDefaultKey, "default-key",
                 N_("|USER-ID|use USER-ID as default secret key")),
 
   /* Not yet used: */
   /*   ARGPARSE_s_s (oDefRecipient, "default-recipient", */
   /*                  N_("|NAME|use NAME as default recipient")), */
   /*   ARGPARSE_s_n (oDefRecipientSelf, "default-recipient-self", */
   /*                  N_("use the default key as default recipient")), */
   /*   ARGPARSE_s_n (oNoDefRecipient, "no-default-recipient", "@"), */
 
   ARGPARSE_s_s (oKeyServer, "keyserver",
                 N_("|SPEC|use this keyserver to lookup keys")),
   ARGPARSE_s_s (oOptions, "options", N_("|FILE|read options from FILE")),
 
   ARGPARSE_s_s (oDebug, "debug", "@"),
   ARGPARSE_s_s (oDebugLevel, "debug-level",
                 N_("|LEVEL|set the debugging level to LEVEL")),
   ARGPARSE_s_n (oDebugAll, "debug-all", "@"),
   ARGPARSE_s_n (oDebugNone, "debug-none", "@"),
   ARGPARSE_s_i (oDebugWait, "debug-wait", "@"),
   ARGPARSE_s_n (oDebugAllowCoreDump, "debug-allow-core-dump", "@"),
   ARGPARSE_s_n (oDebugNoChainValidation, "debug-no-chain-validation", "@"),
   ARGPARSE_s_n (oDebugIgnoreExpiration,  "debug-ignore-expiration", "@"),
 
   ARGPARSE_s_i (oStatusFD, "status-fd",
                 N_("|FD|write status info to this FD")),
 
   ARGPARSE_s_s (oCipherAlgo, "cipher-algo",
                 N_("|NAME|use cipher algorithm NAME")),
   ARGPARSE_s_s (oDigestAlgo, "digest-algo",
                 N_("|NAME|use message digest algorithm NAME")),
   ARGPARSE_s_s (oExtraDigestAlgo, "extra-digest-algo", "@"),
 
 
   ARGPARSE_group (302, N_(
   "@\n(See the man page for a complete listing of all commands and options)\n"
   )),
 
 
   /* Hidden options. */
   ARGPARSE_s_s (oCompliance, "compliance",   "@"),
   ARGPARSE_s_n (oNoVerbose, "no-verbose", "@"),
   ARGPARSE_s_n (oEnableSpecialFilenames, "enable-special-filenames", "@"),
   ARGPARSE_s_n (oNoSecmemWarn, "no-secmem-warning", "@"),
   ARGPARSE_s_n (oNoArmor, "no-armor", "@"),
   ARGPARSE_s_n (oNoArmor, "no-armour", "@"),
   ARGPARSE_s_n (oNoDefKeyring, "no-default-keyring", "@"),
   ARGPARSE_s_n (oNoGreeting, "no-greeting", "@"),
   ARGPARSE_s_n (oNoOptions, "no-options", "@"),
   ARGPARSE_s_s (oHomedir, "homedir", "@"),
   ARGPARSE_s_s (oAgentProgram, "agent-program", "@"),
   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 (oDirmngrProgram, "dirmngr-program", "@"),
   ARGPARSE_s_n (oDisableDirmngr, "disable-dirmngr", "@"),
   ARGPARSE_s_s (oProtectToolProgram, "protect-tool-program", "@"),
   ARGPARSE_s_s (oFakedSystemTime, "faked-system-time", "@"),
   ARGPARSE_s_n (oNoBatch, "no-batch", "@"),
   ARGPARSE_s_n (oWithColons, "with-colons", "@"),
   ARGPARSE_s_n (oWithKeyData,"with-key-data", "@"),
   ARGPARSE_s_n (oWithValidation, "with-validation", "@"),
   ARGPARSE_s_n (oWithMD5Fingerprint, "with-md5-fingerprint", "@"),
   ARGPARSE_s_n (oWithEphemeralKeys,  "with-ephemeral-keys", "@"),
   ARGPARSE_s_n (oSkipVerify, "skip-verify", "@"),
   ARGPARSE_s_n (oWithFingerprint, "with-fingerprint", "@"),
   ARGPARSE_s_n (oWithKeygrip,     "with-keygrip", "@"),
   ARGPARSE_s_n (oWithSecret,      "with-secret", "@"),
   ARGPARSE_s_s (oDisableCipherAlgo,  "disable-cipher-algo", "@"),
   ARGPARSE_s_s (oDisablePubkeyAlgo,  "disable-pubkey-algo", "@"),
   ARGPARSE_s_n (oIgnoreTimeConflict, "ignore-time-conflict", "@"),
   ARGPARSE_s_n (oNoRandomSeedFile,  "no-random-seed-file", "@"),
   ARGPARSE_s_n (oNoCommonCertsImport, "no-common-certs-import", "@"),
   ARGPARSE_s_s (oIgnoreCertExtension, "ignore-cert-extension", "@"),
   ARGPARSE_s_n (oNoAutostart, "no-autostart", "@"),
+  ARGPARSE_s_n (oEnableIssuerBasedCRLCheck, "enable-issuer-based-crl-check",
+                "@"),
 
   /* Command aliases.  */
   ARGPARSE_c (aListKeys, "list-key", "@"),
   ARGPARSE_c (aListChain, "list-signatures", "@"),
   ARGPARSE_c (aListChain, "list-sigs", "@"),
   ARGPARSE_c (aListChain, "check-signatures", "@"),
   ARGPARSE_c (aListChain, "check-sigs", "@"),
   ARGPARSE_c (aDeleteKey, "delete-key", "@"),
 
   ARGPARSE_end ()
 };
 
 
 /* The list of supported debug flags.  */
 static struct debug_flags_s debug_flags [] =
   {
     { DBG_X509_VALUE   , "x509"    },
     { DBG_MPI_VALUE    , "mpi"     },
     { DBG_CRYPTO_VALUE , "crypto"  },
     { DBG_MEMORY_VALUE , "memory"  },
     { DBG_CACHE_VALUE  , "cache"   },
     { DBG_MEMSTAT_VALUE, "memstat" },
     { DBG_HASHING_VALUE, "hashing" },
     { DBG_IPC_VALUE    , "ipc"     },
     { 0, NULL }
   };
 
 
 /* Global variable to keep an error count. */
 int gpgsm_errors_seen = 0;
 
 /* It is possible that we are currentlu running under setuid permissions */
 static int maybe_setuid = 1;
 
 /* Helper to implement --debug-level and --debug*/
 static const char *debug_level;
 static unsigned int debug_value;
 
 /* Default value for include-certs.  We need an extra macro for
    gpgconf-list because the variable will be changed by the command
    line option.
 
    It is often cumbersome to locate intermediate certificates, thus by
    default we include all certificates in the chain.  However we leave
    out the root certificate because that would make it too easy for
    the recipient to import that root certificate.  A root certificate
    should be installed only after due checks and thus it won't help to
    send it along with each message.  */
 #define DEFAULT_INCLUDE_CERTS -2 /* Include all certs but root. */
 static int default_include_certs = DEFAULT_INCLUDE_CERTS;
 
 /* Whether the chain mode shall be used for validation.  */
 static int default_validation_model;
 
 /* The default cipher algo.  */
 #define DEFAULT_CIPHER_ALGO "AES"
 
 
 static char *build_list (const char *text,
 			 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 emergency_cleanup (void);
 static int open_read (const char *filename);
 static estream_t open_es_fread (const char *filename, const char *mode);
 static estream_t open_es_fwrite (const char *filename);
 static void run_protect_tool (int argc, char **argv);
 
 static int
 our_pk_test_algo (int algo)
 {
   switch (algo)
     {
     case GCRY_PK_RSA:
     case GCRY_PK_ECDSA:
       return gcry_pk_test_algo (algo);
     default:
       return 1;
     }
 }
 
 static int
 our_cipher_test_algo (int algo)
 {
   switch (algo)
     {
     case GCRY_CIPHER_3DES:
     case GCRY_CIPHER_AES128:
     case GCRY_CIPHER_AES192:
     case GCRY_CIPHER_AES256:
     case GCRY_CIPHER_SERPENT128:
     case GCRY_CIPHER_SERPENT192:
     case GCRY_CIPHER_SERPENT256:
     case GCRY_CIPHER_SEED:
     case GCRY_CIPHER_CAMELLIA128:
     case GCRY_CIPHER_CAMELLIA192:
     case GCRY_CIPHER_CAMELLIA256:
       return gcry_cipher_test_algo (algo);
     default:
       return 1;
     }
 }
 
 
 static int
 our_md_test_algo (int algo)
 {
   switch (algo)
     {
     case GCRY_MD_MD5:
     case GCRY_MD_SHA1:
     case GCRY_MD_RMD160:
     case GCRY_MD_SHA224:
     case GCRY_MD_SHA256:
     case GCRY_MD_SHA384:
     case GCRY_MD_SHA512:
     case GCRY_MD_WHIRLPOOL:
       return gcry_md_test_algo (algo);
     default:
       return 1;
     }
 }
 
 
 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 const char *
 my_strusage( int level )
 {
   static char *digests, *pubkeys, *ciphers;
   static char *ver_gcry, *ver_ksba;
   const char *p;
 
   switch (level)
     {
     case 11: p = "@GPGSM@ (@GNUPG@)";
       break;
     case 13: p = VERSION; break;
     case 17: p = PRINTABLE_OS_NAME; break;
     case 19: p = _("Please report bugs to <@EMAIL@>.\n"); break;
 
     case 1:
     case 40: p = _("Usage: @GPGSM@ [options] [files] (-h for help)");
       break;
     case 41:
       p = _("Syntax: @GPGSM@ [options] [files]\n"
             "Sign, check, encrypt or decrypt using the S/MIME protocol\n"
             "Default operation depends on the input data\n");
       break;
 
     case 20:
       if (!ver_gcry)
         ver_gcry = make_libversion ("libgcrypt", gcry_check_version);
       p = ver_gcry;
       break;
     case 21:
       if (!ver_ksba)
         ver_ksba = make_libversion ("libksba", ksba_check_version);
       p = ver_ksba;
       break;
 
     case 31: p = "\nHome: "; break;
     case 32: p = gnupg_homedir (); break;
     case 33: p = _("\nSupported algorithms:\n"); break;
     case 34:
       if (!ciphers)
         ciphers = build_list ("Cipher: ", gnupg_cipher_algo_name,
                               our_cipher_test_algo );
       p = ciphers;
       break;
     case 35:
       if (!pubkeys)
         pubkeys = build_list ("Pubkey: ", gcry_pk_algo_name,
                               our_pk_test_algo );
       p = pubkeys;
       break;
     case 36:
       if (!digests)
         digests = build_list("Hash: ", gcry_md_algo_name, our_md_test_algo );
       p = digests;
       break;
 
     default: p = NULL; break;
     }
   return p;
 }
 
 
 static char *
 build_list (const char *text, const char * (*mapf)(int), int (*chkf)(int))
 {
   int i;
   size_t n=strlen(text)+2;
   char *list, *p;
 
   if (maybe_setuid) {
     gcry_control (GCRYCTL_DROP_PRIVS); /* drop setuid */
   }
 
   for (i=1; i < 400; i++ )
     if (!chkf(i))
       n += strlen(mapf(i)) + 2;
   list = xmalloc (21 + n);
   *list = 0;
   for (p=NULL, i=1; i < 400; i++)
     {
       if (!chkf(i))
         {
           if( !p )
             p = stpcpy (list, text );
           else
             p = stpcpy (p, ", ");
           p = stpcpy (p, mapf(i) );
 	}
     }
   if (p)
     strcpy (p, "\n" );
   return list;
 }
 
 
 /* Set the file pointer into binary mode if required.  */
 static void
 set_binary (FILE *fp)
 {
 #ifdef HAVE_DOSISH_SYSTEM
   setmode (fileno (fp), O_BINARY);
 #else
   (void)fp;
 #endif
 }
 
 
 
 static void
 wrong_args (const char *text)
 {
   fprintf (stderr, _("usage: %s [options] %s\n"), GPGSM_NAME, text);
   gpgsm_exit (2);
 }
 
 
 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 DEBUG_LEVEL of NULL only the active
    debug flags are propagated to the subsystems.  With DEBUG_LEVEL
    set, a specific set of debug flags is set; and individual debugging
    flags will be added on top.  */
 static void
 set_debug (void)
 {
   int numok = (debug_level && digitp (debug_level));
   int numlvl = numok? atoi (debug_level) : 0;
 
   if (!debug_level)
     ;
   else if (!strcmp (debug_level, "none") || (numok && numlvl < 1))
     opt.debug = 0;
   else if (!strcmp (debug_level, "basic") || (numok && numlvl <= 2))
     opt.debug = DBG_IPC_VALUE;
   else if (!strcmp (debug_level, "advanced") || (numok && numlvl <= 5))
     opt.debug = DBG_IPC_VALUE|DBG_X509_VALUE;
   else if (!strcmp (debug_level, "expert")  || (numok && numlvl <= 8))
     opt.debug = (DBG_IPC_VALUE|DBG_X509_VALUE
                  |DBG_CACHE_VALUE|DBG_CRYPTO_VALUE);
   else if (!strcmp (debug_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"), debug_level);
       gpgsm_exit (2);
     }
 
   opt.debug |= debug_value;
 
   if (opt.debug && !opt.verbose)
     opt.verbose = 1;
   if (opt.debug)
     opt.quiet = 0;
 
   if (opt.debug & DBG_MPI_VALUE)
     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 2);
   if (opt.debug & DBG_CRYPTO_VALUE )
     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
   gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
 
   if (opt.debug)
     parse_debug_flag (NULL, &opt.debug, debug_flags);
 }
 
 
 
 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 == aClearsign)
             || (cmd == aClearsign && new_cmd == aSign) )
     cmd = aClearsign;
   else
     {
       log_error(_("conflicting commands\n"));
       gpgsm_exit(2);
     }
 
   *ret_cmd = cmd;
 }
 
 
 /* Helper to add recipients to a list. */
 static void
 do_add_recipient (ctrl_t ctrl, const char *name,
                   certlist_t *recplist, int is_encrypt_to, int recp_required)
 {
   int rc = gpgsm_add_to_certlist (ctrl, name, 0, recplist, is_encrypt_to);
   if (rc)
     {
       if (recp_required)
         {
           log_error ("can't encrypt to '%s': %s\n", name, gpg_strerror (rc));
           gpgsm_status2 (ctrl, STATUS_INV_RECP,
                          get_inv_recpsgnr_code (rc), name, NULL);
         }
       else
         log_info (_("Note: won't be able to encrypt to '%s': %s\n"),
                   name, gpg_strerror (rc));
     }
 }
 
 
 static void
 parse_validation_model (const char *model)
 {
   int i = gpgsm_parse_validation_model (model);
   if (i == -1)
     log_error (_("unknown validation model '%s'\n"), model);
   else
     default_validation_model = i;
 }
 
 
 /* Release the list of SERVERS.  As usual it is okay to call this
    function with SERVERS passed as NULL.  */
 void
 keyserver_list_free (struct keyserver_spec *servers)
 {
   while (servers)
     {
       struct keyserver_spec *tmp = servers->next;
       xfree (servers->host);
       xfree (servers->user);
       if (servers->pass)
         memset (servers->pass, 0, strlen (servers->pass));
       xfree (servers->pass);
       xfree (servers->base);
       xfree (servers);
       servers = tmp;
     }
 }
 
 /* See also dirmngr ldapserver_parse_one().  */
 struct keyserver_spec *
 parse_keyserver_line (char *line,
 		      const char *filename, unsigned int lineno)
 {
   char *p;
   char *endp;
   struct keyserver_spec *server;
   int fieldno;
   int fail = 0;
 
   /* Parse the colon separated fields.  */
   server = xcalloc (1, sizeof *server);
   for (fieldno = 1, p = line; p; p = endp, fieldno++ )
     {
       endp = strchr (p, ':');
       if (endp)
 	*endp++ = '\0';
       trim_spaces (p);
       switch (fieldno)
 	{
 	case 1:
 	  if (*p)
 	    server->host = xstrdup (p);
 	  else
 	    {
 	      log_error (_("%s:%u: no hostname given\n"),
 			 filename, lineno);
 	      fail = 1;
 	    }
 	  break;
 
 	case 2:
 	  if (*p)
 	    server->port = atoi (p);
 	  break;
 
 	case 3:
 	  if (*p)
 	    server->user = xstrdup (p);
 	  break;
 
 	case 4:
 	  if (*p && !server->user)
 	    {
 	      log_error (_("%s:%u: password given without user\n"),
 			 filename, lineno);
 	      fail = 1;
 	    }
 	  else if (*p)
 	    server->pass = xstrdup (p);
 	  break;
 
 	case 5:
 	  if (*p)
 	    server->base = xstrdup (p);
 	  break;
 
 	default:
 	  /* (We silently ignore extra fields.) */
 	  break;
 	}
     }
 
   if (fail)
     {
       log_info (_("%s:%u: skipping this line\n"), filename, lineno);
       keyserver_list_free (server);
       server = NULL;
     }
 
   return server;
 }
 
 
 int
 main ( int argc, char **argv)
 {
   ARGPARSE_ARGS pargs;
   int orig_argc;
   char **orig_argv;
   /*  char *username;*/
   int may_coredump;
   strlist_t sl, remusr= NULL, locusr=NULL;
   strlist_t nrings=NULL;
   int detached_sig = 0;
   FILE *configfp = NULL;
   char *configname = NULL;
   unsigned configlineno;
   int parse_debug = 0;
   int no_more_options = 0;
   int default_config =1;
   int default_keyring = 1;
   char *logfile = NULL;
   char *auditlog = NULL;
   char *htmlauditlog = NULL;
   int greeting = 0;
   int nogreeting = 0;
   int debug_wait = 0;
   int use_random_seed = 1;
   int no_common_certs_import = 0;
   int with_fpr = 0;
   const char *forced_digest_algo = NULL;
   const char *extra_digest_algo = NULL;
   enum cmd_and_opt_values cmd = 0;
   struct server_control_s ctrl;
   certlist_t recplist = NULL;
   certlist_t signerlist = NULL;
   int do_not_setup_keys = 0;
   int recp_required = 0;
   estream_t auditfp = NULL;
   estream_t htmlauditfp = NULL;
   struct assuan_malloc_hooks malloc_hooks;
   int pwfd = -1;
   /*mtrace();*/
 
   early_system_init ();
   gnupg_reopen_std (GPGSM_NAME);
   /* trap_unaligned ();*/
   gnupg_rl_initialize ();
   set_strusage (my_strusage);
   gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
 
   /* 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 */
   log_set_prefix (GPGSM_NAME, GPGRT_LOG_WITH_PREFIX);
 
   /* Make sure that our subsystems are ready.  */
   i18n_init ();
   init_common_subsystems (&argc, &argv);
 
   /* Check that the libraries are suitable.  Do it here because the
      option parse may need services of the library */
   if (!ksba_check_version (NEED_KSBA_VERSION) )
     log_fatal (_("%s is too old (need %s, have %s)\n"), "libksba",
                NEED_KSBA_VERSION, ksba_check_version (NULL) );
 
 
   gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
 
   may_coredump = disable_core_dumps ();
 
   gnupg_init_signals (0, emergency_cleanup);
 
   dotlock_create (NULL, 0); /* Register lockfile cleanup.  */
 
   /* Tell the compliance module who we are.  */
   gnupg_initialize_compliance (GNUPG_MODULE_NAME_GPGSM);
 
   opt.autostart = 1;
   opt.session_env = session_env_new ();
   if (!opt.session_env)
     log_fatal ("error allocating session environment block: %s\n",
                strerror (errno));
 
   /* Note: If you change this default cipher algorithm , please
      remember to update the Gpgconflist entry as well.  */
   opt.def_cipher_algoid = DEFAULT_CIPHER_ALGO;
 
 
   /* First check whether we have a config file on the commandline */
   orig_argc = argc;
   orig_argv = argv;
   pargs.argc = &argc;
   pargs.argv = &argv;
   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
   while (arg_parse( &pargs, opts))
     {
       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
         parse_debug++;
       else if (pargs.r_opt == oOptions)
         { /* yes there is one, so we do not try the default one but
              read the config file when it is encountered at the
              commandline */
           default_config = 0;
 	}
       else if (pargs.r_opt == oNoOptions)
         {
           default_config = 0; /* --no-options */
           opt.no_homedir_creation = 1;
         }
       else if (pargs.r_opt == oHomedir)
         gnupg_set_homedir (pargs.r.ret_str);
       else if (pargs.r_opt == aCallProtectTool)
         break; /* This break makes sure that --version and --help are
                   passed to the protect-tool. */
     }
 
 
   /* Initialize the secure memory. */
   gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
   maybe_setuid = 0;
 
   /*
      Now we are now working under our real uid
   */
 
   ksba_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free );
 
   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);
 
   /* Setup a default control structure for command line mode */
   memset (&ctrl, 0, sizeof ctrl);
   gpgsm_init_default_ctrl (&ctrl);
   ctrl.no_server = 1;
   ctrl.status_fd = -1; /* No status output. */
   ctrl.autodetect_encoding = 1;
 
   /* Set the default option file */
   if (default_config )
     configname = make_filename (gnupg_homedir (),
                                 GPGSM_NAME EXTSEP_S "conf", NULL);
   /* Set the default policy file */
   opt.policy_file = make_filename (gnupg_homedir (), "policies.txt", NULL);
 
   argc        = orig_argc;
   argv        = orig_argv;
   pargs.argc  = &argc;
   pargs.argv  = &argv;
   pargs.flags =  1;  /* do not remove the args */
 
  next_pass:
   if (configname) {
     configlineno = 0;
     configfp = fopen (configname, "r");
     if (!configfp)
       {
         if (default_config)
           {
             if (parse_debug)
               log_info (_("Note: no default option file '%s'\n"), configname);
           }
         else
           {
             log_error (_("option file '%s': %s\n"), configname, strerror(errno));
             gpgsm_exit(2);
           }
         xfree(configname);
         configname = NULL;
       }
     if (parse_debug && configname)
       log_info (_("reading options from '%s'\n"), configname);
     default_config = 0;
   }
 
   while (!no_more_options
          && optfile_parse (configfp, configname, &configlineno, &pargs, opts))
     {
       switch (pargs.r_opt)
         {
 	case aGPGConfList:
 	case aGPGConfTest:
           set_cmd (&cmd, pargs.r_opt);
           do_not_setup_keys = 1;
           nogreeting = 1;
           break;
 
         case aServer:
           opt.batch = 1;
           set_cmd (&cmd, aServer);
           break;
 
         case aCallDirmngr:
           opt.batch = 1;
           set_cmd (&cmd, aCallDirmngr);
           do_not_setup_keys = 1;
           break;
 
         case aCallProtectTool:
           opt.batch = 1;
           set_cmd (&cmd, aCallProtectTool);
           no_more_options = 1; /* Stop parsing. */
           do_not_setup_keys = 1;
           break;
 
         case aDeleteKey:
           set_cmd (&cmd, aDeleteKey);
           /*greeting=1;*/
           do_not_setup_keys = 1;
           break;
 
         case aDetachedSign:
           detached_sig = 1;
           set_cmd (&cmd, aSign );
           break;
 
         case aKeygen:
           set_cmd (&cmd, aKeygen);
           greeting=1;
           do_not_setup_keys = 1;
           break;
 
         case aImport:
         case aSendKeys:
         case aRecvKeys:
         case aExport:
         case aExportSecretKeyP12:
         case aExportSecretKeyP8:
         case aExportSecretKeyRaw:
         case aDumpKeys:
         case aDumpChain:
         case aDumpExternalKeys:
         case aDumpSecretKeys:
         case aListKeys:
         case aListExternalKeys:
         case aListSecretKeys:
         case aListChain:
         case aLearnCard:
         case aPasswd:
         case aKeydbClearSomeCertFlags:
           do_not_setup_keys = 1;
           set_cmd (&cmd, pargs.r_opt);
           break;
 
         case aEncr:
           recp_required = 1;
           set_cmd (&cmd, pargs.r_opt);
           break;
 
         case aSym:
         case aDecrypt:
         case aSign:
         case aClearsign:
         case aVerify:
           set_cmd (&cmd, pargs.r_opt);
           break;
 
           /* Output encoding selection.  */
         case oArmor:
           ctrl.create_pem = 1;
           break;
         case oBase64:
           ctrl.create_pem = 0;
           ctrl.create_base64 = 1;
           break;
         case oNoArmor:
           ctrl.create_pem = 0;
           ctrl.create_base64 = 0;
           break;
 
         case oP12Charset:
           opt.p12_charset = pargs.r.ret_str;
           break;
 
         case oPassphraseFD:
 	  pwfd = translate_sys2libc_fd_int (pargs.r.ret_int, 0);
 	  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;
 
           /* Input encoding selection.  */
         case oAssumeArmor:
           ctrl.autodetect_encoding = 0;
           ctrl.is_pem = 1;
           ctrl.is_base64 = 0;
           break;
         case oAssumeBase64:
           ctrl.autodetect_encoding = 0;
           ctrl.is_pem = 0;
           ctrl.is_base64 = 1;
           break;
         case oAssumeBinary:
           ctrl.autodetect_encoding = 0;
           ctrl.is_pem = 0;
           ctrl.is_base64 = 0;
           break;
 
         case oDisableCRLChecks:
           opt.no_crl_check = 1;
           break;
         case oEnableCRLChecks:
           opt.no_crl_check = 0;
           break;
         case oDisableTrustedCertCRLCheck:
           opt.no_trusted_cert_crl_check = 1;
           break;
         case oEnableTrustedCertCRLCheck:
           opt.no_trusted_cert_crl_check = 0;
           break;
         case oForceCRLRefresh:
           opt.force_crl_refresh = 1;
           break;
+        case oEnableIssuerBasedCRLCheck:
+          opt.enable_issuer_based_crl_check = 1;
+          break;
 
         case oDisableOCSP:
           ctrl.use_ocsp = opt.enable_ocsp = 0;
           break;
         case oEnableOCSP:
           ctrl.use_ocsp = opt.enable_ocsp = 1;
           break;
 
         case oIncludeCerts:
           ctrl.include_certs = default_include_certs = pargs.r.ret_int;
           break;
 
         case oPolicyFile:
           xfree (opt.policy_file);
           if (*pargs.r.ret_str)
             opt.policy_file = xstrdup (pargs.r.ret_str);
           else
             opt.policy_file = NULL;
           break;
 
         case oDisablePolicyChecks:
           opt.no_policy_check = 1;
           break;
         case oEnablePolicyChecks:
           opt.no_policy_check = 0;
           break;
 
         case oAutoIssuerKeyRetrieve:
           opt.auto_issuer_key_retrieve = 1;
           break;
 
         case oOutput: opt.outfile = pargs.r.ret_str; break;
 
 
         case oQuiet: opt.quiet = 1; break;
         case oNoTTY: /* fixme:tty_no_terminal(1);*/ break;
         case oDryRun: opt.dry_run = 1; break;
 
         case oVerbose:
           opt.verbose++;
           gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
           break;
         case oNoVerbose:
           opt.verbose = 0;
           gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
           break;
 
         case oLogFile: logfile = pargs.r.ret_str; break;
         case oNoLogFile: logfile = NULL; break;
 
         case oAuditLog: auditlog = pargs.r.ret_str; break;
         case oHtmlAuditLog: htmlauditlog = pargs.r.ret_str; break;
 
         case oBatch:
           opt.batch = 1;
           greeting = 0;
           break;
         case oNoBatch: opt.batch = 0; break;
 
         case oAnswerYes: opt.answer_yes = 1; break;
         case oAnswerNo: opt.answer_no = 1; break;
 
         case oKeyring: append_to_strlist (&nrings, pargs.r.ret_str); break;
 
         case oDebug:
           if (parse_debug_flag (pargs.r.ret_str, &debug_value, debug_flags))
             {
               pargs.r_opt = ARGPARSE_INVALID_ARG;
               pargs.err = ARGPARSE_PRINT_ERROR;
             }
           break;
         case oDebugAll: debug_value = ~0; break;
         case oDebugNone: debug_value = 0; break;
         case oDebugLevel: debug_level = pargs.r.ret_str; break;
         case oDebugWait: debug_wait = pargs.r.ret_int; break;
         case oDebugAllowCoreDump:
           may_coredump = enable_core_dumps ();
           break;
         case oDebugNoChainValidation: opt.no_chain_validation = 1; break;
         case oDebugIgnoreExpiration: opt.ignore_expiration = 1; break;
 
         case oStatusFD:
             ctrl.status_fd = translate_sys2libc_fd_int (pargs.r.ret_int, 1);
             break;
         case oLoggerFD:
             log_set_fd (translate_sys2libc_fd_int (pargs.r.ret_int, 1));
             break;
         case oWithMD5Fingerprint:
           opt.with_md5_fingerprint=1; /*fall through*/
         case oWithFingerprint:
           with_fpr=1; /*fall through*/
         case aFingerprint:
           opt.fingerprint++;
           break;
 
         case oWithKeygrip:
           opt.with_keygrip = 1;
           break;
 
         case oOptions:
           /* config files may not be nested (silently ignore them) */
           if (!configfp)
             {
               xfree(configname);
               configname = xstrdup (pargs.r.ret_str);
               goto next_pass;
 	    }
           break;
         case oNoOptions: opt.no_homedir_creation = 1; break; /* no-options */
         case oHomedir: gnupg_set_homedir (pargs.r.ret_str); break;
         case oAgentProgram: opt.agent_program = pargs.r.ret_str;  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 = xstrdup (pargs.r.ret_str); break;
         case oLCmessages: opt.lc_messages = xstrdup (pargs.r.ret_str); break;
 
         case oDirmngrProgram: opt.dirmngr_program = pargs.r.ret_str;  break;
         case oDisableDirmngr: opt.disable_dirmngr = 1;  break;
         case oPreferSystemDirmngr: /* Obsolete */; break;
         case oProtectToolProgram:
           opt.protect_tool_program = pargs.r.ret_str;
           break;
 
         case oFakedSystemTime:
           {
             time_t 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, 0);
           }
           break;
 
         case oNoDefKeyring: default_keyring = 0; break;
         case oNoGreeting: nogreeting = 1; break;
 
         case oDefaultKey:
           if (*pargs.r.ret_str)
             {
               xfree (opt.local_user);
               opt.local_user = xstrdup (pargs.r.ret_str);
             }
           break;
         case oDefRecipient:
           if (*pargs.r.ret_str)
             opt.def_recipient = xstrdup (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 oWithKeyData: opt.with_key_data=1; /* fall through */
         case oWithColons: ctrl.with_colons = 1; break;
         case oWithSecret: ctrl.with_secret = 1; break;
         case oWithValidation: ctrl.with_validation=1; break;
         case oWithEphemeralKeys: ctrl.with_ephemeral_keys=1; break;
 
         case oSkipVerify: opt.skip_verify=1; break;
 
         case oNoEncryptTo: opt.no_encrypt_to = 1; break;
         case oEncryptTo: /* Store the recipient in the second list */
           sl = add_to_strlist (&remusr, pargs.r.ret_str);
           sl->flags = 1;
           break;
 
         case oRecipient: /* store the recipient */
           add_to_strlist ( &remusr, pargs.r.ret_str);
           break;
 
         case oUser: /* Store the local users, the first one is the default */
           if (!opt.local_user)
             opt.local_user = xstrdup (pargs.r.ret_str);
           add_to_strlist (&locusr, pargs.r.ret_str);
           break;
 
         case oNoSecmemWarn:
           gcry_control (GCRYCTL_DISABLE_SECMEM_WARN);
           break;
 
         case oCipherAlgo:
           opt.def_cipher_algoid = pargs.r.ret_str;
           break;
 
         case oDisableCipherAlgo:
           {
             int algo = gcry_cipher_map_name (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 oDigestAlgo:
           forced_digest_algo = pargs.r.ret_str;
           break;
 
         case oExtraDigestAlgo:
           extra_digest_algo = pargs.r.ret_str;
           break;
 
         case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
         case oNoRandomSeedFile: use_random_seed = 0; break;
         case oNoCommonCertsImport: no_common_certs_import = 1; break;
 
         case oEnableSpecialFilenames:
           enable_special_filenames ();
           break;
 
         case oValidationModel: parse_validation_model (pargs.r.ret_str); break;
 
 	case oKeyServer:
 	  {
 	    struct keyserver_spec *keyserver;
 	    keyserver = parse_keyserver_line (pargs.r.ret_str,
 					      configname, configlineno);
 	    if (! keyserver)
 	      log_error (_("could not parse keyserver\n"));
 	    else
 	      {
 		/* FIXME: Keep last next pointer.  */
 		struct keyserver_spec **next_p = &opt.keyserver;
 		while (*next_p)
 		  next_p = &(*next_p)->next;
 		*next_p = keyserver;
 	      }
 	  }
 	  break;
 
         case oIgnoreCertExtension:
           add_to_strlist (&opt.ignored_cert_extensions, pargs.r.ret_str);
           break;
 
         case oNoAutostart: opt.autostart = 0; break;
 
         case oCompliance:
           {
             struct gnupg_compliance_option compliance_options[] =
               {
                 { "gnupg", CO_GNUPG },
                 { "de-vs", CO_DE_VS }
               };
             int compliance = gnupg_parse_compliance_option (pargs.r.ret_str,
                                                             compliance_options,
                                                             DIM (compliance_options),
                                                             opt.quiet);
             if (compliance < 0)
               log_inc_errorcount (); /* Force later termination.  */
             opt.compliance = compliance;
           }
           break;
 
         default:
           pargs.err = configfp? ARGPARSE_PRINT_WARNING:ARGPARSE_PRINT_ERROR;
           break;
 	}
     }
 
   if (configfp)
     {
       fclose (configfp);
       configfp = NULL;
       /* Keep a copy of the config filename. */
       opt.config_filename = configname;
       configname = NULL;
       goto next_pass;
     }
   xfree (configname);
   configname = NULL;
 
   if (!opt.config_filename)
     opt.config_filename = make_filename (gnupg_homedir (),
                                          GPGSM_NAME EXTSEP_S "conf",
                                          NULL);
 
   if (log_get_errorcount(0))
     {
       gpgsm_status_with_error (&ctrl, STATUS_FAILURE,
                                "option-parser", gpg_error (GPG_ERR_GENERAL));
       gpgsm_exit(2);
     }
 
   if (pwfd != -1)	/* Read the passphrase now.  */
     read_passphrase_from_fd (pwfd);
 
   /* Now that we have the options parsed we need to update the default
      control structure.  */
   gpgsm_init_default_ctrl (&ctrl);
 
   if (nogreeting)
     greeting = 0;
 
   if (greeting)
     {
       es_fprintf (es_stderr, "%s %s; %s\n",
                   strusage(11), strusage(13), strusage(14) );
       es_fprintf (es_stderr, "%s\n", strusage(15) );
     }
 #  ifdef IS_DEVELOPMENT_VERSION
   if (!opt.batch)
     {
       log_info ("NOTE: THIS IS A DEVELOPMENT VERSION!\n");
       log_info ("It is only intended for test purposes and should NOT be\n");
       log_info ("used in a production environment or with production keys!\n");
     }
 #  endif
 
   if (may_coredump && !opt.quiet)
     log_info (_("WARNING: program may create a core file!\n"));
 
 /*   if (opt.qualsig_approval && !opt.quiet) */
 /*     log_info (_("This software has officially been approved to " */
 /*                 "create and verify\n" */
 /*                 "qualified signatures according to German law.\n")); */
 
   if (logfile && cmd == aServer)
     {
       log_set_file (logfile);
       log_set_prefix (NULL, GPGRT_LOG_WITH_PREFIX | GPGRT_LOG_WITH_TIME | GPGRT_LOG_WITH_PID);
     }
 
   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]);
     }
 
 /*FIXME    if (opt.batch) */
 /*      tty_batchmode (1); */
 
   gcry_control (GCRYCTL_RESUME_SECMEM_WARN);
 
   set_debug ();
 
   /* Although we always use gpgsm_exit, we better install a regualr
      exit handler so that at least the secure memory gets wiped
      out. */
   if (atexit (emergency_cleanup))
     {
       log_error ("atexit failed\n");
       gpgsm_exit (2);
     }
 
   /* Must do this after dropping setuid, because the mapping functions
      may try to load an module and we may have disabled an algorithm.
      We remap the commonly used algorithms to the OIDs for
      convenience.  We need to work with the OIDs because they are used
      to check whether the encryption mode is actually available. */
   if (!strcmp (opt.def_cipher_algoid, "3DES") )
     opt.def_cipher_algoid = "1.2.840.113549.3.7";
   else if (!strcmp (opt.def_cipher_algoid, "AES")
            || !strcmp (opt.def_cipher_algoid, "AES128"))
     opt.def_cipher_algoid = "2.16.840.1.101.3.4.1.2";
   else if (!strcmp (opt.def_cipher_algoid, "AES192") )
     opt.def_cipher_algoid = "2.16.840.1.101.3.4.1.22";
   else if (!strcmp (opt.def_cipher_algoid, "AES256") )
     opt.def_cipher_algoid = "2.16.840.1.101.3.4.1.42";
   else if (!strcmp (opt.def_cipher_algoid, "SERPENT")
            || !strcmp (opt.def_cipher_algoid, "SERPENT128") )
     opt.def_cipher_algoid = "1.3.6.1.4.1.11591.13.2.2";
   else if (!strcmp (opt.def_cipher_algoid, "SERPENT192") )
     opt.def_cipher_algoid = "1.3.6.1.4.1.11591.13.2.22";
   else if (!strcmp (opt.def_cipher_algoid, "SERPENT256") )
     opt.def_cipher_algoid = "1.3.6.1.4.1.11591.13.2.42";
   else if (!strcmp (opt.def_cipher_algoid, "SEED") )
     opt.def_cipher_algoid = "1.2.410.200004.1.4";
   else if (!strcmp (opt.def_cipher_algoid, "CAMELLIA")
            || !strcmp (opt.def_cipher_algoid, "CAMELLIA128") )
     opt.def_cipher_algoid = "1.2.392.200011.61.1.1.1.2";
   else if (!strcmp (opt.def_cipher_algoid, "CAMELLIA192") )
     opt.def_cipher_algoid = "1.2.392.200011.61.1.1.1.3";
   else if (!strcmp (opt.def_cipher_algoid, "CAMELLIA256") )
     opt.def_cipher_algoid = "1.2.392.200011.61.1.1.1.4";
 
   if (cmd != aGPGConfList)
     {
       if ( !gcry_cipher_map_name (opt.def_cipher_algoid)
            || !gcry_cipher_mode_from_oid (opt.def_cipher_algoid))
         log_error (_("selected cipher algorithm is invalid\n"));
 
       if (forced_digest_algo)
         {
           opt.forced_digest_algo = gcry_md_map_name (forced_digest_algo);
           if (our_md_test_algo(opt.forced_digest_algo) )
             log_error (_("selected digest algorithm is invalid\n"));
         }
       if (extra_digest_algo)
         {
           opt.extra_digest_algo = gcry_md_map_name (extra_digest_algo);
           if (our_md_test_algo (opt.extra_digest_algo) )
             log_error (_("selected digest algorithm is invalid\n"));
         }
     }
 
   /* 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.  */
   if (! gnupg_cipher_is_allowed (opt.compliance,
                                  cmd == aEncr || cmd == aSignEncr,
                                  gcry_cipher_map_name (opt.def_cipher_algoid),
                                  GCRY_CIPHER_MODE_NONE)
       && ! gnupg_cipher_is_allowed (opt.compliance,
                                     cmd == aEncr || cmd == aSignEncr,
                                     gcry_cipher_mode_from_oid
                                     (opt.def_cipher_algoid),
                                     GCRY_CIPHER_MODE_NONE))
     log_error (_("cipher algorithm '%s' may not be used in %s mode\n"),
                opt.def_cipher_algoid,
                gnupg_compliance_option_string (opt.compliance));
 
   if (forced_digest_algo
       && ! gnupg_digest_is_allowed (opt.compliance,
                                      cmd == aSign
                                      || cmd == aSignEncr
                                      || cmd == aClearsign,
                                      opt.forced_digest_algo))
     log_error (_("digest algorithm '%s' may not be used in %s mode\n"),
                forced_digest_algo,
                gnupg_compliance_option_string (opt.compliance));
 
   if (extra_digest_algo
       && ! gnupg_digest_is_allowed (opt.compliance,
                                      cmd == aSign
                                      || cmd == aSignEncr
                                      || cmd == aClearsign,
                                      opt.extra_digest_algo))
     log_error (_("digest algorithm '%s' may not be used in %s mode\n"),
                extra_digest_algo,
                gnupg_compliance_option_string (opt.compliance));
 
   if (log_get_errorcount(0))
     {
       gpgsm_status_with_error (&ctrl, STATUS_FAILURE, "option-postprocessing",
                                gpg_error (GPG_ERR_GENERAL));
       gpgsm_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);
       xfree(p);
     }
 
   if (!cmd && opt.fingerprint && !with_fpr)
     set_cmd (&cmd, aListKeys);
 
   /* Add default keybox. */
   if (!nrings && default_keyring)
     {
       int created;
 
       keydb_add_resource (&ctrl, "pubring.kbx", 0, &created);
       if (created && !no_common_certs_import)
         {
           /* Import the standard certificates for a new default keybox. */
           char *filelist[2];
 
           filelist[0] = make_filename (gnupg_datadir (),"com-certs.pem", NULL);
           filelist[1] = NULL;
           if (!access (filelist[0], F_OK))
             {
               log_info (_("importing common certificates '%s'\n"),
                         filelist[0]);
               gpgsm_import_files (&ctrl, 1, filelist, open_read);
             }
           xfree (filelist[0]);
         }
     }
   for (sl = nrings; sl; sl = sl->next)
     keydb_add_resource (&ctrl, sl->d, 0, NULL);
   FREE_STRLIST(nrings);
 
 
   /* Prepare the audit log feature for certain commands.  */
   if (auditlog || htmlauditlog)
     {
       switch (cmd)
         {
         case aEncr:
         case aSign:
         case aDecrypt:
         case aVerify:
           audit_release (ctrl.audit);
           ctrl.audit = audit_new ();
           if (auditlog)
             auditfp = open_es_fwrite (auditlog);
           if (htmlauditlog)
             htmlauditfp = open_es_fwrite (htmlauditlog);
           break;
         default:
           break;
         }
     }
 
 
   if (!do_not_setup_keys)
     {
       int errcount = log_get_errorcount (0);
 
       for (sl = locusr; sl ; sl = sl->next)
         {
           int rc = gpgsm_add_to_certlist (&ctrl, sl->d, 1, &signerlist, 0);
           if (rc)
             {
               log_error (_("can't sign using '%s': %s\n"),
                          sl->d, gpg_strerror (rc));
               gpgsm_status2 (&ctrl, STATUS_INV_SGNR,
                              get_inv_recpsgnr_code (rc), sl->d, NULL);
               gpgsm_status2 (&ctrl, STATUS_INV_RECP,
                              get_inv_recpsgnr_code (rc), sl->d, NULL);
             }
         }
 
       /* Build the recipient list.  We first add the regular ones and then
          the encrypt-to ones because the underlying function will silently
          ignore duplicates and we can't allow keeping a duplicate which is
          flagged as encrypt-to as the actually encrypt function would then
          complain about no (regular) recipients. */
       for (sl = remusr; sl; sl = sl->next)
         if (!(sl->flags & 1))
           do_add_recipient (&ctrl, sl->d, &recplist, 0, recp_required);
       if (!opt.no_encrypt_to)
         {
           for (sl = remusr; sl; sl = sl->next)
             if ((sl->flags & 1))
               do_add_recipient (&ctrl, sl->d, &recplist, 1, recp_required);
         }
 
       /* We do not require a recipient for decryption but because
        * recipients and signers are always checked and log_error is
        * sometimes used (for failed signing keys or due to a failed
        * CRL checking) that would have bumbed up the error counter.
        * We clear the counter in the decryption case because there is
        * no reason to force decryption to fail. */
       if (cmd == aDecrypt && !errcount)
         log_get_errorcount (1); /* clear counter */
     }
 
   if (log_get_errorcount(0))
     gpgsm_exit(1); /* Must stop for invalid recipients. */
 
   /* Dispatch command.  */
   switch (cmd)
     {
     case aGPGConfList:
       { /* List options and default values in the GPG Conf format.  */
 	char *config_filename_esc = percent_escape (opt.config_filename, NULL);
 
         es_printf ("%s-%s.conf:%lu:\"%s\n",
                    GPGCONF_NAME, GPGSM_NAME,
                    GC_OPT_FLAG_DEFAULT, config_filename_esc);
         xfree (config_filename_esc);
 
         es_printf ("verbose:%lu:\n", GC_OPT_FLAG_NONE);
 	es_printf ("quiet:%lu:\n", GC_OPT_FLAG_NONE);
 	es_printf ("debug-level:%lu:\"none:\n", GC_OPT_FLAG_DEFAULT);
 	es_printf ("log-file:%lu:\n", GC_OPT_FLAG_NONE);
         es_printf ("disable-crl-checks:%lu:\n", GC_OPT_FLAG_NONE);
         es_printf ("enable-crl-checks:%lu:\n", GC_OPT_FLAG_NONE);
         es_printf ("disable-trusted-cert-crl-check:%lu:\n", GC_OPT_FLAG_NONE);
         es_printf ("enable-ocsp:%lu:\n", GC_OPT_FLAG_NONE);
         es_printf ("include-certs:%lu:%d:\n", GC_OPT_FLAG_DEFAULT,
                    DEFAULT_INCLUDE_CERTS);
         es_printf ("disable-policy-checks:%lu:\n", GC_OPT_FLAG_NONE);
         es_printf ("auto-issuer-key-retrieve:%lu:\n", GC_OPT_FLAG_NONE);
         es_printf ("disable-dirmngr:%lu:\n", GC_OPT_FLAG_NONE);
         es_printf ("cipher-algo:%lu:\"%s:\n", GC_OPT_FLAG_DEFAULT,
                    DEFAULT_CIPHER_ALGO);
         es_printf ("p12-charset:%lu:\n", GC_OPT_FLAG_DEFAULT);
         es_printf ("default-key:%lu:\n", GC_OPT_FLAG_DEFAULT);
         es_printf ("encrypt-to:%lu:\n", GC_OPT_FLAG_DEFAULT);
 	es_printf ("keyserver:%lu:\n", GC_OPT_FLAG_NONE);
 
         /* The next one is an info only item and should match what
            proc_parameters actually implements.  */
         es_printf ("default_pubkey_algo:%lu:\"%s:\n", GC_OPT_FLAG_DEFAULT,
                    "RSA-3072");
         es_printf ("compliance:%lu:\"%s:\n", GC_OPT_FLAG_DEFAULT, "gnupg");
 
       }
       break;
     case aGPGConfTest:
       /* This is merely a dummy command to test whether the
          configuration file is valid.  */
       break;
 
     case aServer:
       if (debug_wait)
         {
           log_debug ("waiting for debugger - my pid is %u .....\n",
                      (unsigned int)getpid());
           gnupg_sleep (debug_wait);
           log_debug ("... okay\n");
          }
       gpgsm_server (recplist);
       break;
 
     case aCallDirmngr:
       if (!argc)
         wrong_args ("--call-dirmngr <command> {args}");
       else
         if (gpgsm_dirmngr_run_command (&ctrl, *argv, argc-1, argv+1))
           gpgsm_exit (1);
       break;
 
     case aCallProtectTool:
       run_protect_tool (argc, argv);
       break;
 
     case aEncr: /* Encrypt the given file. */
       {
         estream_t fp = open_es_fwrite (opt.outfile?opt.outfile:"-");
 
         set_binary (stdin);
 
         if (!argc) /* Source is stdin. */
           gpgsm_encrypt (&ctrl, recplist, 0, fp);
         else if (argc == 1)  /* Source is the given file. */
           gpgsm_encrypt (&ctrl, recplist, open_read (*argv), fp);
         else
           wrong_args ("--encrypt [datafile]");
 
         es_fclose (fp);
       }
       break;
 
     case aSign: /* Sign the given file. */
       {
         estream_t fp = open_es_fwrite (opt.outfile?opt.outfile:"-");
 
         /* Fixme: We should also allow concatenation of multiple files for
            signing because that is what gpg does.*/
         set_binary (stdin);
         if (!argc) /* Create from stdin. */
           gpgsm_sign (&ctrl, signerlist, 0, detached_sig, fp);
         else if (argc == 1) /* From file. */
           gpgsm_sign (&ctrl, signerlist,
                       open_read (*argv), detached_sig, fp);
         else
           wrong_args ("--sign [datafile]");
 
         es_fclose (fp);
       }
       break;
 
     case aSignEncr: /* sign and encrypt the given file */
       log_error ("this command has not yet been implemented\n");
       break;
 
     case aClearsign: /* make a clearsig */
       log_error ("this command has not yet been implemented\n");
       break;
 
     case aVerify:
       {
         estream_t fp = NULL;
 
         set_binary (stdin);
         if (argc == 2 && opt.outfile)
           log_info ("option --output ignored for a detached signature\n");
         else if (opt.outfile)
           fp = open_es_fwrite (opt.outfile);
 
         if (!argc)
           gpgsm_verify (&ctrl, 0, -1, fp); /* normal signature from stdin */
         else if (argc == 1)
           gpgsm_verify (&ctrl, open_read (*argv), -1, fp); /* std signature */
         else if (argc == 2) /* detached signature (sig, detached) */
           gpgsm_verify (&ctrl, open_read (*argv), open_read (argv[1]), NULL);
         else
           wrong_args ("--verify [signature [detached_data]]");
 
         es_fclose (fp);
       }
       break;
 
     case aDecrypt:
       {
         estream_t fp = open_es_fwrite (opt.outfile?opt.outfile:"-");
 
         set_binary (stdin);
         if (!argc)
           gpgsm_decrypt (&ctrl, 0, fp); /* from stdin */
         else if (argc == 1)
           gpgsm_decrypt (&ctrl, open_read (*argv), fp); /* from file */
         else
           wrong_args ("--decrypt [filename]");
 
         es_fclose (fp);
       }
       break;
 
     case aDeleteKey:
       for (sl=NULL; argc; argc--, argv++)
         add_to_strlist (&sl, *argv);
       gpgsm_delete (&ctrl, sl);
       free_strlist(sl);
       break;
 
     case aListChain:
     case aDumpChain:
        ctrl.with_chain = 1; /* fall through */
     case aListKeys:
     case aDumpKeys:
     case aListExternalKeys:
     case aDumpExternalKeys:
     case aListSecretKeys:
     case aDumpSecretKeys:
       {
         unsigned int mode;
         estream_t fp;
 
         switch (cmd)
           {
           case aListChain:
           case aListKeys:         mode = (0   | 0 | (1<<6)); break;
           case aDumpChain:
           case aDumpKeys:         mode = (256 | 0 | (1<<6)); break;
           case aListExternalKeys: mode = (0   | 0 | (1<<7)); break;
           case aDumpExternalKeys: mode = (256 | 0 | (1<<7)); break;
           case aListSecretKeys:   mode = (0   | 2 | (1<<6)); break;
           case aDumpSecretKeys:   mode = (256 | 2 | (1<<6)); break;
           default: BUG();
           }
 
         fp = open_es_fwrite (opt.outfile?opt.outfile:"-");
         for (sl=NULL; argc; argc--, argv++)
           add_to_strlist (&sl, *argv);
         gpgsm_list_keys (&ctrl, sl, fp, mode);
         free_strlist(sl);
         es_fclose (fp);
       }
       break;
 
 
     case aKeygen: /* Generate a key; well kind of. */
       {
         estream_t fpin = NULL;
         estream_t fpout;
 
         if (opt.batch)
           {
             if (!argc) /* Create from stdin. */
               fpin = open_es_fread ("-", "r");
             else if (argc == 1) /* From file. */
               fpin = open_es_fread (*argv, "r");
             else
               wrong_args ("--generate-key --batch [parmfile]");
           }
 
         fpout = open_es_fwrite (opt.outfile?opt.outfile:"-");
 
         if (fpin)
           gpgsm_genkey (&ctrl, fpin, fpout);
         else
           gpgsm_gencertreq_tty (&ctrl, fpout);
 
         es_fclose (fpout);
       }
       break;
 
 
     case aImport:
       gpgsm_import_files (&ctrl, argc, argv, open_read);
       break;
 
     case aExport:
       {
         estream_t fp;
 
         fp = open_es_fwrite (opt.outfile?opt.outfile:"-");
         for (sl=NULL; argc; argc--, argv++)
           add_to_strlist (&sl, *argv);
         gpgsm_export (&ctrl, sl, fp);
         free_strlist(sl);
         es_fclose (fp);
       }
       break;
 
     case aExportSecretKeyP12:
       {
         estream_t fp = open_es_fwrite (opt.outfile?opt.outfile:"-");
 
         if (argc == 1)
           gpgsm_p12_export (&ctrl, *argv, fp, 0);
         else
           wrong_args ("--export-secret-key-p12 KEY-ID");
         if (fp != es_stdout)
           es_fclose (fp);
       }
       break;
 
     case aExportSecretKeyP8:
       {
         estream_t fp = open_es_fwrite (opt.outfile?opt.outfile:"-");
 
         if (argc == 1)
           gpgsm_p12_export (&ctrl, *argv, fp, 1);
         else
           wrong_args ("--export-secret-key-p8 KEY-ID");
         if (fp != es_stdout)
           es_fclose (fp);
       }
       break;
 
     case aExportSecretKeyRaw:
       {
         estream_t fp = open_es_fwrite (opt.outfile?opt.outfile:"-");
 
         if (argc == 1)
           gpgsm_p12_export (&ctrl, *argv, fp, 2);
         else
           wrong_args ("--export-secret-key-raw KEY-ID");
         if (fp != es_stdout)
           es_fclose (fp);
       }
       break;
 
     case aSendKeys:
     case aRecvKeys:
       log_error ("this command has not yet been implemented\n");
       break;
 
 
     case aLearnCard:
       if (argc)
         wrong_args ("--learn-card");
       else
         {
           int rc = gpgsm_agent_learn (&ctrl);
           if (rc)
             log_error ("error learning card: %s\n", gpg_strerror (rc));
         }
       break;
 
     case aPasswd:
       if (argc != 1)
         wrong_args ("--change-passphrase <key-Id>");
       else
         {
           int rc;
           ksba_cert_t cert = NULL;
           char *grip = NULL;
 
           rc = gpgsm_find_cert (&ctrl, *argv, NULL, &cert, 0);
           if (rc)
             ;
           else if (!(grip = gpgsm_get_keygrip_hexstring (cert)))
             rc = gpg_error (GPG_ERR_BUG);
           else
             {
               char *desc = gpgsm_format_keydesc (cert);
               rc = gpgsm_agent_passwd (&ctrl, grip, desc);
               xfree (desc);
             }
           if (rc)
             log_error ("error changing passphrase: %s\n", gpg_strerror (rc));
           xfree (grip);
           ksba_cert_release (cert);
         }
       break;
 
     case aKeydbClearSomeCertFlags:
       for (sl=NULL; argc; argc--, argv++)
         add_to_strlist (&sl, *argv);
       keydb_clear_some_cert_flags (&ctrl, sl);
       free_strlist(sl);
       break;
 
 
     default:
         log_error (_("invalid command (there is no implicit command)\n"));
 	break;
     }
 
   /* Print the audit result if needed.  */
   if ((auditlog && auditfp) || (htmlauditlog && htmlauditfp))
     {
       if (auditlog && auditfp)
         audit_print_result (ctrl.audit, auditfp, 0);
       if (htmlauditlog && htmlauditfp)
         audit_print_result (ctrl.audit, htmlauditfp, 1);
       audit_release (ctrl.audit);
       ctrl.audit = NULL;
       es_fclose (auditfp);
       es_fclose (htmlauditfp);
     }
 
   /* cleanup */
   keyserver_list_free (opt.keyserver);
   opt.keyserver = NULL;
   gpgsm_release_certlist (recplist);
   gpgsm_release_certlist (signerlist);
   FREE_STRLIST (remusr);
   FREE_STRLIST (locusr);
   gpgsm_exit(0);
   return 8; /*NOTREACHED*/
 }
 
 /* Note: This function is used by signal handlers!. */
 static void
 emergency_cleanup (void)
 {
   gcry_control (GCRYCTL_TERM_SECMEM );
 }
 
 
 void
 gpgsm_exit (int rc)
 {
   gcry_control (GCRYCTL_UPDATE_RANDOM_SEED_FILE);
   if (opt.debug & DBG_MEMSTAT_VALUE)
     {
       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
     }
   if (opt.debug)
     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
   emergency_cleanup ();
   rc = rc? rc : log_get_errorcount(0)? 2 : gpgsm_errors_seen? 1 : 0;
   exit (rc);
 }
 
 
 void
 gpgsm_init_default_ctrl (struct server_control_s *ctrl)
 {
   ctrl->include_certs = default_include_certs;
   ctrl->use_ocsp = opt.enable_ocsp;
   ctrl->validation_model = default_validation_model;
   ctrl->offline = opt.disable_dirmngr;
 }
 
 
 int
 gpgsm_parse_validation_model (const char *model)
 {
   if (!ascii_strcasecmp (model, "shell") )
     return 0;
   else if ( !ascii_strcasecmp (model, "chain") )
     return 1;
   else if ( !ascii_strcasecmp (model, "steed") )
     return 2;
   else
     return -1;
 }
 
 
 
 /* Open the FILENAME for read and return the file descriptor.  Stop
    with an error message in case of problems.  "-" denotes stdin and
    if special filenames are allowed the given fd is opened instead.  */
 static int
 open_read (const char *filename)
 {
   int fd;
 
   if (filename[0] == '-' && !filename[1])
     {
       set_binary (stdin);
       return 0; /* stdin */
     }
   fd = check_special_filename (filename, 0, 0);
   if (fd != -1)
     return fd;
   fd = open (filename, O_RDONLY | O_BINARY);
   if (fd == -1)
     {
       log_error (_("can't open '%s': %s\n"), filename, strerror (errno));
       gpgsm_exit (2);
     }
   return fd;
 }
 
 /* Same as open_read but return an estream_t.  */
 static estream_t
 open_es_fread (const char *filename, const char *mode)
 {
   int fd;
   estream_t fp;
 
   if (filename[0] == '-' && !filename[1])
     fd = fileno (stdin);
   else
     fd = check_special_filename (filename, 0, 0);
   if (fd != -1)
     {
       fp = es_fdopen_nc (fd, mode);
       if (!fp)
         {
           log_error ("es_fdopen(%d) failed: %s\n", fd, strerror (errno));
           gpgsm_exit (2);
         }
       return fp;
     }
   fp = es_fopen (filename, mode);
   if (!fp)
     {
       log_error (_("can't open '%s': %s\n"), filename, strerror (errno));
       gpgsm_exit (2);
     }
   return fp;
 }
 
 
 /* Open FILENAME for fwrite and return an extended stream.  Stop with
    an error message in case of problems.  "-" denotes stdout and if
    special filenames are allowed the given fd is opened instead.
    Caller must close the returned stream. */
 static estream_t
 open_es_fwrite (const char *filename)
 {
   int fd;
   estream_t fp;
 
   if (filename[0] == '-' && !filename[1])
     {
       fflush (stdout);
       fp = es_fdopen_nc (fileno(stdout), "wb");
       return fp;
     }
 
   fd = check_special_filename (filename, 1, 0);
   if (fd != -1)
     {
       fp = es_fdopen_nc (fd, "wb");
       if (!fp)
         {
           log_error ("es_fdopen(%d) failed: %s\n", fd, strerror (errno));
           gpgsm_exit (2);
         }
       return fp;
     }
   fp = es_fopen (filename, "wb");
   if (!fp)
     {
       log_error (_("can't open '%s': %s\n"), filename, strerror (errno));
       gpgsm_exit (2);
     }
   return fp;
 }
 
 
 static void
 run_protect_tool (int argc, char **argv)
 {
 #ifdef HAVE_W32_SYSTEM
   (void)argc;
   (void)argv;
 #else
   const char *pgm;
   char **av;
   int i;
 
   if (!opt.protect_tool_program || !*opt.protect_tool_program)
     pgm = gnupg_module_name (GNUPG_MODULE_NAME_PROTECT_TOOL);
   else
     pgm = opt.protect_tool_program;
 
   av = xcalloc (argc+2, sizeof *av);
   av[0] = strrchr (pgm, '/');
   if (!av[0])
     av[0] = xstrdup (pgm);
   for (i=1; argc; i++, argc--, argv++)
     av[i] = *argv;
   av[i] = NULL;
   execv (pgm, av);
   log_error ("error executing '%s': %s\n", pgm, strerror (errno));
 #endif /*!HAVE_W32_SYSTEM*/
   gpgsm_exit (2);
 }
diff --git a/sm/gpgsm.h b/sm/gpgsm.h
index a9fb4c89b..d81e39230 100644
--- a/sm/gpgsm.h
+++ b/sm/gpgsm.h
@@ -1,441 +1,442 @@
 /* gpgsm.h - Global definitions for GpgSM
  * Copyright (C) 2001, 2003, 2004, 2007, 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 GPGSM_H
 #define GPGSM_H
 
 #ifdef GPG_ERR_SOURCE_DEFAULT
 #error GPG_ERR_SOURCE_DEFAULT already defined
 #endif
 #define GPG_ERR_SOURCE_DEFAULT  GPG_ERR_SOURCE_GPGSM
 #include <gpg-error.h>
 
 
 #include <ksba.h>
 #include "../common/util.h"
 #include "../common/status.h"
 #include "../common/audit.h"
 #include "../common/session-env.h"
 #include "../common/ksba-io-support.h"
 #include "../common/compliance.h"
 
 
 #define MAX_DIGEST_LEN 64
 
 struct keyserver_spec
 {
   struct keyserver_spec *next;
 
   char *host;
   int port;
   char *user;
   char *pass;
   char *base;
 };
 
 
 /* A large struct named "opt" to keep global flags. */
 EXTERN_UNLESS_MAIN_MODULE
 struct
 {
   unsigned int debug; /* debug flags (DBG_foo_VALUE) */
   int verbose;      /* verbosity level */
   int quiet;        /* be as quiet as possible */
   int batch;        /* run in batch mode, i.e w/o any user interaction */
   int answer_yes;   /* assume yes on most questions */
   int answer_no;    /* assume no on most questions */
   int dry_run;      /* don't change any persistent data */
   int no_homedir_creation;
 
   const char *config_filename; /* Name of the used config file. */
   const char *agent_program;
 
   session_env_t session_env;
   char *lc_ctype;
   char *lc_messages;
 
   int autostart;
   const char *dirmngr_program;
   int disable_dirmngr;        /* Do not do any dirmngr calls.  */
   const char *protect_tool_program;
   char *outfile;    /* name of output file */
 
   int with_key_data;/* include raw key in the column delimted output */
 
   int fingerprint;  /* list fingerprints in all key listings */
 
   int with_md5_fingerprint; /* Also print an MD5 fingerprint for
                                standard key listings. */
 
   int with_keygrip; /* Option --with-keygrip active.  */
 
   int pinentry_mode;
   int request_origin;
 
   int armor;        /* force base64 armoring (see also ctrl.with_base64) */
   int no_armor;     /* don't try to figure out whether data is base64 armored*/
 
   const char *p12_charset; /* Use this charset for encoding the
                               pkcs#12 passphrase.  */
 
 
   const char *def_cipher_algoid;  /* cipher algorithm to use if
                                      nothing else is specified */
 
   int def_compress_algo;  /* Ditto for compress algorithm */
 
   int forced_digest_algo; /* User forced hash algorithm. */
 
   char *def_recipient;    /* userID of the default recipient */
   int def_recipient_self; /* The default recipient is the default key */
 
   int no_encrypt_to;      /* Ignore all as encrypt to marked recipients. */
 
   char *local_user;       /* NULL or argument to -u */
 
   int extra_digest_algo;  /* A digest algorithm also used for
                              verification of signatures.  */
 
   int always_trust;       /* Trust the given keys even if there is no
                              valid certification chain */
   int skip_verify;        /* do not check signatures on data */
 
   int lock_once;          /* Keep lock once they are set */
 
   int ignore_time_conflict; /* Ignore certain time conflicts */
 
   int no_crl_check;         /* Don't do a CRL check */
   int no_trusted_cert_crl_check; /* Don't run a CRL check for trusted certs. */
   int force_crl_refresh;    /* Force refreshing the CRL. */
+  int enable_issuer_based_crl_check; /* Backward compatibility hack.  */
   int enable_ocsp;          /* Default to use OCSP checks. */
 
   char *policy_file;        /* full pathname of policy file */
   int no_policy_check;      /* ignore certificate policies */
   int no_chain_validation;  /* Bypass all cert chain validity tests */
   int ignore_expiration;    /* Ignore the notAfter validity checks. */
 
   int auto_issuer_key_retrieve; /* try to retrieve a missing issuer key. */
 
   int qualsig_approval;     /* Set to true if this software has
                                officially been approved to create an
                                verify qualified signatures.  This is a
                                runtime option in case we want to check
                                the integrity of the software at
                                runtime. */
 
   struct keyserver_spec *keyserver;
 
   /* A list of certificate extension OIDs which are ignored so that
      one can claim that a critical extension has been handled.  One
      OID per string.  */
   strlist_t ignored_cert_extensions;
 
   enum gnupg_compliance_mode compliance;
 } opt;
 
 /* Debug values and macros.  */
 #define DBG_X509_VALUE    1	/* debug x.509 data reading/writing */
 #define DBG_MPI_VALUE	  2	/* debug mpi details */
 #define DBG_CRYPTO_VALUE  4	/* debug low level crypto */
 #define DBG_MEMORY_VALUE  32	/* debug memory allocation stuff */
 #define DBG_CACHE_VALUE   64	/* debug the caching */
 #define DBG_MEMSTAT_VALUE 128	/* show memory statistics */
 #define DBG_HASHING_VALUE 512	/* debug hashing operations */
 #define DBG_IPC_VALUE     1024  /* debug assuan communication */
 
 #define DBG_X509    (opt.debug & DBG_X509_VALUE)
 #define DBG_CRYPTO  (opt.debug & DBG_CRYPTO_VALUE)
 #define DBG_MEMORY  (opt.debug & DBG_MEMORY_VALUE)
 #define DBG_CACHE   (opt.debug & DBG_CACHE_VALUE)
 #define DBG_HASHING (opt.debug & DBG_HASHING_VALUE)
 #define DBG_IPC     (opt.debug & DBG_IPC_VALUE)
 
 /* Forward declaration for an object defined in server.c */
 struct server_local_s;
 
 /* Session control object.  This object is passed down to most
    functions.  Note that the default values for it are set by
    gpgsm_init_default_ctrl(). */
 struct server_control_s
 {
   int no_server;      /* We are not running under server control */
   int  status_fd;     /* Only for non-server mode */
   struct server_local_s *server_local;
 
   audit_ctx_t audit;  /* NULL or a context for the audit subsystem.  */
   int agent_seen;     /* Flag indicating that the gpg-agent has been
                          accessed.  */
 
   int with_colons;    /* Use column delimited output format */
   int with_secret;    /* Mark secret keys in a public key listing.  */
   int with_chain;     /* Include the certifying certs in a listing */
   int with_validation;/* Validate each key while listing. */
   int with_ephemeral_keys;  /* Include ephemeral flagged keys in the
                                keylisting. */
 
   int autodetect_encoding; /* Try to detect the input encoding */
   int is_pem;         /* Is in PEM format */
   int is_base64;      /* is in plain base-64 format */
 
   int create_base64;  /* Create base64 encoded output */
   int create_pem;     /* create PEM output */
   const char *pem_name; /* PEM name to use */
 
   int include_certs;  /* -1 to send all certificates in the chain
                          along with a signature or the number of
                          certificates up the chain (0 = none, 1 = only
                          signer) */
   int use_ocsp;       /* Set to true if OCSP should be used. */
   int validation_model; /* 0 := standard model (shell),
                            1 := chain model,
                            2 := STEED model. */
   int offline;        /* If true gpgsm won't do any network access.  */
 
   /* The current time.  Used as a helper in certchain.c.  */
   ksba_isotime_t current_time;
 };
 
 
 /* An object to keep a list of certificates. */
 struct certlist_s
 {
   struct certlist_s *next;
   ksba_cert_t cert;
   int is_encrypt_to; /* True if the certificate has been set through
                         the --encrypto-to option. */
   int hash_algo;     /* Used to track the hash algorithm to use.  */
   const char *hash_algo_oid;  /* And the corresponding OID.  */
 };
 typedef struct certlist_s *certlist_t;
 
 
 /* A structure carrying information about trusted root certificates. */
 struct rootca_flags_s
 {
   unsigned int valid:1;  /* The rest of the structure has valid
                             information.  */
   unsigned int relax:1;  /* Relax checking of root certificates.  */
   unsigned int chain_model:1; /* Root requires the use of the chain model.  */
 };
 
 
 
 /*-- gpgsm.c --*/
 void gpgsm_exit (int rc);
 void gpgsm_init_default_ctrl (struct server_control_s *ctrl);
 int  gpgsm_parse_validation_model (const char *model);
 
 /*-- server.c --*/
 void gpgsm_server (certlist_t default_recplist);
 gpg_error_t gpgsm_status (ctrl_t ctrl, int no, const char *text);
 gpg_error_t gpgsm_status2 (ctrl_t ctrl, int no, ...) GPGRT_ATTR_SENTINEL(0);
 gpg_error_t gpgsm_status_with_err_code (ctrl_t ctrl, int no, const char *text,
                                         gpg_err_code_t ec);
 gpg_error_t gpgsm_status_with_error (ctrl_t ctrl, int no, const char *text,
                                      gpg_error_t err);
 gpg_error_t gpgsm_proxy_pinentry_notify (ctrl_t ctrl,
                                          const unsigned char *line);
 
 /*-- fingerprint --*/
 unsigned char *gpgsm_get_fingerprint (ksba_cert_t cert, int algo,
                                       unsigned char *array, int *r_len);
 char *gpgsm_get_fingerprint_string (ksba_cert_t cert, int algo);
 char *gpgsm_get_fingerprint_hexstring (ksba_cert_t cert, int algo);
 unsigned long gpgsm_get_short_fingerprint (ksba_cert_t cert,
                                            unsigned long *r_high);
 unsigned char *gpgsm_get_keygrip (ksba_cert_t cert, unsigned char *array);
 char *gpgsm_get_keygrip_hexstring (ksba_cert_t cert);
 int  gpgsm_get_key_algo_info (ksba_cert_t cert, unsigned int *nbits);
 char *gpgsm_get_certid (ksba_cert_t cert);
 
 
 /*-- certdump.c --*/
 void gpgsm_print_serial (estream_t fp, ksba_const_sexp_t p);
 void gpgsm_print_time (estream_t fp, ksba_isotime_t t);
 void gpgsm_print_name2 (FILE *fp, const char *string, int translate);
 void gpgsm_print_name (FILE *fp, const char *string);
 void gpgsm_es_print_name (estream_t fp, const char *string);
 void gpgsm_es_print_name2 (estream_t fp, const char *string, int translate);
 
 void gpgsm_cert_log_name (const char *text, ksba_cert_t cert);
 
 void gpgsm_dump_cert (const char *text, ksba_cert_t cert);
 void gpgsm_dump_serial (ksba_const_sexp_t p);
 void gpgsm_dump_time (ksba_isotime_t t);
 void gpgsm_dump_string (const char *string);
 
 char *gpgsm_format_serial (ksba_const_sexp_t p);
 char *gpgsm_format_name2 (const char *name, int translate);
 char *gpgsm_format_name (const char *name);
 char *gpgsm_format_sn_issuer (ksba_sexp_t sn, const char *issuer);
 
 char *gpgsm_fpr_and_name_for_status (ksba_cert_t cert);
 
 char *gpgsm_format_keydesc (ksba_cert_t cert);
 
 
 /*-- certcheck.c --*/
 int gpgsm_check_cert_sig (ksba_cert_t issuer_cert, ksba_cert_t cert);
 int gpgsm_check_cms_signature (ksba_cert_t cert, ksba_const_sexp_t sigval,
                                gcry_md_hd_t md, int hash_algo, int *r_pkalgo);
 /* fixme: move create functions to another file */
 int gpgsm_create_cms_signature (ctrl_t ctrl,
                                 ksba_cert_t cert, gcry_md_hd_t md, int mdalgo,
                                 unsigned char **r_sigval);
 
 
 /*-- certchain.c --*/
 
 /* Flags used with  gpgsm_validate_chain.  */
 #define VALIDATE_FLAG_NO_DIRMNGR  1
 #define VALIDATE_FLAG_CHAIN_MODEL 2
 #define VALIDATE_FLAG_STEED       4
 
 int gpgsm_walk_cert_chain (ctrl_t ctrl,
                            ksba_cert_t start, ksba_cert_t *r_next);
 int gpgsm_is_root_cert (ksba_cert_t cert);
 int gpgsm_validate_chain (ctrl_t ctrl, ksba_cert_t cert,
                           ksba_isotime_t checktime,
                           ksba_isotime_t r_exptime,
                           int listmode, estream_t listfp,
                           unsigned int flags, unsigned int *retflags);
 int gpgsm_basic_cert_check (ctrl_t ctrl, ksba_cert_t cert);
 
 /*-- certlist.c --*/
 int gpgsm_cert_use_sign_p (ksba_cert_t cert, int silent);
 int gpgsm_cert_use_encrypt_p (ksba_cert_t cert);
 int gpgsm_cert_use_verify_p (ksba_cert_t cert);
 int gpgsm_cert_use_decrypt_p (ksba_cert_t cert);
 int gpgsm_cert_use_cert_p (ksba_cert_t cert);
 int gpgsm_cert_use_ocsp_p (ksba_cert_t cert);
 int gpgsm_cert_has_well_known_private_key (ksba_cert_t cert);
 int gpgsm_certs_identical_p (ksba_cert_t cert_a, ksba_cert_t cert_b);
 int gpgsm_add_cert_to_certlist (ctrl_t ctrl, ksba_cert_t cert,
                                 certlist_t *listaddr, int is_encrypt_to);
 int gpgsm_add_to_certlist (ctrl_t ctrl, const char *name, int secret,
                            certlist_t *listaddr, int is_encrypt_to);
 void gpgsm_release_certlist (certlist_t list);
 int gpgsm_find_cert (ctrl_t ctrl, const char *name, ksba_sexp_t keyid,
                      ksba_cert_t *r_cert, int allow_ambiguous);
 
 /*-- keylist.c --*/
 gpg_error_t gpgsm_list_keys (ctrl_t ctrl, strlist_t names,
                              estream_t fp, unsigned int mode);
 
 /*-- import.c --*/
 int gpgsm_import (ctrl_t ctrl, int in_fd, int reimport_mode);
 int gpgsm_import_files (ctrl_t ctrl, int nfiles, char **files,
                         int (*of)(const char *fname));
 
 /*-- export.c --*/
 void gpgsm_export (ctrl_t ctrl, strlist_t names, estream_t stream);
 void gpgsm_p12_export (ctrl_t ctrl, const char *name, estream_t stream,
                        int rawmode);
 
 /*-- delete.c --*/
 int gpgsm_delete (ctrl_t ctrl, strlist_t names);
 
 /*-- verify.c --*/
 int gpgsm_verify (ctrl_t ctrl, int in_fd, int data_fd, estream_t out_fp);
 
 /*-- sign.c --*/
 int gpgsm_get_default_cert (ctrl_t ctrl, ksba_cert_t *r_cert);
 int gpgsm_sign (ctrl_t ctrl, certlist_t signerlist,
                 int data_fd, int detached, estream_t out_fp);
 
 /*-- encrypt.c --*/
 int gpgsm_encrypt (ctrl_t ctrl, certlist_t recplist,
                    int in_fd, estream_t out_fp);
 
 /*-- decrypt.c --*/
 int gpgsm_decrypt (ctrl_t ctrl, int in_fd, estream_t out_fp);
 
 /*-- certreqgen.c --*/
 int gpgsm_genkey (ctrl_t ctrl, estream_t in_stream, estream_t out_stream);
 
 /*-- certreqgen-ui.c --*/
 void gpgsm_gencertreq_tty (ctrl_t ctrl, estream_t out_stream);
 
 
 /*-- qualified.c --*/
 gpg_error_t gpgsm_is_in_qualified_list (ctrl_t ctrl, ksba_cert_t cert,
                                         char *country);
 gpg_error_t gpgsm_qualified_consent (ctrl_t ctrl, ksba_cert_t cert);
 gpg_error_t gpgsm_not_qualified_warning (ctrl_t ctrl, ksba_cert_t cert);
 
 /*-- call-agent.c --*/
 int gpgsm_agent_pksign (ctrl_t ctrl, const char *keygrip, const char *desc,
                         unsigned char *digest,
                         size_t digestlen,
                         int digestalgo,
                         unsigned char **r_buf, size_t *r_buflen);
 int gpgsm_scd_pksign (ctrl_t ctrl, const char *keyid, const char *desc,
                       unsigned char *digest, size_t digestlen, int digestalgo,
                       unsigned char **r_buf, size_t *r_buflen);
 int gpgsm_agent_pkdecrypt (ctrl_t ctrl, const char *keygrip, const char *desc,
                            ksba_const_sexp_t ciphertext,
                            char **r_buf, size_t *r_buflen);
 int gpgsm_agent_genkey (ctrl_t ctrl,
                         ksba_const_sexp_t keyparms, ksba_sexp_t *r_pubkey);
 int gpgsm_agent_readkey (ctrl_t ctrl, int fromcard, const char *hexkeygrip,
                          ksba_sexp_t *r_pubkey);
 int gpgsm_agent_scd_serialno (ctrl_t ctrl, char **r_serialno);
 int gpgsm_agent_scd_keypairinfo (ctrl_t ctrl, strlist_t *r_list);
 int gpgsm_agent_istrusted (ctrl_t ctrl, ksba_cert_t cert, const char *hexfpr,
                            struct rootca_flags_s *rootca_flags);
 int gpgsm_agent_havekey (ctrl_t ctrl, const char *hexkeygrip);
 int gpgsm_agent_marktrusted (ctrl_t ctrl, ksba_cert_t cert);
 int gpgsm_agent_learn (ctrl_t ctrl);
 int gpgsm_agent_passwd (ctrl_t ctrl, const char *hexkeygrip, const char *desc);
 gpg_error_t gpgsm_agent_get_confirmation (ctrl_t ctrl, const char *desc);
 gpg_error_t gpgsm_agent_send_nop (ctrl_t ctrl);
 gpg_error_t gpgsm_agent_keyinfo (ctrl_t ctrl, const char *hexkeygrip,
                                  char **r_serialno);
 gpg_error_t gpgsm_agent_ask_passphrase (ctrl_t ctrl, const char *desc_msg,
                                         int repeat, char **r_passphrase);
 gpg_error_t gpgsm_agent_keywrap_key (ctrl_t ctrl, int forexport,
                                      void **r_kek, size_t *r_keklen);
 gpg_error_t gpgsm_agent_import_key (ctrl_t ctrl,
                                     const void *key, size_t keylen);
 gpg_error_t gpgsm_agent_export_key (ctrl_t ctrl, const char *keygrip,
                                     const char *desc,
                                     unsigned char **r_result,
                                     size_t *r_resultlen);
 
 /*-- call-dirmngr.c --*/
 int gpgsm_dirmngr_isvalid (ctrl_t ctrl,
                            ksba_cert_t cert, ksba_cert_t issuer_cert,
                            int use_ocsp);
 int gpgsm_dirmngr_lookup (ctrl_t ctrl, strlist_t names, int cache_only,
                           void (*cb)(void*, ksba_cert_t), void *cb_value);
 int gpgsm_dirmngr_run_command (ctrl_t ctrl, const char *command,
                                int argc, char **argv);
 
 
 /*-- misc.c --*/
 void setup_pinentry_env (void);
 gpg_error_t transform_sigval (const unsigned char *sigval, size_t sigvallen,
                               int mdalgo,
                               unsigned char **r_newsigval,
                               size_t *r_newsigvallen);
 
 
 
 #endif /*GPGSM_H*/