gpg: Rename cipher.c to cipher-cfb.c
[gnupg.git] / g10 / trustdb.c
index 8c732bb..0a98c12 100644 (file)
@@ -1,11 +1,12 @@
 /* trustdb.c
- * Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
+ *               2008, 2012 Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
  * GnuPG is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
+ * 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,
  * 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, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ * 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 <assert.h>
 
 #ifndef DISABLE_REGEX
 #include <sys/types.h>
-#ifdef USE_GNU_REGEX
-#include "_regex.h"
-#else
 #include <regex.h>
-#endif
 #endif /* !DISABLE_REGEX */
 
-#include "errors.h"
-#include "iobuf.h"
+#include "gpg.h"
+#include "../common/status.h"
+#include "../common/iobuf.h"
 #include "keydb.h"
-#include "memory.h"
-#include "util.h"
+#include "../common/util.h"
 #include "options.h"
 #include "packet.h"
 #include "main.h"
-#include "i18n.h"
+#include "../common/mbox-util.h"
+#include "../common/i18n.h"
 #include "tdbio.h"
 #include "trustdb.h"
-
-
-/*
- * A structure to store key identification as well as some stuff needed
- * for validation 
- */
-struct key_item {
-  struct key_item *next;
-  unsigned int ownertrust,min_ownertrust;
-  byte trust_depth;
-  byte trust_value;
-  char *trust_regexp;
-  u32 kid[2];
-};
+#include "tofu.h"
 
 
 typedef struct key_item **KeyHashTable; /* see new_key_hash_table() */
 
 /*
  * Structure to keep track of keys, this is used as an array wherre
- * the item right after the last one has a keyblock set to NULL. 
+ * the item right after the last one has a keyblock set to NULL.
  * Maybe we can drop this thing and replace it by key_item
  */
-struct key_array {
+struct key_array
+{
   KBNODE keyblock;
 };
 
 
-/* control information for the trust DB */
-static struct {
-    int init;
-    int level;
-    char *dbname;
+/* Control information for the trust DB.  */
+static struct
+{
+  int init;
+  int level;
+  char *dbname;
+  int no_trustdb;
 } trustdb_args;
 
-/* some globals */
+/* Some globals.  */
 static struct key_item *user_utk_list; /* temp. used to store --trusted-keys */
 static struct key_item *utk_list;      /* all ultimately trusted keys */
 
 static int pending_check_trustdb;
 
-static int validate_keys (int interactive);
+static int validate_keys (ctrl_t ctrl, int interactive);
 
 \f
 /**********************************************
@@ -96,8 +82,8 @@ static struct key_item *
 new_key_item (void)
 {
   struct key_item *k;
-  
-  k = m_alloc_clear (sizeof *k);
+
+  k = xmalloc_clear (sizeof *k);
   return k;
 }
 
@@ -109,25 +95,27 @@ release_key_items (struct key_item *k)
   for (; k; k = k2)
     {
       k2 = k->next;
-      m_free (k->trust_regexp);
-      m_free (k);
+      xfree (k->trust_regexp);
+      xfree (k);
     }
 }
 
+#define KEY_HASH_TABLE_SIZE 1024
+
 /*
- * For fast keylook up we need a hash table.  Each byte of a KeyIDs
+ * For fast keylook up we need a hash table.  Each byte of a KeyID
  * should be distributed equally over the 256 possible values (except
  * for v3 keyIDs but we consider them as not important here). So we
- * can just use 10 bits to index a table of 1024 key items. 
- * Possible optimization: Don not use key_items but other hash_table when the
- * duplicates lists gets too large. 
+ * can just use 10 bits to index a table of KEY_HASH_TABLE_SIZE key items.
+ * Possible optimization: Do not use key_items but other hash_table when the
+ * duplicates lists get too large.
  */
-static KeyHashTable 
+static KeyHashTable
 new_key_hash_table (void)
 {
   struct key_item **tbl;
 
-  tbl = m_alloc_clear (1024 * sizeof *tbl);
+  tbl = xmalloc_clear (KEY_HASH_TABLE_SIZE * sizeof *tbl);
   return tbl;
 }
 
@@ -138,12 +126,12 @@ release_key_hash_table (KeyHashTable tbl)
 
   if (!tbl)
     return;
-  for (i=0; i < 1024; i++)
+  for (i=0; i < KEY_HASH_TABLE_SIZE; i++)
     release_key_items (tbl[i]);
-  m_free (tbl);
+  xfree (tbl);
 }
 
-/* 
+/*
  * Returns: True if the keyID is in the given hash table
  */
 static int
@@ -151,7 +139,7 @@ test_key_hash_table (KeyHashTable tbl, u32 *kid)
 {
   struct key_item *k;
 
-  for (k = tbl[(kid[1] & 0x03ff)]; k; k = k->next)
+  for (k = tbl[(kid[1] % KEY_HASH_TABLE_SIZE)]; k; k = k->next)
     if (k->kid[0] == kid[0] && k->kid[1] == kid[1])
       return 1;
   return 0;
@@ -163,17 +151,18 @@ test_key_hash_table (KeyHashTable tbl, u32 *kid)
 static void
 add_key_hash_table (KeyHashTable tbl, u32 *kid)
 {
+  int i = kid[1] % KEY_HASH_TABLE_SIZE;
   struct key_item *k, *kk;
 
-  for (k = tbl[(kid[1] & 0x03ff)]; k; k = k->next)
+  for (k = tbl[i]; k; k = k->next)
     if (k->kid[0] == kid[0] && k->kid[1] == kid[1])
       return; /* already in table */
-  
+
   kk = new_key_item ();
   kk->kid[0] = kid[0];
   kk->kid[1] = kid[1];
-  kk->next = tbl[(kid[1] & 0x03ff)];
-  tbl[(kid[1] & 0x03ff)] = kk;
+  kk->next = tbl[i];
+  tbl[i] = kk;
 }
 
 /*
@@ -187,7 +176,7 @@ release_key_array ( struct key_array *keys )
     if (keys) {
         for (k=keys; k->keyblock; k++)
             release_kbnode (k->keyblock);
-        m_free (keys);
+        xfree (keys);
     }
 }
 
@@ -204,39 +193,44 @@ release_key_array ( struct key_array *keys )
  * FIXME: Should be replaced by a function to add those keys to the trustdb.
  */
 void
-register_trusted_key( const char *string )
+tdb_register_trusted_keyid (u32 *keyid)
 {
-  KEYDB_SEARCH_DESC desc;
   struct key_item *k;
 
-  if (classify_user_id (string, &desc) != KEYDB_SEARCH_MODE_LONG_KID ) {
-    log_error(_("`%s' is not a valid long keyID\n"), string );
-    return;
-  }
-
   k = new_key_item ();
-  k->kid[0] = desc.u.kid[0];
-  k->kid[1] = desc.u.kid[1];
+  k->kid[0] = keyid[0];
+  k->kid[1] = keyid[1];
   k->next = user_utk_list;
   user_utk_list = k;
 }
 
+void
+tdb_register_trusted_key( const char *string )
+{
+  gpg_error_t err;
+  KEYDB_SEARCH_DESC desc;
+
+  err = classify_user_id (string, &desc, 1);
+  if (err || desc.mode != KEYDB_SEARCH_MODE_LONG_KID )
+    {
+      log_error(_("'%s' is not a valid long keyID\n"), string );
+      return;
+    }
+
+  register_trusted_keyid(desc.u.kid);
+}
+
 /*
  * Helper to add a key to the global list of ultimately trusted keys.
- * Retruns: true = inserted, false = already in in list.
+ * Returns: true = inserted, false = already in list.
  */
 static int
 add_utk (u32 *kid)
 {
   struct key_item *k;
 
-  for (k = utk_list; k; k = k->next) 
-    {
-      if (k->kid[0] == kid[0] && k->kid[1] == kid[1])
-        {
-          return 0;
-        }
-    }
+  if (tdb_keyid_is_utk (kid))
+    return 0;
 
   k = new_key_item ();
   k->kid[0] = kid[0];
@@ -245,7 +239,7 @@ add_utk (u32 *kid)
   k->next = utk_list;
   utk_list = k;
   if( opt.verbose > 1 )
-    log_info(_("key %08lX: accepted as trusted key\n"), (ulong)kid[1]);
+    log_info(_("key %s: accepted as trusted key\n"), keystr(kid));
   return 1;
 }
 
@@ -254,7 +248,7 @@ add_utk (u32 *kid)
  * Verify that all our secret keys are usable and put them into the utk_list.
  */
 static void
-verify_own_keys(void)
+verify_own_keys (ctrl_t ctrl)
 {
   TRUSTREC rec;
   ulong recnum;
@@ -265,15 +259,15 @@ verify_own_keys(void)
     return;
 
   /* scan the trustdb to find all ultimately trusted keys */
-  for (recnum=1; !tdbio_read_record (recnum, &rec, 0); recnum++ ) 
+  for (recnum=1; !tdbio_read_record (recnum, &rec, 0); recnum++ )
     {
-      if ( rec.rectype == RECTYPE_TRUST 
+      if ( rec.rectype == RECTYPE_TRUST
            && (rec.r.trust.ownertrust & TRUST_MASK) == TRUST_ULTIMATE)
         {
             byte *fpr = rec.r.trust.fingerprint;
             int fprlen;
             u32 kid[2];
-            
+
             /* Problem: We do only use fingerprints in the trustdb but
              * we need the keyID here to indetify the key; we can only
              * use that ugly hack to distinguish between 16 and 20
@@ -281,45 +275,62 @@ verify_own_keys(void)
              * the whole validation code to only work with
              * fingerprints */
             fprlen = (!fpr[16] && !fpr[17] && !fpr[18] && !fpr[19])? 16:20;
-            keyid_from_fingerprint (fpr, fprlen, kid);
+            keyid_from_fingerprint (ctrl, fpr, fprlen, kid);
             if (!add_utk (kid))
-                log_info(_("key %08lX occurs more than once in the trustdb\n"),
-                            (ulong)kid[1]);
+             log_info(_("key %s occurs more than once in the trustdb\n"),
+                      keystr(kid));
         }
     }
-  
-  /* the --trusted-key option is again deprecated; however we automagically
-   * add those keys to the trustdb */
-  for (k = user_utk_list; k; k = k->next) 
+
+  /* Put any --trusted-key keys into the trustdb */
+  for (k = user_utk_list; k; k = k->next)
     {
-      if ( add_utk (k->kid) ) 
+      if ( add_utk (k->kid) )
         { /* not yet in trustDB as ultimately trusted */
           PKT_public_key pk;
 
           memset (&pk, 0, sizeof pk);
-          rc = get_pubkey (&pk, k->kid);
-          if (rc) {
-            log_info(_("key %08lX: no public key for trusted key - skipped\n"),
-                     (ulong)k->kid[1] );
-          }
-          else {
-            update_ownertrust (&pk,
-                               ((get_ownertrust (&pk) & ~TRUST_MASK)
-                                | TRUST_ULTIMATE ));
-            release_public_key_parts (&pk);
-          }
-          log_info (_("key %08lX marked as ultimately trusted\n"),
-                    (ulong)k->kid[1]);
+          rc = get_pubkey (ctrl, &pk, k->kid);
+          if (rc)
+           log_info(_("key %s: no public key for trusted key - skipped\n"),
+                    keystr(k->kid));
+          else
+           {
+             tdb_update_ownertrust
+                (ctrl, &pk, ((tdb_get_ownertrust (ctrl, &pk, 0) & ~TRUST_MASK)
+                             | TRUST_ULTIMATE ));
+             release_public_key_parts (&pk);
+           }
+
+          log_info (_("key %s marked as ultimately trusted\n"),keystr(k->kid));
         }
     }
 
-
   /* release the helper table table */
   release_key_items (user_utk_list);
   user_utk_list = NULL;
   return;
 }
 
+/* Returns whether KID is on the list of ultimately trusted keys.  */
+int
+tdb_keyid_is_utk (u32 *kid)
+{
+  struct key_item *k;
+
+  for (k = utk_list; k; k = k->next)
+    if (k->kid[0] == kid[0] && k->kid[1] == kid[1])
+      return 1;
+
+  return 0;
+}
+
+/* Return the list of ultimately trusted keys.  */
+struct key_item *
+tdb_utks (void)
+{
+  return utk_list;
+}
 \f
 /*********************************************
  *********** TrustDB stuff *******************
@@ -335,7 +346,7 @@ read_record (ulong recno, TRUSTREC *rec, int rectype )
   if (rc)
     {
       log_error(_("trust record %lu, req type %d: read failed: %s\n"),
-                recno, rec->rectype, g10_errstr(rc) );
+                recno, rec->rectype, gpg_strerror (rc) );
       tdbio_invalid();
     }
   if (rectype != rec->rectype)
@@ -350,13 +361,13 @@ read_record (ulong recno, TRUSTREC *rec, int rectype )
  * Write a record and die on error
  */
 static void
-write_record (TRUSTREC *rec)
+write_record (ctrl_t ctrl, TRUSTREC *rec)
 {
-  int rc = tdbio_write_record (rec);
+  int rc = tdbio_write_record (ctrl, rec);
   if (rc)
     {
       log_error(_("trust record %lu, type %d: write failed: %s\n"),
-                           rec->recnum, rec->rectype, g10_errstr(rc) );
+                           rec->recnum, rec->rectype, gpg_strerror (rc) );
       tdbio_invalid();
     }
 }
@@ -370,11 +381,26 @@ do_sync(void)
     int rc = tdbio_sync ();
     if(rc)
       {
-        log_error (_("trustdb: sync failed: %s\n"), g10_errstr(rc) );
+        log_error (_("trustdb: sync failed: %s\n"), gpg_strerror (rc) );
         g10_exit(2);
       }
 }
 
+const char *
+trust_model_string (int model)
+{
+  switch (model)
+    {
+    case TM_CLASSIC:  return "classic";
+    case TM_PGP:      return "pgp";
+    case TM_EXTERNAL: return "external";
+    case TM_TOFU:     return "tofu";
+    case TM_TOFU_PGP: return "tofu+pgp";
+    case TM_ALWAYS:   return "always";
+    case TM_DIRECT:   return "direct";
+    default:          return "unknown";
+    }
+}
 
 /****************
  * Perform some checks over the trustdb
@@ -388,112 +414,125 @@ setup_trustdb( int level, const char *dbname )
     if( trustdb_args.init )
        return 0;
     trustdb_args.level = level;
-    trustdb_args.dbname = dbname? m_strdup(dbname): NULL;
+    trustdb_args.dbname = dbname? xstrdup(dbname): NULL;
     return 0;
 }
 
 void
-init_trustdb()
+how_to_fix_the_trustdb ()
+{
+  const char *name = trustdb_args.dbname;
+
+  if (!name)
+    name = "trustdb.gpg";
+
+  log_info (_("You may try to re-create the trustdb using the commands:\n"));
+  log_info ("  cd %s\n", default_homedir ());
+  log_info ("  %s --export-ownertrust > otrust.tmp\n", GPG_NAME);
+#ifdef HAVE_W32_SYSTEM
+  log_info ("  del %s\n", name);
+#else
+  log_info ("  rm %s\n", name);
+#endif
+  log_info ("  %s --import-ownertrust < otrust.tmp\n", GPG_NAME);
+  log_info (_("If that does not work, please consult the manual\n"));
+}
+
+
+/* Initialize the trustdb.  With NO_CREATE set a missing trustdb is
+ * not an error and the function won't terminate the process on error;
+ * in that case 0 is returned if there is a trustdb or an error code
+ * if no trustdb is available.  */
+gpg_error_t
+init_trustdb (ctrl_t ctrl, int no_create)
 {
-  int rc=0;
   int level = trustdb_args.level;
   const char* dbname = trustdb_args.dbname;
 
   if( trustdb_args.init )
-    return;
+    return 0;
 
   trustdb_args.init = 1;
 
-  if ( !level || level==1)
+  if(level==0 || level==1)
     {
-      rc = tdbio_set_dbname( dbname, !!level );
-      if( !rc )
+      int rc = tdbio_set_dbname (ctrl, dbname, (!no_create && level),
+                                 &trustdb_args.no_trustdb);
+      if (no_create && trustdb_args.no_trustdb)
         {
-          if( !level )
-            return;
-          
-          /* verify that our own keys are in the trustDB
-           * or move them to the trustdb. */
-          verify_own_keys();
-          
-          /* should we check whether there is no other ultimately trusted
-           * key in the database? */
+          /* No trustdb found and the caller asked us not to create
+           * it.  Return an error and set the initialization state
+           * back so that we always test for an existing trustdb.  */
+          trustdb_args.init = 0;
+          return gpg_error (GPG_ERR_ENOENT);
         }
+      if (rc)
+       log_fatal("can't init trustdb: %s\n", gpg_strerror (rc) );
     }
   else
     BUG();
-  if( rc )
-    log_fatal("can't init trustdb: %s\n", g10_errstr(rc) );
-}
 
-
-
-\f
-/***********************************************
- ************* Print helpers   ****************
- ***********************************************/
-
-/****************
- * This function returns a letter for a trustvalue  Trust flags
- * are ignore.
- */
-int
-trust_letter (unsigned int value)
-{
-  switch( (value & TRUST_MASK) ) 
+  if(opt.trust_model==TM_AUTO)
     {
-    case TRUST_UNKNOWN:   return '-';
-    case TRUST_EXPIRED:   return 'e';
-    case TRUST_UNDEFINED: return 'q';
-    case TRUST_NEVER:     return 'n';
-    case TRUST_MARGINAL:  return 'm';
-    case TRUST_FULLY:     return 'f';
-    case TRUST_ULTIMATE:  return 'u';
-    default:              return 0;
+      /* Try and set the trust model off of whatever the trustdb says
+        it is. */
+      opt.trust_model=tdbio_read_model();
+
+      /* Sanity check this ;) */
+      if(opt.trust_model != TM_CLASSIC
+        && opt.trust_model != TM_PGP
+        && opt.trust_model != TM_TOFU_PGP
+        && opt.trust_model != TM_TOFU
+        && opt.trust_model != TM_EXTERNAL)
+       {
+         log_info(_("unable to use unknown trust model (%d) - "
+                    "assuming %s trust model\n"),opt.trust_model,"pgp");
+         opt.trust_model = TM_PGP;
+       }
+
+      if(opt.verbose)
+       log_info(_("using %s trust model\n"),
+                 trust_model_string (opt.trust_model));
     }
-}
 
-/* The strings here are similar to those in
-   pkclist.c:do_edit_ownertrust() */
-const char *
-trust_string (unsigned int value)
-{
-  switch( (value & TRUST_MASK) ) 
+  if (opt.trust_model==TM_PGP || opt.trust_model==TM_CLASSIC
+      || opt.trust_model == TM_TOFU || opt.trust_model == TM_TOFU_PGP)
     {
-    case TRUST_UNKNOWN:   return _("unknown trust");
-    case TRUST_EXPIRED:   return _("expired");
-    case TRUST_UNDEFINED: return _("undefined trust");
-    case TRUST_NEVER:     return _("do NOT trust");
-    case TRUST_MARGINAL:  return _("marginal trust");
-    case TRUST_FULLY:     return _("full trust");
-    case TRUST_ULTIMATE:  return _("ultimate trust");
-    default:              return "err";
+      /* Verify the list of ultimately trusted keys and move the
+        --trusted-keys list there as well. */
+      if(level==1)
+       verify_own_keys (ctrl);
+
+      if(!tdbio_db_matches_options())
+       pending_check_trustdb=1;
     }
+
+  return 0;
 }
 
-static const char *
-trust_model_string(void)
+
+/* Check whether we have a trust database, initializing it if
+   necessary if the trust model is not 'always trust'.  Returns true
+   if we do have a usable trust database.  */
+int
+have_trustdb (ctrl_t ctrl)
 {
-  switch(opt.trust_model)
-    {
-    case TM_OPENPGP: return "OpenPGP";
-    case TM_CLASSIC: return "classic";
-    case TM_ALWAYS:  return "always";
-    default:         return "unknown";
-    }
+  return !init_trustdb (ctrl, opt.trust_model == TM_ALWAYS);
 }
 
+
 /****************
  * Recreate the WoT but do not ask for new ownertrusts.  Special
  * feature: In batch mode and without a forced yes, this is only done
  * when a check is due.  This can be used to run the check from a crontab
  */
 void
-check_trustdb ()
+check_trustdb (ctrl_t ctrl)
 {
-  if(opt.trust_model==TM_OPENPGP || opt.trust_model==TM_CLASSIC)
+  init_trustdb (ctrl, 0);
+  if (opt.trust_model == TM_PGP || opt.trust_model == TM_CLASSIC
+      || opt.trust_model == TM_TOFU_PGP || opt.trust_model == TM_TOFU)
     {
-      init_trustdb();
       if (opt.batch && !opt.answer_yes)
        {
          ulong scheduled;
@@ -513,152 +552,201 @@ check_trustdb ()
            }
        }
 
-      validate_keys (0);
+      validate_keys (ctrl, 0);
     }
   else
-    log_info (_("no need for a trustdb check with \"%s\" trust model\n"),
-             trust_model_string());
+    log_info (_("no need for a trustdb check with '%s' trust model\n"),
+             trust_model_string(opt.trust_model));
 }
 
 
 /*
- * Recreate the WoT. 
+ * Recreate the WoT.
  */
 void
-update_trustdb()
+update_trustdb (ctrl_t ctrl)
 {
-  if(opt.trust_model==TM_OPENPGP || opt.trust_model==TM_CLASSIC)
-    {
-      init_trustdb();
-      validate_keys (1);
-    }
+  init_trustdb (ctrl, 0);
+  if (opt.trust_model == TM_PGP || opt.trust_model == TM_CLASSIC
+      || opt.trust_model == TM_TOFU_PGP || opt.trust_model == TM_TOFU)
+    validate_keys (ctrl, 1);
   else
-    log_info (_("no need for a trustdb update with \"%s\" trust model\n"),
-             trust_model_string());
+    log_info (_("no need for a trustdb update with '%s' trust model\n"),
+             trust_model_string(opt.trust_model));
 }
 
 void
-revalidation_mark (void)
+tdb_revalidation_mark (ctrl_t ctrl)
 {
-  init_trustdb();
-  /* we simply set the time for the next check to 1 (far back in 1970)
-   * so that a --update-trustdb will be scheduled */
-  if (tdbio_write_nextcheck (1))
-      do_sync ();
+  init_trustdb (ctrl, 0);
+  if (trustdb_args.no_trustdb && opt.trust_model == TM_ALWAYS)
+    return;
+
+  /* We simply set the time for the next check to 1 (far back in 1970)
+     so that a --update-trustdb will be scheduled.  */
+  if (tdbio_write_nextcheck (ctrl, 1))
+    do_sync ();
   pending_check_trustdb = 1;
 }
 
-\f
+int
+trustdb_pending_check(void)
+{
+  return pending_check_trustdb;
+}
+
+/* If the trustdb is dirty, and we're interactive, update it.
+   Otherwise, check it unless no-auto-check-trustdb is set. */
+void
+tdb_check_or_update (ctrl_t ctrl)
+{
+  if (trustdb_pending_check ())
+    {
+      if (opt.interactive)
+       update_trustdb (ctrl);
+      else if (!opt.no_auto_check_trustdb)
+       check_trustdb (ctrl);
+    }
+}
+
+void
+read_trust_options (ctrl_t ctrl,
+                    byte *trust_model, ulong *created, ulong *nextcheck,
+                   byte *marginals, byte *completes, byte *cert_depth,
+                   byte *min_cert_level)
+{
+  TRUSTREC opts;
+
+  init_trustdb (ctrl, 0);
+  if (trustdb_args.no_trustdb && opt.trust_model == TM_ALWAYS)
+    memset (&opts, 0, sizeof opts);
+  else
+    read_record (0, &opts, RECTYPE_VER);
+
+  if(trust_model)
+    *trust_model=opts.r.ver.trust_model;
+  if(created)
+    *created=opts.r.ver.created;
+  if(nextcheck)
+    *nextcheck=opts.r.ver.nextcheck;
+  if(marginals)
+    *marginals=opts.r.ver.marginals;
+  if(completes)
+    *completes=opts.r.ver.completes;
+  if(cert_depth)
+    *cert_depth=opts.r.ver.cert_depth;
+  if(min_cert_level)
+    *min_cert_level=opts.r.ver.min_cert_level;
+}
+
 /***********************************************
  ***********  Ownertrust et al. ****************
  ***********************************************/
 
-static int 
-read_trust_record (PKT_public_key *pk, TRUSTREC *rec)
+static int
+read_trust_record (ctrl_t ctrl, PKT_public_key *pk, TRUSTREC *rec)
 {
   int rc;
-  
-  init_trustdb();
+
+  init_trustdb (ctrl, 0);
   rc = tdbio_search_trust_bypk (pk, rec);
-  if (rc == -1)
-    return -1; /* no record yet */
-  if (rc) 
+  if (rc)
     {
-      log_error ("trustdb: searching trust record failed: %s\n",
-                 g10_errstr (rc));
-      return rc; 
+      if (gpg_err_code (rc) != GPG_ERR_NOT_FOUND)
+        log_error ("trustdb: searching trust record failed: %s\n",
+                   gpg_strerror (rc));
+      return rc;
     }
-      
+
   if (rec->rectype != RECTYPE_TRUST)
     {
       log_error ("trustdb: record %lu is not a trust record\n",
                  rec->recnum);
-      return G10ERR_TRUSTDB; 
-    }      
-  
+      return GPG_ERR_TRUSTDB;
+    }
+
   return 0;
 }
 
-/****************
- * Return the assigned ownertrust value for the given public key.
- * The key should be the primary key.
+
+/*
+ * Return the assigned ownertrust value for the given public key.  The
+ * key should be the primary key.  If NO_CREATE is set a missing
+ * trustdb will not be created.  This comes for example handy when we
+ * want to print status lines (DECRYPTION_KEY) which carry ownertrust
+ * values but we usually use --always-trust.
  */
-unsigned int 
-get_ownertrust ( PKT_public_key *pk)
+unsigned int
+tdb_get_ownertrust (ctrl_t ctrl, PKT_public_key *pk, int no_create)
 {
   TRUSTREC rec;
-  int rc;
-  
-  rc = read_trust_record (pk, &rec);
-  if (rc == -1)
+  gpg_error_t err;
+
+  if (trustdb_args.no_trustdb && opt.trust_model == TM_ALWAYS)
+    return TRUST_UNKNOWN;
+
+  /* If the caller asked not to create a trustdb we call init_trustdb
+   * directly and allow it to fail with an error code for a
+   * non-existing trustdb.  */
+  if (no_create && init_trustdb (ctrl, 1))
+    return TRUST_UNKNOWN;
+
+  err = read_trust_record (ctrl, pk, &rec);
+  if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
     return TRUST_UNKNOWN; /* no record yet */
-  if (rc) 
+  if (err)
     {
       tdbio_invalid ();
-      return rc; /* actually never reached */
+      return TRUST_UNKNOWN; /* actually never reached */
     }
 
   return rec.r.trust.ownertrust;
 }
 
-unsigned int 
-get_min_ownertrust (PKT_public_key *pk)
+
+unsigned int
+tdb_get_min_ownertrust (ctrl_t ctrl, PKT_public_key *pk, int no_create)
 {
   TRUSTREC rec;
-  int rc;
-  
-  rc = read_trust_record (pk, &rec);
-  if (rc == -1)
+  gpg_error_t err;
+
+  if (trustdb_args.no_trustdb && opt.trust_model == TM_ALWAYS)
+    return TRUST_UNKNOWN;
+
+  /* If the caller asked not to create a trustdb we call init_trustdb
+   * directly and allow it to fail with an error code for a
+   * non-existing trustdb.  */
+  if (no_create && init_trustdb (ctrl, 1))
+    return TRUST_UNKNOWN;
+
+  err = read_trust_record (ctrl, pk, &rec);
+  if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
     return TRUST_UNKNOWN; /* no record yet */
-  if (rc) 
+  if (err)
     {
       tdbio_invalid ();
-      return rc; /* actually never reached */
+      return TRUST_UNKNOWN; /* actually never reached */
     }
 
   return rec.r.trust.min_ownertrust;
 }
 
-/*
- * Same as get_ownertrust but return a trust letter instead of an value.
- */
-int
-get_ownertrust_info (PKT_public_key *pk)
-{
-    unsigned int otrust,otrust_min;
-    int c;
-
-    otrust = get_ownertrust (pk);
-    otrust_min = get_min_ownertrust (pk);
-    if(otrust<otrust_min)
-      {
-       /* If the trust that the user has set is less than the trust
-          that was calculated from a trust signature chain, use the
-          higher of the two.  We do this here and not in
-          get_ownertrust since the underlying ownertrust should not
-          really be set - just the appearance of the ownertrust. */
-
-       otrust=otrust_min;
-      }
-
-    c = trust_letter( (otrust & TRUST_MASK) );
-    if( !c )
-       c = '?';
-    return c;
-}
 
 /*
  * Set the trust value of the given public key to the new value.
  * The key should be a primary one.
  */
 void
-update_ownertrust (PKT_public_key *pk, unsigned int new_trust )
+tdb_update_ownertrust (ctrl_t ctrl, PKT_public_key *pk, unsigned int new_trust )
 {
   TRUSTREC rec;
-  int rc;
-  
-  rc = read_trust_record (pk, &rec);
-  if (!rc)
+  gpg_error_t err;
+
+  if (trustdb_args.no_trustdb && opt.trust_model == TM_ALWAYS)
+    return;
+
+  err = read_trust_record (ctrl, pk, &rec);
+  if (!err)
     {
       if (DBG_TRUST)
         log_debug ("update ownertrust from %u to %u\n",
@@ -666,12 +754,12 @@ update_ownertrust (PKT_public_key *pk, unsigned int new_trust )
       if (rec.r.trust.ownertrust != new_trust)
         {
           rec.r.trust.ownertrust = new_trust;
-          write_record( &rec );
-          revalidation_mark ();
+          write_record (ctrl, &rec);
+          tdb_revalidation_mark (ctrl);
           do_sync ();
         }
     }
-  else if (rc == -1)
+  else if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
     { /* no record yet - create a new one */
       size_t dummy;
 
@@ -679,53 +767,57 @@ update_ownertrust (PKT_public_key *pk, unsigned int new_trust )
         log_debug ("insert ownertrust %u\n", new_trust );
 
       memset (&rec, 0, sizeof rec);
-      rec.recnum = tdbio_new_recnum ();
+      rec.recnum = tdbio_new_recnum (ctrl);
       rec.rectype = RECTYPE_TRUST;
       fingerprint_from_pk (pk, rec.r.trust.fingerprint, &dummy);
       rec.r.trust.ownertrust = new_trust;
-      write_record (&rec);
-      revalidation_mark ();
+      write_record (ctrl, &rec);
+      tdb_revalidation_mark (ctrl);
       do_sync ();
-      rc = 0;
     }
-  else 
+  else
     {
       tdbio_invalid ();
     }
 }
 
 static void
-update_min_ownertrust (u32 *kid, unsigned int new_trust )
+update_min_ownertrust (ctrl_t ctrl, u32 *kid, unsigned int new_trust)
 {
   PKT_public_key *pk;
   TRUSTREC rec;
-  int rc;
+  gpg_error_t err;
 
-  pk = m_alloc_clear (sizeof *pk);
-  rc = get_pubkey (pk, kid);
-  if (rc)
+  if (trustdb_args.no_trustdb && opt.trust_model == TM_ALWAYS)
+    return;
+
+  pk = xmalloc_clear (sizeof *pk);
+  err = get_pubkey (ctrl, pk, kid);
+  if (err)
     {
-      log_error (_("public key %08lX not found: %s\n"),
-                 (ulong)kid[1], g10_errstr(rc) );
+      log_error (_("public key %s not found: %s\n"),
+                 keystr (kid), gpg_strerror (err));
+      xfree (pk);
       return;
     }
 
-  rc = read_trust_record (pk, &rec);
-  if (!rc)
+  err = read_trust_record (ctrl, pk, &rec);
+  if (!err)
     {
       if (DBG_TRUST)
-        log_debug ("key %08lX: update min_ownertrust from %u to %u\n",
-                   (ulong)kid[1],(unsigned int)rec.r.trust.min_ownertrust,
+        log_debug ("key %08lX%08lX: update min_ownertrust from %u to %u\n",
+                   (ulong)kid[0],(ulong)kid[1],
+                  (unsigned int)rec.r.trust.min_ownertrust,
                   new_trust );
       if (rec.r.trust.min_ownertrust != new_trust)
         {
           rec.r.trust.min_ownertrust = new_trust;
-          write_record( &rec );
-          revalidation_mark ();
+          write_record (ctrl, &rec);
+          tdb_revalidation_mark (ctrl);
           do_sync ();
         }
     }
-  else if (rc == -1)
+  else if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
     { /* no record yet - create a new one */
       size_t dummy;
 
@@ -733,31 +825,41 @@ update_min_ownertrust (u32 *kid, unsigned int new_trust )
         log_debug ("insert min_ownertrust %u\n", new_trust );
 
       memset (&rec, 0, sizeof rec);
-      rec.recnum = tdbio_new_recnum ();
+      rec.recnum = tdbio_new_recnum (ctrl);
       rec.rectype = RECTYPE_TRUST;
       fingerprint_from_pk (pk, rec.r.trust.fingerprint, &dummy);
       rec.r.trust.min_ownertrust = new_trust;
-      write_record (&rec);
-      revalidation_mark ();
+      write_record (ctrl, &rec);
+      tdb_revalidation_mark (ctrl);
       do_sync ();
-      rc = 0;
     }
-  else 
+  else
     {
       tdbio_invalid ();
     }
+
+  free_public_key (pk);
 }
 
-/* Clear the ownertrust and min_ownertrust values.  Return true if a
-   change actually happened. */
+
+/*
+ * Clear the ownertrust and min_ownertrust values.
+ *
+ * Return: True if a change actually happened.
+ */
 int
-clear_ownertrusts (PKT_public_key *pk)
+tdb_clear_ownertrusts (ctrl_t ctrl, PKT_public_key *pk)
 {
   TRUSTREC rec;
-  int rc;
-  
-  rc = read_trust_record (pk, &rec);
-  if (!rc)
+  gpg_error_t err;
+
+  init_trustdb (ctrl, 0);
+
+  if (trustdb_args.no_trustdb && opt.trust_model == TM_ALWAYS)
+    return 0;
+
+  err = read_trust_record (ctrl, pk, &rec);
+  if (!err)
     {
       if (DBG_TRUST)
        {
@@ -770,43 +872,45 @@ clear_ownertrusts (PKT_public_key *pk)
         {
           rec.r.trust.ownertrust = 0;
           rec.r.trust.min_ownertrust = 0;
-          write_record( &rec );
-          revalidation_mark ();
+          write_record (ctrl, &rec);
+          tdb_revalidation_mark (ctrl);
           do_sync ();
           return 1;
         }
     }
-  else if (rc != -1)
+  else if (gpg_err_code (err) != GPG_ERR_NOT_FOUND)
     {
       tdbio_invalid ();
     }
   return 0;
 }
 
-/* 
- * Note: Caller has to do a sync 
+/*
+ * Note: Caller has to do a sync
  */
 static void
-update_validity (PKT_public_key *pk, const byte *namehash,
+update_validity (ctrl_t ctrl, PKT_public_key *pk, PKT_user_id *uid,
                  int depth, int validity)
 {
   TRUSTREC trec, vrec;
-  int rc;
+  gpg_error_t err;
   ulong recno;
-  
-  rc = read_trust_record (pk, &trec);
-  if (rc && rc != -1)
+
+  namehash_from_uid(uid);
+
+  err = read_trust_record (ctrl, pk, &trec);
+  if (err && gpg_err_code (err) != GPG_ERR_NOT_FOUND)
     {
       tdbio_invalid ();
       return;
     }
-  if (rc == -1) /* no record yet - create a new one */
-    { 
+  if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
+    {
+      /* No record yet - create a new one. */
       size_t dummy;
 
-      rc = 0;
       memset (&trec, 0, sizeof trec);
-      trec.recnum = tdbio_new_recnum ();
+      trec.recnum = tdbio_new_recnum (ctrl);
       trec.rectype = RECTYPE_TRUST;
       fingerprint_from_pk (pk, trec.r.trust.fingerprint, &dummy);
       trec.r.trust.ownertrust = 0;
@@ -817,7 +921,7 @@ update_validity (PKT_public_key *pk, const byte *namehash,
   while (recno)
     {
       read_record (recno, &vrec, RECTYPE_VALID);
-      if ( !memcmp (vrec.r.valid.namehash, namehash, 20) )
+      if ( !memcmp (vrec.r.valid.namehash, uid->namehash, 20) )
         break;
       recno = vrec.r.valid.next;
     }
@@ -825,198 +929,399 @@ update_validity (PKT_public_key *pk, const byte *namehash,
   if (!recno) /* insert a new validity record */
     {
       memset (&vrec, 0, sizeof vrec);
-      vrec.recnum = tdbio_new_recnum ();
+      vrec.recnum = tdbio_new_recnum (ctrl);
       vrec.rectype = RECTYPE_VALID;
-      memcpy (vrec.r.valid.namehash, namehash, 20);
+      memcpy (vrec.r.valid.namehash, uid->namehash, 20);
       vrec.r.valid.next = trec.r.trust.validlist;
+      trec.r.trust.validlist = vrec.recnum;
     }
   vrec.r.valid.validity = validity;
-  write_record (&vrec);
+  vrec.r.valid.full_count = uid->help_full_count;
+  vrec.r.valid.marginal_count = uid->help_marginal_count;
+  write_record (ctrl, &vrec);
   trec.r.trust.depth = depth;
-  trec.r.trust.validlist = vrec.recnum;
-  write_record (&trec);
+  write_record (ctrl, &trec);
 }
 
 
-/* reset validity for all user IDs.  Caller must sync. */
-static int
-clear_validity (PKT_public_key *pk)
+/***********************************************
+ *********  Query trustdb values  **************
+ ***********************************************/
+
+/* Return true if key is disabled.  Note that this is usually used via
+   the pk_is_disabled macro.  */
+int
+tdb_cache_disabled_value (ctrl_t ctrl, PKT_public_key *pk)
 {
-  TRUSTREC trec, vrec;
-  int rc;
-  ulong recno;
-  int any = 0;
-  
-  rc = read_trust_record (pk, &trec);
-  if (rc && rc != -1)
+  gpg_error_t err;
+  TRUSTREC trec;
+  int disabled = 0;
+
+  if (pk->flags.disabled_valid)
+    return pk->flags.disabled;
+
+  init_trustdb (ctrl, 0);
+
+  if (trustdb_args.no_trustdb)
+    return 0;  /* No trustdb => not disabled.  */
+
+  err = read_trust_record (ctrl, pk, &trec);
+  if (err && gpg_err_code (err) != GPG_ERR_NOT_FOUND)
     {
       tdbio_invalid ();
-      return 0;
+      goto leave;
     }
-  if (rc == -1) /* no record yet - no need to clear it then ;-) */
-    return 0;
-
-  /* Clear minimum ownertrust, if any */
-  if(trec.r.trust.min_ownertrust)
+  if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
     {
-      trec.r.trust.min_ownertrust=0;
-      write_record(&trec);
+      /* No record found, so assume not disabled.  */
+      goto leave;
     }
 
-  /* reset validity for all user IDs */
-  recno = trec.r.trust.validlist;
-  while (recno)
-    {
-      read_record (recno, &vrec, RECTYPE_VALID);
-      if ((vrec.r.valid.validity & TRUST_MASK))
-        {
-          vrec.r.valid.validity &= ~TRUST_MASK;
-          write_record (&vrec);
-          any = 1;
-        }
-      recno = vrec.r.valid.next;
-    }
+  if ((trec.r.trust.ownertrust & TRUST_FLAG_DISABLED))
+    disabled = 1;
+
+  /* Cache it for later so we don't need to look at the trustdb every
+     time */
+  pk->flags.disabled = disabled;
+  pk->flags.disabled_valid = 1;
 
-  return any;
+ leave:
+  return disabled;
 }
 
-/***********************************************
- *********  Query trustdb values  **************
- ***********************************************/
 
-/*
- * Return the validity information for PK.  If the namehash is not
- * NULL, the validity of the corresponsing user ID is returned,
- * otherwise, a reasonable value for the entire key is returned. 
- */
-unsigned int
-get_validity (PKT_public_key *pk, const byte *namehash)
+void
+tdb_check_trustdb_stale (ctrl_t ctrl)
 {
-  static int did_nextcheck;
-  TRUSTREC trec, vrec;
-  int rc;
-  ulong recno;
-  unsigned int validity;
-  u32 kid[2];
-  PKT_public_key *main_pk;
+  static int did_nextcheck=0;
+
+  init_trustdb (ctrl, 0);
 
-  init_trustdb ();
-  if (!did_nextcheck)
+  if (trustdb_args.no_trustdb)
+    return;  /* No trustdb => can't be stale.  */
+
+  if (!did_nextcheck
+      && (opt.trust_model == TM_PGP || opt.trust_model == TM_CLASSIC
+          || opt.trust_model == TM_TOFU_PGP || opt.trust_model == TM_TOFU))
     {
       ulong scheduled;
 
       did_nextcheck = 1;
       scheduled = tdbio_read_nextcheck ();
-      if (scheduled && scheduled <= make_timestamp ())
+      if ((scheduled && scheduled <= make_timestamp ())
+         || pending_check_trustdb)
         {
-          if (opt.no_auto_check_trustdb) 
+          if (opt.no_auto_check_trustdb)
             {
               pending_check_trustdb = 1;
-              log_info ("please do a --check-trustdb\n");
+              if (!opt.quiet)
+                log_info (_("please do a --check-trustdb\n"));
             }
           else
             {
-              log_info (_("checking the trustdb\n"));
-              validate_keys (0);
+              if (!opt.quiet)
+                log_info (_("checking the trustdb\n"));
+              validate_keys (ctrl, 0);
             }
         }
     }
+}
 
-  keyid_from_pk (pk, kid);
-  if (pk->main_keyid[0] != kid[0] || pk->main_keyid[1] != kid[1])
-    { /* this is a subkey - get the mainkey */
-      main_pk = m_alloc_clear (sizeof *main_pk);
-      rc = get_pubkey (main_pk, pk->main_keyid);
-      if (rc)
-        {
-          log_error ("error getting main key %08lX of subkey %08lX: %s\n",
-                     (ulong)pk->main_keyid[1], (ulong)kid[1], g10_errstr(rc));
-          validity = TRUST_UNKNOWN; 
-          goto leave;
-       }
-    }
-  else
-    main_pk = pk;
+/*
+ * Return the validity information for KB/PK (at least one of them
+ * must be non-NULL).  This is the core of get_validity.  If SIG is
+ * not NULL, then the trust is being evaluated in the context of the
+ * provided signature.  This is used by the TOFU code to record
+ * statistics.
+ */
+unsigned int
+tdb_get_validity_core (ctrl_t ctrl,
+                       kbnode_t kb,
+                       PKT_public_key *pk, PKT_user_id *uid,
+                       PKT_public_key *main_pk,
+                      PKT_signature *sig,
+                      int may_ask)
+{
+  TRUSTREC trec, vrec;
+  gpg_error_t err = 0;
+  ulong recno;
+#ifdef USE_TOFU
+  unsigned int tofu_validity = TRUST_UNKNOWN;
+  int free_kb = 0;
+#endif
+  unsigned int validity = TRUST_UNKNOWN;
+
+  if (kb && pk)
+    log_assert (keyid_cmp (pk_main_keyid (pk),
+                           pk_main_keyid (kb->pkt->pkt.public_key)) == 0);
 
-  rc = read_trust_record (main_pk, &trec);
-  if (rc && rc != -1)
+  if (! pk)
     {
-      tdbio_invalid ();
-      return 0;
+      log_assert (kb);
+      pk = kb->pkt->pkt.public_key;
     }
-  if (rc == -1) /* no record found */
+
+#ifndef USE_TOFU
+  (void)sig;
+  (void)may_ask;
+#endif
+
+  init_trustdb (ctrl, 0);
+
+  /* If we have no trustdb (which also means it has not been created)
+     and the trust-model is always, we don't know the validity -
+     return immediately.  If we won't do that the tdbio code would try
+     to open the trustdb and run into a fatal error.  */
+  if (trustdb_args.no_trustdb && opt.trust_model == TM_ALWAYS)
+    return TRUST_UNKNOWN;
+
+  check_trustdb_stale (ctrl);
+
+  if(opt.trust_model==TM_DIRECT)
     {
-      validity = TRUST_UNKNOWN; 
+      /* Note that this happens BEFORE any user ID stuff is checked.
+        The direct trust model applies to keys as a whole. */
+      validity = tdb_get_ownertrust (ctrl, main_pk, 0);
       goto leave;
     }
 
-  /* loop over all user IDs */
-  recno = trec.r.trust.validlist;
-  validity = 0;
-  while (recno)
+#ifdef USE_TOFU
+  if (opt.trust_model == TM_TOFU || opt.trust_model == TM_TOFU_PGP)
     {
-      read_record (recno, &vrec, RECTYPE_VALID);
-      if ( validity < (vrec.r.valid.validity & TRUST_MASK) )
-        validity = (vrec.r.valid.validity & TRUST_MASK);
-      if ( namehash && !memcmp (vrec.r.valid.namehash, namehash, 20) )
-        break;
-      recno = vrec.r.valid.next;
+      kbnode_t n = NULL;
+      strlist_t user_id_list = NULL;
+      int done = 0;
+
+      /* If the caller didn't supply a user id then use all uids.  */
+      if (! uid)
+        {
+          if (! kb)
+            {
+              kb = get_pubkeyblock (ctrl, main_pk->keyid);
+              free_kb = 1;
+            }
+          n = kb;
+        }
+
+      if (DBG_TRUST && sig && sig->signers_uid)
+        log_debug ("TOFU: only considering user id: '%s'\n",
+                   sig->signers_uid);
+
+      while (!done && (uid || (n = find_next_kbnode (n, PKT_USER_ID))))
+       {
+         PKT_user_id *user_id;
+          int expired = 0;
+
+         if (uid)
+            {
+              user_id = uid;
+              /* If the caller specified a user id, then we only
+                 process the specified user id and are done after the
+                 first iteration.  */
+              done = 1;
+            }
+         else
+           user_id = n->pkt->pkt.user_id;
+
+          if (user_id->attrib_data)
+            /* Skip user attributes.  */
+            continue;
+
+          if (sig && sig->signers_uid)
+            /* Make sure the UID matches.  */
+            {
+              char *email = mailbox_from_userid (user_id->name);
+              if (!email || !*email || strcmp (sig->signers_uid, email) != 0)
+                {
+                  if (DBG_TRUST)
+                    log_debug ("TOFU: skipping user id '%s', which does"
+                               " not match the signer's email ('%s')\n",
+                               email, sig->signers_uid);
+                  xfree (email);
+                  continue;
+                }
+              xfree (email);
+            }
+
+          /* If the user id is revoked or expired, then skip it.  */
+          if (user_id->flags.revoked || user_id->flags.expired)
+            {
+              if (DBG_TRUST)
+                {
+                  char *s;
+                  if (user_id->flags.revoked && user_id->flags.expired)
+                    s = "revoked and expired";
+                  else if (user_id->flags.revoked)
+                    s = "revoked";
+                  else
+                    s = "expire";
+
+                  log_debug ("TOFU: Ignoring %s user id (%s)\n",
+                             s, user_id->name);
+                }
+
+              if (user_id->flags.revoked)
+                continue;
+
+              expired = 1;
+            }
+
+          add_to_strlist (&user_id_list, user_id->name);
+          user_id_list->flags = expired;
+        }
+
+      /* Process the user ids in the order they appear in the key
+         block.  */
+      strlist_rev (&user_id_list);
+
+      /* It only makes sense to observe any signature before getting
+         the validity.  This is because if the current signature
+         results in a conflict, then we damn well want to take that
+         into account.  */
+      if (sig)
+        {
+          err = tofu_register_signature (ctrl, main_pk, user_id_list,
+                                         sig->digest, sig->digest_len,
+                                         sig->timestamp, "unknown");
+          if (err)
+            {
+              log_error ("TOFU: error registering signature: %s\n",
+                         gpg_strerror (err));
+
+              tofu_validity = TRUST_UNKNOWN;
+            }
+        }
+      if (! err)
+        tofu_validity = tofu_get_validity (ctrl, main_pk, user_id_list,
+                                           may_ask);
+
+      free_strlist (user_id_list);
+      if (free_kb)
+        release_kbnode (kb);
     }
-  
-  if (recno) /* okay, use the user ID associated one */
-    validity = (vrec.r.valid.validity & TRUST_MASK);
+#endif /*USE_TOFU*/
+
+  if (opt.trust_model == TM_TOFU_PGP
+      || opt.trust_model == TM_CLASSIC
+      || opt.trust_model == TM_PGP)
+    {
+      err = read_trust_record (ctrl, main_pk, &trec);
+      if (err && gpg_err_code (err) != GPG_ERR_NOT_FOUND)
+       {
+         tdbio_invalid ();
+         return 0;
+       }
+      if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
+       {
+         /* No record found.  */
+         validity = TRUST_UNKNOWN;
+         goto leave;
+       }
 
-  if ( (trec.r.trust.ownertrust & TRUST_FLAG_DISABLED) )
-    validity |= TRUST_FLAG_DISABLED;
+      /* Loop over all user IDs */
+      recno = trec.r.trust.validlist;
+      validity = 0;
+      while (recno)
+       {
+         read_record (recno, &vrec, RECTYPE_VALID);
+
+         if(uid)
+           {
+             /* If a user ID is given we return the validity for that
+                user ID ONLY.  If the namehash is not found, then
+                there is no validity at all (i.e. the user ID wasn't
+                signed). */
+             if(memcmp(vrec.r.valid.namehash,uid->namehash,20)==0)
+               {
+                 validity=(vrec.r.valid.validity & TRUST_MASK);
+                 break;
+               }
+           }
+         else
+           {
+             /* If no user ID is given, we take the maximum validity
+                over all user IDs */
+             if (validity < (vrec.r.valid.validity & TRUST_MASK))
+               validity = (vrec.r.valid.validity & TRUST_MASK);
+           }
+
+         recno = vrec.r.valid.next;
+       }
+
+      if ((trec.r.trust.ownertrust & TRUST_FLAG_DISABLED))
+       {
+         validity |= TRUST_FLAG_DISABLED;
+         pk->flags.disabled = 1;
+       }
+      else
+       pk->flags.disabled = 0;
+      pk->flags.disabled_valid = 1;
+    }
 
  leave:
-  /* set some flags direct from the key */
-  if (main_pk->is_revoked)
-    validity |= TRUST_FLAG_REVOKED;
-  if (main_pk != pk && pk->is_revoked)
-    validity |= TRUST_FLAG_SUB_REVOKED;
-  /* Note: expiration is a trust value and not a flag - don't know why
-   * I initially designed it that way */
-  if (main_pk->has_expired || pk->has_expired)
-    validity = (validity & ~TRUST_MASK) | TRUST_EXPIRED;
-  
-  if (pending_check_trustdb)
+#ifdef USE_TOFU
+  validity = tofu_wot_trust_combine (tofu_validity, validity);
+#else /*!USE_TOFU*/
+  validity &= TRUST_MASK;
+
+  if (validity == TRUST_NEVER)
+    /* TRUST_NEVER trumps everything else.  */
+    validity |= TRUST_NEVER;
+  if (validity == TRUST_EXPIRED)
+    /* TRUST_EXPIRED trumps everything but TRUST_NEVER.  */
+    validity |= TRUST_EXPIRED;
+#endif /*!USE_TOFU*/
+
+  if (opt.trust_model != TM_TOFU
+      && pending_check_trustdb)
     validity |= TRUST_FLAG_PENDING_CHECK;
 
-  if (main_pk != pk)
-    free_public_key (main_pk);
   return validity;
 }
 
 
-int
-get_validity_info (PKT_public_key *pk, const byte *namehash)
+static void
+get_validity_counts (ctrl_t ctrl, PKT_public_key *pk, PKT_user_id *uid)
 {
-    int trustlevel;
-    int c;
-
-    trustlevel = get_validity (pk, namehash);
-    if( trustlevel & TRUST_FLAG_DISABLED )
-       return 'd';
-    if( trustlevel & TRUST_FLAG_REVOKED )
-       return 'r';
-    c = trust_letter ( (trustlevel & TRUST_MASK) );
-    if( !c )
-       c = '?';
-    return c;
-}
+  TRUSTREC trec, vrec;
+  ulong recno;
+
+  if(pk==NULL || uid==NULL)
+    BUG();
 
+  namehash_from_uid(uid);
 
+  uid->help_marginal_count=uid->help_full_count=0;
 
+  init_trustdb (ctrl, 0);
+
+  if(read_trust_record (ctrl, pk, &trec))
+    return;
+
+  /* loop over all user IDs */
+  recno = trec.r.trust.validlist;
+  while (recno)
+    {
+      read_record (recno, &vrec, RECTYPE_VALID);
+
+      if(memcmp(vrec.r.valid.namehash,uid->namehash,20)==0)
+       {
+         uid->help_marginal_count=vrec.r.valid.marginal_count;
+         uid->help_full_count=vrec.r.valid.full_count;
+         /*  es_printf("Fetched marginal %d, full %d\n",uid->help_marginal_count,uid->help_full_count); */
+         break;
+       }
+
+      recno = vrec.r.valid.next;
+    }
+}
 
 void
 list_trust_path( const char *username )
 {
+  (void)username;
 }
 
-
-
-
 /****************
  * Enumerate all keys, which are needed to build all trust paths for
  * the given key.  This function does not return the key itself or
@@ -1039,7 +1344,11 @@ int
 enum_cert_paths( void **context, ulong *lid,
                 unsigned *ownertrust, unsigned *validity )
 {
-    return -1;
+  (void)context;
+  (void)lid;
+  (void)ownertrust;
+  (void)validity;
+  return -1;
 }
 
 
@@ -1047,10 +1356,13 @@ enum_cert_paths( void **context, ulong *lid,
  * Print the current path
  */
 void
-enum_cert_paths_printvoid **context, FILE *fp,
-                                      int refresh, ulong selected_lid )
+enum_cert_paths_print (void **context, FILE *fp,
+                       int refresh, ulong selected_lid)
 {
-    return;
+  (void)context;
+  (void)fp;
+  (void)refresh;
+  (void)selected_lid;
 }
 
 
@@ -1060,33 +1372,33 @@ enum_cert_paths_print( void **context, FILE *fp,
  ****************************************/
 
 static int
-ask_ownertrust (u32 *kid,int minimum)
+ask_ownertrust (ctrl_t ctrl, u32 *kid, int minimum)
 {
   PKT_public_key *pk;
   int rc;
   int ot;
 
-  pk = m_alloc_clear (sizeof *pk);
-  rc = get_pubkey (pk, kid);
+  pk = xmalloc_clear (sizeof *pk);
+  rc = get_pubkey (ctrl, pk, kid);
   if (rc)
     {
-      log_error (_("public key %08lX not found: %s\n"),
-                 (ulong)kid[1], g10_errstr(rc) );
+      log_error (_("public key %s not found: %s\n"),
+                 keystr(kid), gpg_strerror (rc) );
       return TRUST_UNKNOWN;
     }
+
   if(opt.force_ownertrust)
     {
-      log_info("force trust for key %08lX to %s\n",(ulong)kid[1],
-              trust_string(opt.force_ownertrust));
-      update_ownertrust(pk,opt.force_ownertrust);
+      log_info("force trust for key %s to %s\n",
+              keystr(kid),trust_value_to_string(opt.force_ownertrust));
+      tdb_update_ownertrust (ctrl, pk, opt.force_ownertrust);
       ot=opt.force_ownertrust;
     }
   else
     {
-      ot=edit_ownertrust(pk,0);
+      ot=edit_ownertrust (ctrl, pk, 0);
       if(ot>0)
-       ot = get_ownertrust (pk);
+       ot = tdb_get_ownertrust (ctrl, pk, 0);
       else if(ot==0)
        ot = minimum?minimum:TRUST_UNDEFINED;
       else
@@ -1104,7 +1416,7 @@ mark_keyblock_seen (KeyHashTable tbl, KBNODE node)
 {
   for ( ;node; node = node->next )
     if (node->pkt->pkttype == PKT_PUBLIC_KEY
-        || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
+       || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
       {
         u32 aki[2];
 
@@ -1114,7 +1426,6 @@ mark_keyblock_seen (KeyHashTable tbl, KBNODE node)
 }
 
 
-
 static void
 dump_key_array (int depth, struct key_array *keys)
 {
@@ -1126,8 +1437,8 @@ dump_key_array (int depth, struct key_array *keys)
       u32 kid[2];
 
       keyid_from_pk(node->pkt->pkt.public_key, kid);
-      printf ("%d:%08lX%08lX:K::%c::::\n",
-              depth, (ulong)kid[0], (ulong)kid[1], '?');
+      es_printf ("%d:%08lX%08lX:K::%c::::\n",
+                 depth, (ulong)kid[0], (ulong)kid[1], '?');
 
       for (; node; node = node->next)
         {
@@ -1137,25 +1448,26 @@ dump_key_array (int depth, struct key_array *keys)
 
               if (len > 30)
                 len = 30;
-              printf ("%d:%08lX%08lX:U:::%c:::",
-                      depth, (ulong)kid[0], (ulong)kid[1],
-                      (node->flag & 4)? 'f':
-                      (node->flag & 2)? 'm':
-                      (node->flag & 1)? 'q':'-');
-              print_string (stdout,  node->pkt->pkt.user_id->name, len, ':');
-              putchar (':');
-              putchar ('\n');
+              es_printf ("%d:%08lX%08lX:U:::%c:::",
+                         depth, (ulong)kid[0], (ulong)kid[1],
+                         (node->flag & 4)? 'f':
+                         (node->flag & 2)? 'm':
+                         (node->flag & 1)? 'q':'-');
+              es_write_sanitized (es_stdout, node->pkt->pkt.user_id->name,
+                                  len, ":", NULL);
+              es_putc (':', es_stdout);
+              es_putc ('\n', es_stdout);
             }
         }
     }
-}  
+}
 
 
 static void
-store_validation_status (int depth, KBNODE keyblock)
+store_validation_status (ctrl_t ctrl, int depth,
+                         kbnode_t keyblock, KeyHashTable stored)
 {
   KBNODE node;
-  byte namehash[20];
   int status;
   int any = 0;
 
@@ -1164,7 +1476,6 @@ store_validation_status (int depth, KBNODE keyblock)
       if (node->pkt->pkttype == PKT_USER_ID)
         {
           PKT_user_id *uid = node->pkt->pkt.user_id;
-
           if (node->flag & 4)
             status = TRUST_FULLY;
           else if (node->flag & 2)
@@ -1173,16 +1484,14 @@ store_validation_status (int depth, KBNODE keyblock)
             status = TRUST_UNDEFINED;
           else
             status = 0;
-          
+
           if (status)
             {
-              if( uid->attrib_data )
-                rmd160_hash_buffer (namehash,uid->attrib_data,uid->attrib_len);
-              else
-                rmd160_hash_buffer (namehash, uid->name, uid->len );
-              
-              update_validity (keyblock->pkt->pkt.public_key,
-                               namehash, depth, status);
+              update_validity (ctrl, keyblock->pkt->pkt.public_key,
+                              uid, depth, status);
+
+             mark_keyblock_seen(stored,keyblock);
+
               any = 1;
             }
         }
@@ -1190,199 +1499,119 @@ store_validation_status (int depth, KBNODE keyblock)
 
   if (any)
     do_sync ();
-}  
+}
 
-/*
- * check whether the signature sig is in the klist k
- */
-static struct key_item *
-is_in_klist (struct key_item *k, PKT_signature *sig)
+
+/* Returns a sanitized copy of the regexp (which might be "", but not
+   NULL). */
+#ifndef DISABLE_REGEX
+/* Operator charactors except '.' and backslash.
+   See regex(7) on BSD.  */
+#define REGEXP_OPERATOR_CHARS "^[$()|*+?{"
+
+static char *
+sanitize_regexp(const char *old)
 {
-  for (; k; k = k->next)
+  size_t start=0,len=strlen(old),idx=0;
+  int escaped=0,standard_bracket=0;
+  char *new=xmalloc((len*2)+1); /* enough to \-escape everything if we
+                                  have to */
+
+  /* There are basically two commonly-used regexps here.  GPG and most
+     versions of PGP use "<[^>]+[@.]example\.com>$" and PGP (9)
+     command line uses "example.com" (i.e. whatever the user specifies,
+     and we can't expect users know to use "\." instead of ".").  So
+     here are the rules: we're allowed to start with "<[^>]+[@.]" and
+     end with ">$" or start and end with nothing.  In between, the
+     only legal regex character is ".", and everything else gets
+     escaped.  Part of the gotcha here is that some regex packages
+     allow more than RFC-4880 requires.  For example, 4880 has no "{}"
+     operator, but GNU regex does.  Commenting removes these operators
+     from consideration.  A possible future enhancement is to use
+     commenting to effectively back off a given regex to the Henry
+     Spencer syntax in 4880. -dshaw */
+
+  /* Are we bracketed between "<[^>]+[@.]" and ">$" ? */
+  if(len>=12 && strncmp(old,"<[^>]+[@.]",10)==0
+     && old[len-2]=='>' && old[len-1]=='$')
     {
-      if (k->kid[0] == sig->keyid[0] && k->kid[1] == sig->keyid[1])
-        return k;
+      strcpy(new,"<[^>]+[@.]");
+      idx=strlen(new);
+      standard_bracket=1;
+      start+=10;
+      len-=2;
     }
-  return NULL;
-}
 
-/*
- * Mark the signature of the given UID which are used to certify it.
- * To do this, we first revmove all signatures which are not valid and
- * from the remain ones we look for the latest one.  If this is not a
- * certification revocation signature we mark the signature by setting
- * node flag bit 8.  Note that flag bits 9 and 10 are used for internal
- * purposes.  
- */
-static void
-mark_usable_uid_certs (KBNODE keyblock, KBNODE uidnode,
-                       u32 *main_kid, struct key_item *klist,
-                       u32 curtime, u32 *next_expire)
-{
-  KBNODE node;
-  PKT_signature *sig;
-  
-  /* first check all signatures */
-  for (node=uidnode->next; node; node = node->next)
-    {
-      node->flag &= ~(1<<8 | 1<<9 | 1<<10);
-      if (node->pkt->pkttype == PKT_USER_ID
-          || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
-        break; /* ready */
-      if (node->pkt->pkttype != PKT_SIGNATURE)
-        continue;
-      
-      sig = node->pkt->pkt.signature;
-      if (sig->keyid[0] == main_kid[0] && sig->keyid[1] == main_kid[1])
-        continue; /* ignore self-signatures */
-      if (!IS_UID_SIG(sig) && !IS_UID_REV(sig))
-        continue; /* we only look at these signature classes */
-      if (!is_in_klist (klist, sig))
-        continue;  /* no need to check it then */
-      if (check_key_signature (keyblock, node, NULL))
-        continue; /* ignore invalid signatures */
-      node->flag |= 1<<9;
-    }      
-  /* reset the remaining flags */
-  for (; node; node = node->next)
-      node->flag &= ~(1<<8 | 1<<9 | 1 << 10);
-
-  /* kbnode flag usage: bit 9 is here set for signatures to consider,
-   * bit 10 will be set by the loop to keep track of keyIDs already
-   * processed, bit 8 will be set for the usable signatures */
-
-  /* for each cert figure out the latest valid one */
-  for (node=uidnode->next; node; node = node->next)
+  /* Walk the remaining characters and ensure that everything that is
+     left is not an operational regex character. */
+  for(;start<len;start++)
     {
-      KBNODE n, signode;
-      u32 kid[2];
-      u32 sigdate;
-      
-      if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
-        break;
-      if ( !(node->flag & (1<<9)) )
-        continue; /* not a node to look at */
-      if ( (node->flag & (1<<10)) )
-        continue; /* signature with a keyID already processed */
-      node->flag |= (1<<10); /* mark this node as processed */
-      sig = node->pkt->pkt.signature;
-      signode = node;
-      sigdate = sig->timestamp;
-      kid[0] = sig->keyid[0]; kid[1] = sig->keyid[1];
-      for (n=uidnode->next; n; n = n->next)
-        {
-          if (n->pkt->pkttype == PKT_PUBLIC_SUBKEY)
-            break;
-          if ( !(n->flag & (1<<9)) )
-            continue;
-          if ( (n->flag & (1<<10)) )
-            continue; /* shortcut already processed signatures */
-          sig = n->pkt->pkt.signature;
-          if (kid[0] != sig->keyid[0] || kid[1] != sig->keyid[1])
-            continue;
-          n->flag |= (1<<10); /* mark this node as processed */
-
-         /* If signode is nonrevocable and unexpired and n isn't,
-             then take signode (skip).  It doesn't matter which is
-             older: if signode was older then we don't want to take n
-             as signode is nonrevocable.  If n was older then we're
-             automatically fine. */
-         
-         if(((IS_UID_SIG(signode->pkt->pkt.signature) &&
-              !signode->pkt->pkt.signature->flags.revocable &&
-              (signode->pkt->pkt.signature->expiredate==0 ||
-               signode->pkt->pkt.signature->expiredate>curtime))) &&
-            (!(IS_UID_SIG(n->pkt->pkt.signature) &&
-               !n->pkt->pkt.signature->flags.revocable &&
-               (n->pkt->pkt.signature->expiredate==0 ||
-                n->pkt->pkt.signature->expiredate>curtime))))
-           continue;
-
-         /* If n is nonrevocable and unexpired and signode isn't,
-             then take n.  Again, it doesn't matter which is older: if
-             n was older then we don't want to take signode as n is
-             nonrevocable.  If signode was older then we're
-             automatically fine. */
-         
-         if((!(IS_UID_SIG(signode->pkt->pkt.signature) &&
-               !signode->pkt->pkt.signature->flags.revocable &&
-               (signode->pkt->pkt.signature->expiredate==0 ||
-                signode->pkt->pkt.signature->expiredate>curtime))) &&
-            ((IS_UID_SIG(n->pkt->pkt.signature) &&
-              !n->pkt->pkt.signature->flags.revocable &&
-              (n->pkt->pkt.signature->expiredate==0 ||
-               n->pkt->pkt.signature->expiredate>curtime))))
-            {
-              signode = n;
-              sigdate = sig->timestamp;
-             continue;
-            }
-
-         /* At this point, if it's newer, it goes in as the only
-             remaining possibilities are signode and n are both either
-             revocable or expired or both nonrevocable and unexpired.
-             If the timestamps are equal take the later ordered
-             packet, presuming that the key packets are hopefully in
-             their original order. */
+      if(!escaped && old[start]=='\\')
+       escaped=1;
+      else if (!escaped && strchr (REGEXP_OPERATOR_CHARS, old[start]))
+       new[idx++]='\\';
+      else
+       escaped=0;
 
-          if (sig->timestamp >= sigdate)
-            {
-              signode = n;
-              sigdate = sig->timestamp;
-            }
-        }
-      sig = signode->pkt->pkt.signature;
-      if (IS_UID_SIG (sig))
-        { /* this seems to be a usable one which is not revoked. 
-           * Just need to check whether there is an expiration time,
-           * We do the expired certification after finding a suitable
-           * certification, the assumption is that a signator does not
-           * want that after the expiration of his certificate the
-           * system falls back to an older certification which has a
-           * different expiration time */
-          const byte *p;
-          u32 expire;
-                    
-          p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_SIG_EXPIRE, NULL );
-          expire = p? sig->timestamp + buffer_to_u32(p) : 0;
-
-          if (expire==0 || expire > curtime )
-            {
-              signode->flag |= (1<<8); /* yeah, found a good cert */
-              if (expire && expire < *next_expire)
-                *next_expire = expire;
-            }
-        }
+      new[idx++]=old[start];
     }
+
+  new[idx]='\0';
+
+  /* Note that the (sub)string we look at might end with a bare "\".
+     If it does, leave it that way.  If the regexp actually ended with
+     ">$", then it was escaping the ">" and is fine.  If the regexp
+     actually ended with the bare "\", then it's an illegal regexp and
+     regcomp should kick it out. */
+
+  if(standard_bracket)
+    strcat(new,">$");
+
+  return new;
 }
+#endif /*!DISABLE_REGEX*/
 
 /* Used by validate_one_keyblock to confirm a regexp within a trust
    signature.  Returns 1 for match, and 0 for no match or regex
    error. */
 static int
-check_regexp(const char *exp,const char *string)
+check_regexp(const char *expr,const char *string)
 {
-#ifdef DISABLE_REGEXP
-  /* When DISABLE_REGEXP is defined, assume all regexps do not
+#ifdef DISABLE_REGEX
+  (void)expr;
+  (void)string;
+  /* When DISABLE_REGEX is defined, assume all regexps do not
      match. */
   return 0;
-#elif defined(__riscos__)
-  return riscos_check_regexp(exp, string, DBG_TRUST);
 #else
   int ret;
-  regex_t pat;
+  char *regexp;
 
-  if(regcomp(&pat,exp,REG_ICASE|REG_NOSUB|REG_EXTENDED)!=0)
-    return 0;
+  regexp=sanitize_regexp(expr);
 
-  ret=regexec(&pat,string,0,NULL,0);
+#ifdef __riscos__
+  ret=riscos_check_regexp(expr, string, DBG_TRUST);
+#else
+  {
+    regex_t pat;
 
-  regfree(&pat);
+    ret=regcomp(&pat,regexp,REG_ICASE|REG_NOSUB|REG_EXTENDED);
+    if(ret==0)
+      {
+       ret=regexec(&pat,string,0,NULL,0);
+       regfree(&pat);
+      }
+    ret=(ret==0);
+  }
+#endif
 
   if(DBG_TRUST)
-    log_debug("regexp \"%s\" on \"%s\": %s\n",exp,string,ret==0?"YES":"NO");
+    log_debug("regexp '%s' ('%s') on '%s': %s\n",
+             regexp,expr,string,ret?"YES":"NO");
 
-  return (ret==0);
+  xfree(regexp);
+
+  return ret;
 #endif
 }
 
@@ -1399,103 +1628,150 @@ check_regexp(const char *exp,const char *string)
  * This function assumes that all kbnode flags are cleared on entry.
  */
 static int
-validate_one_keyblock (KBNODE kb, struct key_item *klist,
+validate_one_keyblock (ctrl_t ctrl, kbnode_t kb, struct key_item *klist,
                        u32 curtime, u32 *next_expire)
 {
   struct key_item *kr;
   KBNODE node, uidnode=NULL;
+  PKT_user_id *uid=NULL;
   PKT_public_key *pk = kb->pkt->pkt.public_key;
   u32 main_kid[2];
-  int issigned=0, any_signed = 0, fully_count =0, marginal_count = 0;
+  int issigned=0, any_signed = 0;
 
   keyid_from_pk(pk, main_kid);
   for (node=kb; node; node = node->next)
     {
-      if (node->pkt->pkttype == PKT_USER_ID)
+      /* A bit of discussion here: is it better for the web of trust
+        to be built among only self-signed uids?  On the one hand, a
+        self-signed uid is a statement that the key owner definitely
+        intended that uid to be there, but on the other hand, a
+        signed (but not self-signed) uid does carry trust, of a sort,
+        even if it is a statement being made by people other than the
+        key owner "through" the uids on the key owner's key.  I'm
+        going with the latter.  However, if the user ID was
+        explicitly revoked, or passively allowed to expire, that
+        should stop validity through the user ID until it is
+        resigned.  -dshaw */
+
+      if (node->pkt->pkttype == PKT_USER_ID
+         && !node->pkt->pkt.user_id->flags.revoked
+         && !node->pkt->pkt.user_id->flags.expired)
         {
           if (uidnode && issigned)
             {
-              if (fully_count >= opt.completes_needed
-                  || marginal_count >= opt.marginals_needed )
-                uidnode->flag |= 4; 
-              else if (fully_count || marginal_count)
+              if (uid->help_full_count >= opt.completes_needed
+                  || uid->help_marginal_count >= opt.marginals_needed )
+                uidnode->flag |= 4;
+              else if (uid->help_full_count || uid->help_marginal_count)
                 uidnode->flag |= 2;
               uidnode->flag |= 1;
               any_signed = 1;
             }
           uidnode = node;
+         uid=uidnode->pkt->pkt.user_id;
+
+         /* If the selfsig is going to expire... */
+         if(uid->expiredate && uid->expiredate<*next_expire)
+           *next_expire = uid->expiredate;
+
           issigned = 0;
-          fully_count = marginal_count = 0;
-          mark_usable_uid_certs (kb, uidnode, main_kid, klist, 
+         get_validity_counts (ctrl, pk, uid);
+          mark_usable_uid_certs (ctrl, kb, uidnode, main_kid, klist,
                                  curtime, next_expire);
         }
-      else if (node->pkt->pkttype == PKT_SIGNATURE 
-               && (node->flag & (1<<8)) )
+      else if (node->pkt->pkttype == PKT_SIGNATURE
+              && (node->flag & (1<<8)) && uid)
         {
          /* Note that we are only seeing unrevoked sigs here */
           PKT_signature *sig = node->pkt->pkt.signature;
-          
+
           kr = is_in_klist (klist, sig);
          /* If the trust_regexp does not match, it's as if the sig
              did not exist.  This is safe for non-trust sigs as well
              since we don't accept a regexp on the sig unless it's a
              trust sig. */
-          if (kr && (kr->trust_regexp==NULL || opt.trust_model!=TM_OPENPGP ||
-                    (uidnode && check_regexp(kr->trust_regexp,
-                                           uidnode->pkt->pkt.user_id->name))))
+          if (kr && (!kr->trust_regexp
+                     || !(opt.trust_model == TM_PGP
+                          || opt.trust_model == TM_TOFU_PGP)
+                     || (uidnode
+                         && check_regexp(kr->trust_regexp,
+                                         uidnode->pkt->pkt.user_id->name))))
             {
-             if(DBG_TRUST && opt.trust_model==TM_OPENPGP && sig->trust_depth)
-               log_debug("trust sig on %s, sig depth is %d, kr depth is %d\n",
-                         uidnode->pkt->pkt.user_id->name,sig->trust_depth,
-                         kr->trust_depth);
-
              /* Are we part of a trust sig chain?  We always favor
                  the latest trust sig, rather than the greater or
                  lesser trust sig or value.  I could make a decent
                  argument for any of these cases, but this seems to be
                  what PGP does, and I'd like to be compatible. -dms */
-             if(opt.trust_model==TM_OPENPGP && sig->trust_depth
-                && pk->trust_timestamp<=sig->timestamp
-                && (sig->trust_depth<=kr->trust_depth
-                    || kr->ownertrust==TRUST_ULTIMATE))
+              if ((opt.trust_model == TM_PGP
+                   || opt.trust_model == TM_TOFU_PGP)
+                  && sig->trust_depth
+                  && pk->trust_timestamp <= sig->timestamp)
                {
-                 /* If we got here, we know that:
-
-                    this is a trust sig.
-
-                    it's a newer trust sig than any previous trust
-                    sig on this key (not uid).
-
-                    it is legal in that it was either generated by an
-                    ultimate key, or a key that was part of a trust
-                    chain, and the depth does not violate the
-                    original trust sig.
-
-                    if there is a regexp attached, it matched
-                    successfully.
-                 */
-
-                 if(DBG_TRUST)
-                   log_debug("replacing trust value %d with %d and "
-                             "depth %d with %d\n",
-                             pk->trust_value,sig->trust_value,
-                             pk->trust_depth,sig->trust_depth);
-
-                 pk->trust_value=sig->trust_value;
-                 pk->trust_depth=sig->trust_depth-1;
-
-                 /* If the trust sig contains a regexp, record it
-                    on the pk for the next round. */
-                 if(sig->trust_regexp)
-                   pk->trust_regexp=sig->trust_regexp;
+                 unsigned char depth;
+
+                 /* If the depth on the signature is less than the
+                    chain currently has, then use the signature depth
+                    so we don't increase the depth beyond what the
+                    signer wanted.  If the depth on the signature is
+                    more than the chain currently has, then use the
+                    chain depth so we use as much of the signature
+                    depth as the chain will permit.  An ultimately
+                    trusted signature can restart the depth to
+                    whatever level it likes. */
+
+                 if (sig->trust_depth < kr->trust_depth
+                      || kr->ownertrust == TRUST_ULTIMATE)
+                   depth = sig->trust_depth;
+                 else
+                   depth = kr->trust_depth;
+
+                 if (depth)
+                   {
+                     if(DBG_TRUST)
+                       log_debug ("trust sig on %s, sig depth is %d,"
+                                   " kr depth is %d\n",
+                                   uidnode->pkt->pkt.user_id->name,
+                                   sig->trust_depth,
+                                   kr->trust_depth);
+
+                     /* If we got here, we know that:
+
+                        this is a trust sig.
+
+                        it's a newer trust sig than any previous trust
+                        sig on this key (not uid).
+
+                        it is legal in that it was either generated by an
+                        ultimate key, or a key that was part of a trust
+                        chain, and the depth does not violate the
+                        original trust sig.
+
+                        if there is a regexp attached, it matched
+                        successfully.
+                     */
+
+                     if (DBG_TRUST)
+                       log_debug ("replacing trust value %d with %d and "
+                                   "depth %d with %d\n",
+                                   pk->trust_value,sig->trust_value,
+                                   pk->trust_depth,depth);
+
+                     pk->trust_value = sig->trust_value;
+                     pk->trust_depth = depth-1;
+
+                     /* If the trust sig contains a regexp, record it
+                        on the pk for the next round. */
+                     if (sig->trust_regexp)
+                       pk->trust_regexp = sig->trust_regexp;
+                   }
                }
 
-             if (kr->ownertrust == TRUST_ULTIMATE)
-                fully_count = opt.completes_needed;
+              if (kr->ownertrust == TRUST_ULTIMATE)
+                uid->help_full_count = opt.completes_needed;
               else if (kr->ownertrust == TRUST_FULLY)
-                fully_count++;
+                uid->help_full_count++;
               else if (kr->ownertrust == TRUST_MARGINAL)
-                marginal_count++;
+                uid->help_marginal_count++;
               issigned = 1;
            }
         }
@@ -1503,10 +1779,10 @@ validate_one_keyblock (KBNODE kb, struct key_item *klist,
 
   if (uidnode && issigned)
     {
-      if (fully_count >= opt.completes_needed
-               || marginal_count >= opt.marginals_needed )
-        uidnode->flag |= 4; 
-      else if (fully_count || marginal_count)
+      if (uid->help_full_count >= opt.completes_needed
+         || uid->help_marginal_count >= opt.marginals_needed )
+        uidnode->flag |= 4;
+      else if (uid->help_full_count || uid->help_marginal_count)
         uidnode->flag |= 2;
       uidnode->flag |= 1;
       any_signed = 1;
@@ -1517,8 +1793,9 @@ validate_one_keyblock (KBNODE kb, struct key_item *klist,
 
 
 static int
-search_skipfnc (void *opaque, u32 *kid)
+search_skipfnc (void *opaque, u32 *kid, int dummy_uid_no)
 {
+  (void)dummy_uid_no;
   return test_key_hash_table ((KeyHashTable)opaque, kid);
 }
 
@@ -1528,10 +1805,10 @@ search_skipfnc (void *opaque, u32 *kid)
  * kllist.  The caller has to pass keydb handle so that we don't use
  * to create our own.  Returns either a key_array or NULL in case of
  * an error.  No results found are indicated by an empty array.
- * Caller hast to release the returned array.  
+ * Caller hast to release the returned array.
  */
 static struct key_array *
-validate_key_list (KEYDB_HANDLE hd, KeyHashTable visited,
+validate_key_list (ctrl_t ctrl, KEYDB_HANDLE hd, KeyHashTable full_trust,
                    struct key_item *klist, u32 curtime, u32 *next_expire)
 {
   KBNODE keyblock = NULL;
@@ -1539,50 +1816,48 @@ validate_key_list (KEYDB_HANDLE hd, KeyHashTable visited,
   size_t nkeys, maxkeys;
   int rc;
   KEYDB_SEARCH_DESC desc;
-  
+
   maxkeys = 1000;
-  keys = m_alloc ((maxkeys+1) * sizeof *keys);
+  keys = xmalloc ((maxkeys+1) * sizeof *keys);
   nkeys = 0;
-  
+
   rc = keydb_search_reset (hd);
   if (rc)
     {
-      log_error ("keydb_search_reset failed: %s\n", g10_errstr(rc));
-      m_free (keys);
+      log_error ("keydb_search_reset failed: %s\n", gpg_strerror (rc));
+      xfree (keys);
       return NULL;
     }
 
   memset (&desc, 0, sizeof desc);
   desc.mode = KEYDB_SEARCH_MODE_FIRST;
   desc.skipfnc = search_skipfnc;
-  desc.skipfncvalue = visited;
-  rc = keydb_search (hd, &desc, 1);
-  if (rc == -1)
+  desc.skipfncvalue = full_trust;
+  rc = keydb_search (hd, &desc, 1, NULL);
+  if (gpg_err_code (rc) == GPG_ERR_NOT_FOUND)
     {
       keys[nkeys].keyblock = NULL;
       return keys;
     }
   if (rc)
     {
-      log_error ("keydb_search_first failed: %s\n", g10_errstr(rc));
-      m_free (keys);
-      return NULL;
+      log_error ("keydb_search(first) failed: %s\n", gpg_strerror (rc));
+      goto die;
     }
-  
+
   desc.mode = KEYDB_SEARCH_MODE_NEXT; /* change mode */
   do
     {
       PKT_public_key *pk;
-        
+
       rc = keydb_get_keyblock (hd, &keyblock);
-      if (rc) 
+      if (rc)
         {
-          log_error ("keydb_get_keyblock failed: %s\n", g10_errstr(rc));
-          m_free (keys);
-          return NULL;
+          log_error ("keydb_get_keyblock failed: %s\n", gpg_strerror (rc));
+         goto die;
         }
-      
-      if ( keyblock->pkt->pkttype != PKT_PUBLIC_KEY) 
+
+      if ( keyblock->pkt->pkttype != PKT_PUBLIC_KEY)
         {
           log_debug ("ooops: invalid pkttype %d encountered\n",
                      keyblock->pkt->pkttype);
@@ -1592,97 +1867,105 @@ validate_key_list (KEYDB_HANDLE hd, KeyHashTable visited,
         }
 
       /* prepare the keyblock for further processing */
-      merge_keys_and_selfsig (keyblock); 
+      merge_keys_and_selfsig (ctrl, keyblock);
       clear_kbnode_flags (keyblock);
       pk = keyblock->pkt->pkt.public_key;
-      if (pk->has_expired || pk->is_revoked)
+      if (pk->has_expired || pk->flags.revoked)
         {
           /* it does not make sense to look further at those keys */
-          mark_keyblock_seen (visited, keyblock);
+          mark_keyblock_seen (full_trust, keyblock);
         }
-      else if (validate_one_keyblock (keyblock, klist, curtime, next_expire))
+      else if (validate_one_keyblock (ctrl, keyblock, klist,
+                                      curtime, next_expire))
         {
+         KBNODE node;
+
           if (pk->expiredate && pk->expiredate >= curtime
               && pk->expiredate < *next_expire)
             *next_expire = pk->expiredate;
 
           if (nkeys == maxkeys) {
             maxkeys += 1000;
-            keys = m_realloc (keys, (maxkeys+1) * sizeof *keys);
+            keys = xrealloc (keys, (maxkeys+1) * sizeof *keys);
           }
           keys[nkeys++].keyblock = keyblock;
-          /* this key is signed - don't check it again */
-          mark_keyblock_seen (visited, keyblock);
+
+         /* Optimization - if all uids are fully trusted, then we
+            never need to consider this key as a candidate again. */
+
+         for (node=keyblock; node; node = node->next)
+           if (node->pkt->pkttype == PKT_USER_ID && !(node->flag & 4))
+             break;
+
+         if(node==NULL)
+           mark_keyblock_seen (full_trust, keyblock);
+
           keyblock = NULL;
         }
 
       release_kbnode (keyblock);
       keyblock = NULL;
-    } 
-  while ( !(rc = keydb_search (hd, &desc, 1)) );
-  if (rc && rc != -1) 
+    }
+  while (!(rc = keydb_search (hd, &desc, 1, NULL)));
+
+  if (rc && gpg_err_code (rc) != GPG_ERR_NOT_FOUND)
     {
-      log_error ("keydb_search_next failed: %s\n", g10_errstr(rc));
-      m_free (keys);
-      return NULL;
+      log_error ("keydb_search_next failed: %s\n", gpg_strerror (rc));
+      goto die;
     }
 
   keys[nkeys].keyblock = NULL;
   return keys;
-} 
 
+ die:
+  keys[nkeys].keyblock = NULL;
+  release_key_array (keys);
+  return NULL;
+}
 
+/* Caller must sync */
 static void
-reset_unconnected_keys (KEYDB_HANDLE hd, KeyHashTable visited)
+reset_trust_records (ctrl_t ctrl)
 {
-  int rc;
-  KBNODE keyblock = NULL;
-  KEYDB_SEARCH_DESC desc;
+  TRUSTREC rec;
+  ulong recnum;
   int count = 0, nreset = 0;
-  
-  rc = keydb_search_reset (hd);
-  if (rc)
-    {
-      log_error ("keydb_search_reset failed: %s\n", g10_errstr(rc));
-      return;
-    }
 
-  memset (&desc, 0, sizeof desc);
-  desc.mode = KEYDB_SEARCH_MODE_FIRST;
-  desc.skipfnc = search_skipfnc;
-  desc.skipfncvalue = visited;
-  rc = keydb_search (hd, &desc, 1);
-  if (rc && rc != -1 )
-    log_error ("keydb_search_first failed: %s\n", g10_errstr(rc));
-  else if (!rc)
+  for (recnum=1; !tdbio_read_record (recnum, &rec, 0); recnum++ )
     {
-      desc.mode = KEYDB_SEARCH_MODE_NEXT; /* change mode */
-      do
-        {
-          rc = keydb_get_keyblock (hd, &keyblock);
-          if (rc) 
-            {
-              log_error ("keydb_get_keyblock failed: %s\n", g10_errstr(rc));
-              break;
-            }
-          count++;
+      if(rec.rectype==RECTYPE_TRUST)
+       {
+         count++;
+         if(rec.r.trust.min_ownertrust)
+           {
+             rec.r.trust.min_ownertrust=0;
+             write_record (ctrl, &rec);
+           }
+
+       }
+      else if(rec.rectype==RECTYPE_VALID
+             && ((rec.r.valid.validity&TRUST_MASK)
+                 || rec.r.valid.marginal_count
+                 || rec.r.valid.full_count))
+       {
+         rec.r.valid.validity &= ~TRUST_MASK;
+         rec.r.valid.marginal_count=rec.r.valid.full_count=0;
+         nreset++;
+         write_record (ctrl, &rec);
+       }
 
-          if (keyblock->pkt->pkttype == PKT_PUBLIC_KEY) /* paranoid assertion*/
-            {
-              nreset += clear_validity (keyblock->pkt->pkt.public_key);
-              release_kbnode (keyblock);
-            } 
-        }
-      while ( !(rc = keydb_search (hd, &desc, 1)) );
-      if (rc && rc != -1) 
-        log_error ("keydb_search_next failed: %s\n", g10_errstr(rc));
     }
-  if (opt.verbose)
-    log_info ("%d unconnected keys (%d trust records cleared)\n",
-              count, nreset);
-  do_sync ();
-} 
 
+  if (opt.verbose)
+    {
+      log_info (ngettext("%d key processed",
+                         "%d keys processed",
+                         count), count);
+      log_printf (ngettext(" (%d validity count cleared)\n",
+                           " (%d validity counts cleared)\n",
+                           nreset), nreset);
+    }
+}
 
 /*
  * Run the key validation procedure.
@@ -1693,7 +1976,7 @@ reset_unconnected_keys (KEYDB_HANDLE hd, KeyHashTable visited)
  * Step 2: loop max_cert_times
  * Step 3:   if OWNERTRUST of any key in klist is undefined
  *             ask user to assign ownertrust
- * Step 4:   Loop over all keys in the keyDB which are not marked seen 
+ * Step 4:   Loop over all keys in the keyDB which are not marked seen
  * Step 5:     if key is revoked or expired
  *                mark key as seen
  *                continue loop at Step 4
@@ -1705,11 +1988,11 @@ reset_unconnected_keys (KEYDB_HANDLE hd, KeyHashTable visited)
  *             End Loop
  * Step 8:   Build a new klist from all fully trusted keys from step 6
  *           End Loop
- *         Ready  
+ *         Ready
  *
  */
 static int
-validate_keys (int interactive)
+validate_keys (ctrl_t ctrl, int interactive)
 {
   int rc = 0;
   int quit=0;
@@ -1720,66 +2003,87 @@ validate_keys (int interactive)
   KEYDB_HANDLE kdb = NULL;
   KBNODE node;
   int depth;
-  int key_count;
   int ot_unknown, ot_undefined, ot_never, ot_marginal, ot_full, ot_ultimate;
-  KeyHashTable visited;
+  KeyHashTable stored,used,full_trust;
   u32 start_time, next_expire;
 
+  /* Make sure we have all sigs cached.  TODO: This is going to
+     require some architectural re-thinking, as it is agonizingly slow.
+     Perhaps combine this with reset_trust_records(), or only check
+     the caches on keys that are actually involved in the web of
+     trust. */
+  keydb_rebuild_caches (ctrl, 0);
+
+  kdb = keydb_new ();
+  if (!kdb)
+    return gpg_error_from_syserror ();
+
   start_time = make_timestamp ();
   next_expire = 0xffffffff; /* set next expire to the year 2106 */
-  visited = new_key_hash_table ();
+  stored = new_key_hash_table ();
+  used = new_key_hash_table ();
+  full_trust = new_key_hash_table ();
+
+  reset_trust_records (ctrl);
+
   /* Fixme: Instead of always building a UTK list, we could just build it
    * here when needed */
   if (!utk_list)
     {
-      log_info ("no ultimately trusted keys found\n");
+      if (!opt.quiet)
+        log_info (_("no ultimately trusted keys found\n"));
       goto leave;
     }
 
-  /* mark all UTKs as visited and set validity to ultimate */
+  /* mark all UTKs as used and fully_trusted and set validity to
+     ultimate */
   for (k=utk_list; k; k = k->next)
     {
       KBNODE keyblock;
       PKT_public_key *pk;
 
-      keyblock = get_pubkeyblock (k->kid);
+      keyblock = get_pubkeyblock (ctrl, k->kid);
       if (!keyblock)
         {
           log_error (_("public key of ultimately"
-                       " trusted key %08lX not found\n"), (ulong)k->kid[1]);
+                       " trusted key %s not found\n"), keystr(k->kid));
           continue;
         }
-      mark_keyblock_seen (visited, keyblock);
+      mark_keyblock_seen (used, keyblock);
+      mark_keyblock_seen (stored, keyblock);
+      mark_keyblock_seen (full_trust, keyblock);
       pk = keyblock->pkt->pkt.public_key;
       for (node=keyblock; node; node = node->next)
         {
           if (node->pkt->pkttype == PKT_USER_ID)
-            {
-              byte namehash[20];
-              PKT_user_id *uid = node->pkt->pkt.user_id;
-              
-              if( uid->attrib_data )
-                rmd160_hash_buffer (namehash,uid->attrib_data,uid->attrib_len);
-              else
-                rmd160_hash_buffer (namehash, uid->name, uid->len );
-              update_validity (pk, namehash, 0, TRUST_ULTIMATE);
-            }
+           update_validity (ctrl, pk, node->pkt->pkt.user_id,
+                             0, TRUST_ULTIMATE);
         }
       if ( pk->expiredate && pk->expiredate >= start_time
            && pk->expiredate < next_expire)
         next_expire = pk->expiredate;
-      
+
       release_kbnode (keyblock);
       do_sync ();
     }
 
+  if (opt.trust_model == TM_TOFU)
+    /* In the TOFU trust model, we only need to save the ultimately
+       trusted keys.  */
+    goto leave;
+
   klist = utk_list;
-  kdb = keydb_new (0);
+
+  if (!opt.quiet)
+    log_info ("marginals needed: %d  completes needed: %d  trust model: %s\n",
+              opt.marginals_needed, opt.completes_needed,
+              trust_model_string (opt.trust_model));
 
   for (depth=0; depth < opt.max_cert_depth; depth++)
     {
+      int valids=0,key_count;
       /* See whether we should assign ownertrust values to the keys in
-         utk_list.  */
+         klist.  */
       ot_unknown = ot_undefined = ot_never = 0;
       ot_marginal = ot_full = ot_ultimate = 0;
       for (k=klist; k; k = k->next)
@@ -1793,13 +2097,13 @@ validate_keys (int interactive)
            min=TRUST_MARGINAL;
 
          if(min!=k->min_ownertrust)
-           update_min_ownertrust(k->kid,min);
+           update_min_ownertrust (ctrl, k->kid,min);
 
           if (interactive && k->ownertrust == TRUST_UNKNOWN)
            {
-             k->ownertrust = ask_ownertrust (k->kid,min);
+             k->ownertrust = ask_ownertrust (ctrl, k->kid,min);
 
-             if (k->ownertrust == -1)
+             if (k->ownertrust == (unsigned int)(-1))
                {
                  quit=1;
                  goto leave;
@@ -1813,10 +2117,11 @@ validate_keys (int interactive)
          if(k->ownertrust<min)
            {
              if(DBG_TRUST)
-               log_debug("key %08lX: "
-                         "overriding ownertrust \"%s\" with \"%s\"\n",
-                         (ulong)k->kid[1],
-                         trust_string(k->ownertrust),trust_string(min));
+               log_debug("key %08lX%08lX:"
+                         " overriding ownertrust '%s' with '%s'\n",
+                         (ulong)k->kid[0],(ulong)k->kid[1],
+                         trust_value_to_string(k->ownertrust),
+                         trust_value_to_string(min));
 
              k->ownertrust=min;
            }
@@ -1833,14 +2138,17 @@ validate_keys (int interactive)
             ot_full++;
           else if (k->ownertrust == TRUST_ULTIMATE)
             ot_ultimate++;
+
+         valids++;
         }
 
       /* Find all keys which are signed by a key in kdlist */
-      keys = validate_key_list (kdb, visited, klist, start_time, &next_expire);
-      if (!keys) 
+      keys = validate_key_list (ctrl, kdb, full_trust, klist,
+                               start_time, &next_expire);
+      if (!keys)
         {
           log_error ("validate_key_list failed\n");
-          rc = G10ERR_GENERAL;
+          rc = GPG_ERR_GENERAL;
           goto leave;
         }
 
@@ -1848,16 +2156,17 @@ validate_keys (int interactive)
         ;
 
       /* Store the calculated valididation status somewhere */
-      if (opt.verbose > 1)
+      if (opt.verbose > 1 && DBG_TRUST)
         dump_key_array (depth, keys);
 
-      log_info (_("checking at depth %d signed=%d"
-                  " ot(-/q/n/m/f/u)=%d/%d/%d/%d/%d/%d\n"), 
-                depth, key_count, ot_unknown, ot_undefined,
-                ot_never, ot_marginal, ot_full, ot_ultimate ); 
-
       for (kar=keys; kar->keyblock; kar++)
-          store_validation_status (depth, kar->keyblock);
+        store_validation_status (ctrl, depth, kar->keyblock, stored);
+
+      if (!opt.quiet)
+        log_info (_("depth: %d  valid: %3d  signed: %3d"
+                    "  trust: %d-, %dq, %dn, %dm, %df, %du\n"),
+                  depth, valids, key_count, ot_unknown, ot_undefined,
+                  ot_never, ot_marginal, ot_full, ot_ultimate );
 
       /* Build a new kdlist from all fully valid keys in KEYS */
       if (klist != utk_list)
@@ -1869,52 +2178,80 @@ validate_keys (int interactive)
             {
               if (node->pkt->pkttype == PKT_USER_ID && (node->flag & 4))
                 {
-                  k = new_key_item ();
-                  keyid_from_pk (kar->keyblock->pkt->pkt.public_key, k->kid);
-                  k->ownertrust = get_ownertrust (kar->keyblock
-                                                  ->pkt->pkt.public_key);
-                 k->min_ownertrust = get_min_ownertrust (kar->keyblock
-                                                       ->pkt->pkt.public_key);
-                 k->trust_depth=
-                   kar->keyblock->pkt->pkt.public_key->trust_depth;
-                 k->trust_value=
-                   kar->keyblock->pkt->pkt.public_key->trust_value;
-                 if(kar->keyblock->pkt->pkt.public_key->trust_regexp)
-                   k->trust_regexp=
-                     m_strdup(kar->keyblock->pkt->
-                              pkt.public_key->trust_regexp);
-                  k->next = klist;
-                  klist = k;
-                  break;
-                }
-            }
-        }
+                 u32 kid[2];
+
+                 /* have we used this key already? */
+                  keyid_from_pk (kar->keyblock->pkt->pkt.public_key, kid);
+                 if(test_key_hash_table(used,kid)==0)
+                   {
+                     /* Normally we add both the primary and subkey
+                        ids to the hash via mark_keyblock_seen, but
+                        since we aren't using this hash as a skipfnc,
+                        that doesn't matter here. */
+                     add_key_hash_table (used,kid);
+                     k = new_key_item ();
+                     k->kid[0]=kid[0];
+                     k->kid[1]=kid[1];
+                     k->ownertrust =
+                       (tdb_get_ownertrust
+                           (ctrl, kar->keyblock->pkt->pkt.public_key, 0)
+                         & TRUST_MASK);
+                     k->min_ownertrust = tdb_get_min_ownertrust
+                        (ctrl, kar->keyblock->pkt->pkt.public_key, 0);
+                     k->trust_depth=
+                       kar->keyblock->pkt->pkt.public_key->trust_depth;
+                     k->trust_value=
+                       kar->keyblock->pkt->pkt.public_key->trust_value;
+                     if(kar->keyblock->pkt->pkt.public_key->trust_regexp)
+                       k->trust_regexp=
+                         xstrdup(kar->keyblock->pkt->
+                                  pkt.public_key->trust_regexp);
+                     k->next = klist;
+                     klist = k;
+                     break;
+                   }
+               }
+           }
+       }
       release_key_array (keys);
       keys = NULL;
       if (!klist)
         break; /* no need to dive in deeper */
     }
 
-  reset_unconnected_keys (kdb, visited);
-
  leave:
   keydb_release (kdb);
   release_key_array (keys);
-  release_key_items (klist);
-  release_key_hash_table (visited);
+  if (klist != utk_list)
+    release_key_items (klist);
+  release_key_hash_table (full_trust);
+  release_key_hash_table (used);
+  release_key_hash_table (stored);
   if (!rc && !quit) /* mark trustDB as checked */
     {
+      int rc2;
+
       if (next_expire == 0xffffffff || next_expire < start_time )
-        tdbio_write_nextcheck (0); 
+        tdbio_write_nextcheck (ctrl, 0);
       else
         {
-          tdbio_write_nextcheck (next_expire); 
-          log_info (_("next trustdb check due at %s\n"),
-                    strtimestamp (next_expire));
+          tdbio_write_nextcheck (ctrl, next_expire);
+          if (!opt.quiet)
+            log_info (_("next trustdb check due at %s\n"),
+                      strtimestamp (next_expire));
         }
-      tdbio_update_version_record();
+
+      rc2 = tdbio_update_version_record (ctrl);
+      if (rc2)
+       {
+         log_error (_("unable to update trustdb version record: "
+                       "write failed: %s\n"), gpg_strerror (rc2));
+         tdbio_invalid ();
+       }
+
       do_sync ();
       pending_check_trustdb = 0;
     }
+
   return rc;
 }