* export.c (parse_export_options): New option sexp-format.
[gnupg.git] / g10 / trustdb.c
index fe2ad34..16bd96e 100644 (file)
@@ -1,5 +1,6 @@
 /* trustdb.c
- * Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003
+ *                                             Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
 #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 "gpg.h"
 #include "errors.h"
 #include "iobuf.h"
 #include "keydb.h"
  */
 struct key_item {
   struct key_item *next;
-  unsigned int ownertrust;
+  unsigned int ownertrust,min_ownertrust;
+  byte trust_depth;
+  byte trust_value;
+  char *trust_regexp;
   u32 kid[2];
 };
 
@@ -85,7 +99,7 @@ new_key_item (void)
 {
   struct key_item *k;
   
-  k = m_alloc_clear (sizeof *k);
+  k = xcalloc (1,sizeof *k);
   return k;
 }
 
@@ -97,7 +111,8 @@ release_key_items (struct key_item *k)
   for (; k; k = k2)
     {
       k2 = k->next;
-      m_free (k);
+      xfree (k->trust_regexp);
+      xfree (k);
     }
 }
 
@@ -114,7 +129,7 @@ new_key_hash_table (void)
 {
   struct key_item **tbl;
 
-  tbl = m_alloc_clear (1024 * sizeof *tbl);
+  tbl = xcalloc (1,1024 * sizeof *tbl);
   return tbl;
 }
 
@@ -127,7 +142,7 @@ release_key_hash_table (KeyHashTable tbl)
     return;
   for (i=0; i < 1024; i++)
     release_key_items (tbl[i]);
-  m_free (tbl);
+  xfree (tbl);
 }
 
 /* 
@@ -174,7 +189,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);
     }
 }
 
@@ -274,9 +289,8 @@ verify_own_keys(void)
                             (ulong)kid[1]);
         }
     }
-  
-  /* the --trusted-key option is again deprecated; however we automagically
-   * add those keys to the trustdb */
+
+  /* Put any --trusted-key keys into the trustdb */
   for (k = user_utk_list; k; k = k->next) 
     {
       if ( add_utk (k->kid) ) 
@@ -322,7 +336,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)
@@ -343,7 +357,7 @@ write_record (TRUSTREC *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();
     }
 }
@@ -357,11 +371,22 @@ 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);
       }
 }
 
+static const char *
+trust_model_string(void)
+{
+  switch(opt.trust_model)
+    {
+    case TM_PGP:     return "PGP";
+    case TM_CLASSIC: return "classic";
+    case TM_ALWAYS:  return "always";
+    default:         return "unknown";
+    }
+}
 
 /****************
  * Perform some checks over the trustdb
@@ -375,7 +400,7 @@ 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;
 }
 
@@ -410,7 +435,29 @@ init_trustdb()
   else
     BUG();
   if( rc )
-    log_fatal("can't init trustdb: %s\n", g10_errstr(rc) );
+    log_fatal("can't init trustdb: %s\n", gpg_strerror (rc) );
+
+  if(opt.trust_model==TM_AUTO)
+    {
+      /* Try and set the trust model off of whatever the trustdb says
+        it is. */
+      opt.trust_model=tdbio_read_model();
+
+      /* Sanity check this ;) */
+      if(opt.trust_model!=TM_PGP && opt.trust_model!=TM_CLASSIC)
+       {
+         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());
+    }
+
+  if((opt.trust_model==TM_PGP || opt.trust_model==TM_CLASSIC)
+     && !tdbio_db_matches_options())
+    pending_check_trustdb=1;
 }
 
 
@@ -424,7 +471,7 @@ init_trustdb()
  * This function returns a letter for a trustvalue  Trust flags
  * are ignore.
  */
-int
+static int
 trust_letter (unsigned int value)
 {
   switch( (value & TRUST_MASK) ) 
@@ -436,10 +483,44 @@ trust_letter (unsigned int value)
     case TRUST_MARGINAL:  return 'm';
     case TRUST_FULLY:     return 'f';
     case TRUST_ULTIMATE:  return 'u';
-    default:              return 0;
+    default:              return '?';
+    }
+}
+
+/* The strings here are similar to those in
+   pkclist.c:do_edit_ownertrust() */
+const char *
+trust_value_to_string (unsigned int value)
+{
+  switch( (value & TRUST_MASK) ) 
+    {
+    case TRUST_UNKNOWN:   return _("unknown");
+    case TRUST_EXPIRED:   return _("expired");
+    case TRUST_UNDEFINED: return _("undefined");
+    case TRUST_NEVER:     return _("never");
+    case TRUST_MARGINAL:  return _("marginal");
+    case TRUST_FULLY:     return _("full");
+    case TRUST_ULTIMATE:  return _("ultimate");
+    default:              return "err";
     }
 }
 
+int
+string_to_trust_value (const char *str)
+{
+  if(ascii_strcasecmp(str,"undefined")==0)
+    return TRUST_UNDEFINED;
+  else if(ascii_strcasecmp(str,"never")==0)
+    return TRUST_NEVER;
+  else if(ascii_strcasecmp(str,"marginal")==0)
+    return TRUST_MARGINAL;
+  else if(ascii_strcasecmp(str,"full")==0)
+    return TRUST_FULLY;
+  else if(ascii_strcasecmp(str,"ultimate")==0)
+    return TRUST_ULTIMATE;
+  else
+    return -1;
+}
 
 /****************
  * Recreate the WoT but do not ask for new ownertrusts.  Special
@@ -450,26 +531,32 @@ void
 check_trustdb ()
 {
   init_trustdb();
-  if (opt.batch && !opt.answer_yes)
+  if(opt.trust_model==TM_PGP || opt.trust_model==TM_CLASSIC)
     {
-      ulong scheduled;
+      if (opt.batch && !opt.answer_yes)
+       {
+         ulong scheduled;
 
-      scheduled = tdbio_read_nextcheck ();
-      if (!scheduled)
-        {
-          log_info (_("no need for a trustdb check\n"));
-          return;
-        }
+         scheduled = tdbio_read_nextcheck ();
+         if (!scheduled)
+           {
+             log_info (_("no need for a trustdb check\n"));
+             return;
+           }
 
-      if (scheduled > make_timestamp ())
-        {
-          log_info (_("next trustdb check due at %s\n"),
-                    strtimestamp (scheduled));
-          return;
-        }
-    }
+         if (scheduled > make_timestamp ())
+           {
+             log_info (_("next trustdb check due at %s\n"),
+                       strtimestamp (scheduled));
+             return;
+           }
+       }
 
-  validate_keys (0);
+      validate_keys (0);
+    }
+  else
+    log_info (_("no need for a trustdb check with \"%s\" trust model\n"),
+             trust_model_string());
 }
 
 
@@ -480,7 +567,11 @@ void
 update_trustdb()
 {
   init_trustdb();
-  validate_keys (1);
+  if(opt.trust_model==TM_PGP || opt.trust_model==TM_CLASSIC)
+    validate_keys (1);
+  else
+    log_info (_("no need for a trustdb update with \"%s\" trust model\n"),
+             trust_model_string());
 }
 
 void
@@ -494,6 +585,12 @@ revalidation_mark (void)
   pending_check_trustdb = 1;
 }
 
+int
+trustdb_pending_check(void)
+{
+  return pending_check_trustdb;
+}
+
 \f
 /***********************************************
  ***********  Ownertrust et al. ****************
@@ -511,7 +608,7 @@ read_trust_record (PKT_public_key *pk, TRUSTREC *rec)
   if (rc) 
     {
       log_error ("trustdb: searching trust record failed: %s\n",
-                 g10_errstr (rc));
+                 gpg_strerror (rc));
       return rc; 
     }
       
@@ -519,13 +616,12 @@ read_trust_record (PKT_public_key *pk, TRUSTREC *rec)
     {
       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.
@@ -544,24 +640,71 @@ get_ownertrust ( PKT_public_key *pk)
       tdbio_invalid ();
       return rc; /* actually never reached */
     }
-  
+
   return rec.r.trust.ownertrust;
 }
 
+unsigned int 
+get_min_ownertrust (PKT_public_key *pk)
+{
+  TRUSTREC rec;
+  int rc;
+  
+  rc = read_trust_record (pk, &rec);
+  if (rc == -1)
+    return TRUST_UNKNOWN; /* no record yet */
+  if (rc) 
+    {
+      tdbio_invalid ();
+      return rc; /* actually never reached */
+    }
+
+  return rec.r.trust.min_ownertrust;
+}
+
 /*
- * Same as get_ownertrust but return a trust letter instead of an value.
+ * Same as get_ownertrust but this takes the minimum ownertrust value
+ * into into account, and will bump up the value as needed.
+ */
+static int
+get_ownertrust_with_min (PKT_public_key *pk)
+{
+  unsigned int otrust,otrust_min;
+
+  otrust = (get_ownertrust (pk) & TRUST_MASK);
+  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;
+    }
+
+  return otrust;
+}
+
+/*
+ * Same as get_ownertrust but return a trust letter instead of an
+ * value.  This takes the minimum ownertrust value into account.
  */
 int
 get_ownertrust_info (PKT_public_key *pk)
 {
-    unsigned int otrust;
-    int c;
-
-    otrust = get_ownertrust (pk);
-    c = trust_letter( (otrust & TRUST_MASK) );
-    if( !c )
-       c = '?';
-    return c;
+  return trust_letter(get_ownertrust_with_min(pk));
+}
+
+/*
+ * Same as get_ownertrust but return a trust string instead of an
+ * value.  This takes the minimum ownertrust value into account.
+ */
+const char *
+get_ownertrust_string (PKT_public_key *pk)
+{
+  return trust_value_to_string(get_ownertrust_with_min(pk));
 }
 
 /*
@@ -611,9 +754,64 @@ update_ownertrust (PKT_public_key *pk, unsigned int new_trust )
     }
 }
 
-/* Clear the ownertrust value.  Return true if a changed actually happend. */
+static void
+update_min_ownertrust (u32 *kid, unsigned int new_trust )
+{
+  PKT_public_key *pk;
+  TRUSTREC rec;
+  int rc;
+
+  pk = xcalloc (1,sizeof *pk);
+  rc = get_pubkey (pk, kid);
+  if (rc)
+    {
+      log_error (_("public key %08lX not found: %s\n"),
+                 (ulong)kid[1], gpg_strerror (rc) );
+      return;
+    }
+
+  rc = read_trust_record (pk, &rec);
+  if (!rc)
+    {
+      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,
+                  new_trust );
+      if (rec.r.trust.min_ownertrust != new_trust)
+        {
+          rec.r.trust.min_ownertrust = new_trust;
+          write_record( &rec );
+          revalidation_mark ();
+          do_sync ();
+        }
+    }
+  else if (rc == -1)
+    { /* no record yet - create a new one */
+      size_t dummy;
+
+      if (DBG_TRUST)
+        log_debug ("insert min_ownertrust %u\n", new_trust );
+
+      memset (&rec, 0, sizeof rec);
+      rec.recnum = tdbio_new_recnum ();
+      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 ();
+      do_sync ();
+      rc = 0;
+    }
+  else 
+    {
+      tdbio_invalid ();
+    }
+}
+
+/* Clear the ownertrust and min_ownertrust values.  Return true if a
+   change actually happened. */
 int
-clear_ownertrust (PKT_public_key *pk)
+clear_ownertrusts (PKT_public_key *pk)
 {
   TRUSTREC rec;
   int rc;
@@ -622,11 +820,16 @@ clear_ownertrust (PKT_public_key *pk)
   if (!rc)
     {
       if (DBG_TRUST)
-        log_debug ("clearing ownertrust (old value %u)\n",
-                   (unsigned int)rec.r.trust.ownertrust);
-      if (rec.r.trust.ownertrust)
+       {
+         log_debug ("clearing ownertrust (old value %u)\n",
+                    (unsigned int)rec.r.trust.ownertrust);
+         log_debug ("clearing min_ownertrust (old value %u)\n",
+                    (unsigned int)rec.r.trust.min_ownertrust);
+       }
+      if (rec.r.trust.ownertrust || rec.r.trust.min_ownertrust)
         {
           rec.r.trust.ownertrust = 0;
+          rec.r.trust.min_ownertrust = 0;
           write_record( &rec );
           revalidation_mark ();
           do_sync ();
@@ -644,13 +847,15 @@ clear_ownertrust (PKT_public_key *pk)
  * Note: Caller has to do a sync 
  */
 static void
-update_validity (PKT_public_key *pk, const byte *namehash,
+update_validity (PKT_public_key *pk, PKT_user_id *uid,
                  int depth, int validity)
 {
   TRUSTREC trec, vrec;
   int rc;
   ulong recno;
-  
+
+  namehash_from_uid(uid);
+
   rc = read_trust_record (pk, &trec);
   if (rc && rc != -1)
     {
@@ -674,7 +879,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;
     }
@@ -684,13 +889,15 @@ update_validity (PKT_public_key *pk, const byte *namehash,
       memset (&vrec, 0, sizeof vrec);
       vrec.recnum = tdbio_new_recnum ();
       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;
+  vrec.r.valid.full_count = uid->help_full_count;
+  vrec.r.valid.marginal_count = uid->help_marginal_count;
   write_record (&vrec);
   trec.r.trust.depth = depth;
-  trec.r.trust.validlist = vrec.recnum;
   write_record (&trec);
 }
 
@@ -710,17 +917,25 @@ clear_validity (PKT_public_key *pk)
       tdbio_invalid ();
       return 0;
     }
-  if (rc == -1) /* no record yet - no need to clerar it then ;-) */
+  if (rc == -1) /* no record yet - no need to clear it then ;-) */
     return 0;
 
-  /* reset validity for all user IDs */
+  /* Clear minimum ownertrust, if any */
+  if(trec.r.trust.min_ownertrust)
+    {
+      trec.r.trust.min_ownertrust=0;
+      write_record(&trec);
+    }
+
   recno = trec.r.trust.validlist;
   while (recno)
     {
       read_record (recno, &vrec, RECTYPE_VALID);
-      if ((vrec.r.valid.validity & TRUST_MASK))
+      if ((vrec.r.valid.validity & TRUST_MASK)
+         || vrec.r.valid.marginal_count || vrec.r.valid.full_count)
         {
           vrec.r.valid.validity &= ~TRUST_MASK;
+         vrec.r.valid.marginal_count = vrec.r.valid.full_count = 0;
           write_record (&vrec);
           any = 1;
         }
@@ -730,19 +945,53 @@ clear_validity (PKT_public_key *pk)
   return any;
 }
 
-
-\f
 /***********************************************
  *********  Query trustdb values  **************
  ***********************************************/
 
+/* Return true if key is disabled */
+int
+cache_disabled_value(PKT_public_key *pk)
+{
+  int rc;
+  TRUSTREC trec;
+  int disabled=0;
+
+  if(pk->is_disabled)
+    return (pk->is_disabled==2);
+
+  init_trustdb();
+
+  rc = read_trust_record (pk, &trec);
+  if (rc && rc != -1)
+    {
+      tdbio_invalid ();
+      goto leave;
+    }
+  if (rc == -1) /* no record found, so assume not disabled */
+    goto leave;
+  if(trec.r.trust.ownertrust & TRUST_FLAG_DISABLED)
+    disabled=1;
+  /* Cache it for later so we don't need to look at the trustdb every
+     time */
+  if(disabled)
+    pk->is_disabled=2;
+  else
+    pk->is_disabled=1;
+
+ leave:
+   return disabled;
+}
+
 /*
  * 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)
+get_validity (PKT_public_key *pk, PKT_user_id *uid)
 {
   static int did_nextcheck;
   TRUSTREC trec, vrec;
@@ -751,9 +1000,13 @@ get_validity (PKT_public_key *pk, const byte *namehash)
   unsigned int validity;
   u32 kid[2];
   PKT_public_key *main_pk;
-  
+
+  if(uid)
+    namehash_from_uid(uid);
+
   init_trustdb ();
-  if (!did_nextcheck)
+  if (!did_nextcheck
+      && (opt.trust_model==TM_PGP || opt.trust_model==TM_CLASSIC))
     {
       ulong scheduled;
 
@@ -764,7 +1017,7 @@ get_validity (PKT_public_key *pk, const byte *namehash)
           if (opt.no_auto_check_trustdb) 
             {
               pending_check_trustdb = 1;
-              log_info ("please do a --check-trustdb\n");
+              log_info (_("please do a --check-trustdb\n"));
             }
           else
             {
@@ -777,12 +1030,12 @@ get_validity (PKT_public_key *pk, const byte *namehash)
   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);
+      main_pk = xcalloc (1,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));
+                     (ulong)pk->main_keyid[1], (ulong)kid[1], gpg_strerror (rc));
           validity = TRUST_UNKNOWN; 
           goto leave;
        }
@@ -808,18 +1061,37 @@ get_validity (PKT_public_key *pk, const byte *namehash)
   while (recno)
     {
       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;
+
+      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 namehash 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 (recno) /* okay, use the user ID associated one */
-    validity = (vrec.r.valid.validity & TRUST_MASK);
-
   if ( (trec.r.trust.ownertrust & TRUST_FLAG_DISABLED) )
-    validity |= TRUST_FLAG_DISABLED;
+    {
+      validity |= TRUST_FLAG_DISABLED;
+      pk->is_disabled=2;
+    }
+  else
+    pk->is_disabled=1;
 
  leave:
   /* set some flags direct from the key */
@@ -840,35 +1112,69 @@ get_validity (PKT_public_key *pk, const byte *namehash)
   return validity;
 }
 
-
 int
-get_validity_info (PKT_public_key *pk, const byte *namehash)
+get_validity_info (PKT_public_key *pk, PKT_user_id *uid)
 {
     int trustlevel;
-    int c;
 
-    trustlevel = get_validity (pk, namehash);
-    if( trustlevel & TRUST_FLAG_DISABLED )
-       return 'd';
+    trustlevel = get_validity (pk, uid);
     if( trustlevel & TRUST_FLAG_REVOKED )
        return 'r';
-    c = trust_letter ( (trustlevel & TRUST_MASK) );
-    if( !c )
-       c = '?';
-    return c;
+    return trust_letter ( trustlevel );
 }
 
+const char *
+get_validity_string (PKT_public_key *pk, PKT_user_id *uid)
+{
+  int trustlevel;
 
+  trustlevel = get_validity (pk, uid);
+  if( trustlevel & TRUST_FLAG_REVOKED )
+    return _("revoked");
+  return trust_value_to_string(trustlevel);
+}
 
+static void
+get_validity_counts (PKT_public_key *pk, PKT_user_id *uid)
+{
+  TRUSTREC trec, vrec;
+  ulong recno;
+
+  if(pk==NULL || uid==NULL)
+    BUG();
+
+  namehash_from_uid(uid);
+
+  uid->help_marginal_count=uid->help_full_count=0;
+
+  init_trustdb ();
+
+  if(read_trust_record (pk, &trec)!=0)
+    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;
+         /*  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 )
 {
 }
 
-
-
-
 /****************
  * Enumerate all keys, which are needed to build all trust paths for
  * the given key.  This function does not return the key itself or
@@ -912,29 +1218,42 @@ enum_cert_paths_print( void **context, FILE *fp,
  ****************************************/
 
 static int
-ask_ownertrust (u32 *kid)
+ask_ownertrust (u32 *kid,int minimum)
 {
   PKT_public_key *pk;
   int rc;
   int ot;
 
-  pk = m_alloc_clear (sizeof *pk);
+  pk = xcalloc (1,sizeof *pk);
   rc = get_pubkey (pk, kid);
   if (rc)
     {
       log_error (_("public key %08lX not found: %s\n"),
-                 (ulong)kid[1], g10_errstr(rc) );
+                 (ulong)kid[1], gpg_strerror (rc) );
       return TRUST_UNKNOWN;
     }
  
-  ot=edit_ownertrust(pk,0);
-  if(ot>0)
-    ot = get_ownertrust (pk);
-  else if(ot==0)
-    ot = TRUST_UNDEFINED;
+  if(opt.force_ownertrust)
+    {
+      log_info("force trust for key %08lX%08lX to %s\n",
+              (ulong)kid[0],(ulong)kid[1],
+              trust_value_to_string(opt.force_ownertrust));
+      update_ownertrust(pk,opt.force_ownertrust);
+      ot=opt.force_ownertrust;
+    }
   else
-    ot = -1; /* quit */
+    {
+      ot=edit_ownertrust(pk,0);
+      if(ot>0)
+       ot = get_ownertrust (pk);
+      else if(ot==0)
+       ot = minimum?minimum:TRUST_UNDEFINED;
+      else
+       ot = -1; /* quit */
+    }
+
   free_public_key( pk );
+
   return ot;
 }
 
@@ -944,7 +1263,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];
 
@@ -954,7 +1273,6 @@ mark_keyblock_seen (KeyHashTable tbl, KBNODE node)
 }
 
 
-
 static void
 dump_key_array (int depth, struct key_array *keys)
 {
@@ -992,10 +1310,9 @@ dump_key_array (int depth, struct key_array *keys)
 
 
 static void
-store_validation_status (int depth, KBNODE keyblock)
+store_validation_status (int depth, KBNODE keyblock, KeyHashTable stored)
 {
   KBNODE node;
-  byte namehash[20];
   int status;
   int any = 0;
 
@@ -1004,7 +1321,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)
@@ -1016,13 +1332,11 @@ store_validation_status (int depth, KBNODE keyblock)
           
           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);
+                              uid, depth, status);
+
+             mark_keyblock_seen(stored,keyblock);
+
               any = 1;
             }
         }
@@ -1196,6 +1510,35 @@ mark_usable_uid_certs (KBNODE keyblock, KBNODE uidnode,
     }
 }
 
+/* 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)
+{
+#ifdef DISABLE_REGEX
+  /* 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;
+
+  if(regcomp(&pat,exp,REG_ICASE|REG_NOSUB|REG_EXTENDED)!=0)
+    return 0;
+
+  ret=regexec(&pat,string,0,NULL,0);
+
+  regfree(&pat);
+
+  if(DBG_TRUST)
+    log_debug("regexp \"%s\" on \"%s\": %s\n",exp,string,ret==0?"YES":"NO");
+
+  return (ret==0);
+#endif
+}
 
 /*
  * Return true if the key is signed by one of the keys in the given
@@ -1215,56 +1558,127 @@ validate_one_keyblock (KBNODE kb, struct key_item *klist,
 {
   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)
     {
+      /* 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. -dshaw */
+
+      /* && node->pkt->pkt.user_id->created) */
       if (node->pkt->pkttype == PKT_USER_ID)
         {
           if (uidnode && issigned)
             {
-              if (fully_count >= opt.completes_needed
-                  || marginal_count >= opt.marginals_needed )
+              if (uid->help_full_count >= opt.completes_needed
+                  || uid->help_marginal_count >= opt.marginals_needed )
                 uidnode->flag |= 4; 
-              else if (fully_count || marginal_count)
+              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 0
+         /* If the selfsig is going to expire...  This is disabled as
+            we do count un-self-signed uids in the web of trust. */
+         if(uid->expiredate && uid->expiredate<*next_expire)
+           *next_expire = uid->expiredate;
+#endif
           issigned = 0;
-          fully_count = marginal_count = 0;
+         get_validity_counts(pk,uid);
           mark_usable_uid_certs (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 (kr)
+         /* 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_PGP ||
+                    (uidnode && check_regexp(kr->trust_regexp,
+                                           uidnode->pkt->pkt.user_id->name))))
             {
+             if(DBG_TRUST && opt.trust_model==TM_PGP && 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_PGP && sig->trust_depth
+                && pk->trust_timestamp<=sig->timestamp
+                && (sig->trust_depth<=kr->trust_depth
+                    || kr->ownertrust==TRUST_ULTIMATE))
+               {
+                 /* 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;
+               }
+
               if (kr->ownertrust == TRUST_ULTIMATE)
-                fully_count = opt.completes_needed;
+                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;
-            }
+           }
         }
     }
 
   if (uidnode && issigned)
     {
-      if (fully_count >= opt.completes_needed
-               || marginal_count >= opt.marginals_needed )
+      if (uid->help_full_count >= opt.completes_needed
+         || uid->help_marginal_count >= opt.marginals_needed )
         uidnode->flag |= 4; 
-      else if (fully_count || marginal_count)
+      else if (uid->help_full_count || uid->help_marginal_count)
         uidnode->flag |= 2;
       uidnode->flag |= 1;
       any_signed = 1;
@@ -1289,7 +1703,7 @@ search_skipfnc (void *opaque, u32 *kid)
  * Caller hast to release the returned array.  
  */
 static struct key_array *
-validate_key_list (KEYDB_HANDLE hd, KeyHashTable visited,
+validate_key_list (KEYDB_HANDLE hd, KeyHashTable full_trust,
                    struct key_item *klist, u32 curtime, u32 *next_expire)
 {
   KBNODE keyblock = NULL;
@@ -1299,21 +1713,21 @@ validate_key_list (KEYDB_HANDLE hd, KeyHashTable visited,
   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;
+  desc.skipfncvalue = full_trust;
   rc = keydb_search (hd, &desc, 1);
   if (rc == -1)
     {
@@ -1322,8 +1736,8 @@ validate_key_list (KEYDB_HANDLE hd, KeyHashTable visited,
     }
   if (rc)
     {
-      log_error ("keydb_search_first failed: %s\n", g10_errstr(rc));
-      m_free (keys);
+      log_error ("keydb_search_first failed: %s\n", gpg_strerror (rc));
+      xfree (keys);
       return NULL;
     }
   
@@ -1335,8 +1749,8 @@ validate_key_list (KEYDB_HANDLE hd, KeyHashTable visited,
       rc = keydb_get_keyblock (hd, &keyblock);
       if (rc) 
         {
-          log_error ("keydb_get_keyblock failed: %s\n", g10_errstr(rc));
-          m_free (keys);
+          log_error ("keydb_get_keyblock failed: %s\n", gpg_strerror (rc));
+          xfree (keys);
           return NULL;
         }
       
@@ -1356,21 +1770,32 @@ validate_key_list (KEYDB_HANDLE hd, KeyHashTable visited,
       if (pk->has_expired || pk->is_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))
         {
+         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;
         }
 
@@ -1380,8 +1805,8 @@ validate_key_list (KEYDB_HANDLE hd, KeyHashTable visited,
   while ( !(rc = keydb_search (hd, &desc, 1)) );
   if (rc && rc != -1) 
     {
-      log_error ("keydb_search_next failed: %s\n", g10_errstr(rc));
-      m_free (keys);
+      log_error ("keydb_search_next failed: %s\n", gpg_strerror (rc));
+      xfree (keys);
       return NULL;
     }
 
@@ -1389,9 +1814,9 @@ validate_key_list (KEYDB_HANDLE hd, KeyHashTable visited,
   return keys;
 } 
 
-
+/* Caller must sync */
 static void
-reset_unconnected_keys (KEYDB_HANDLE hd, KeyHashTable visited)
+reset_trust_records (KEYDB_HANDLE hd, KeyHashTable exclude)
 {
   int rc;
   KBNODE keyblock = NULL;
@@ -1401,17 +1826,20 @@ reset_unconnected_keys (KEYDB_HANDLE hd, KeyHashTable visited)
   rc = keydb_search_reset (hd);
   if (rc)
     {
-      log_error ("keydb_search_reset failed: %s\n", g10_errstr(rc));
+      log_error ("keydb_search_reset failed: %s\n", gpg_strerror (rc));
       return;
     }
 
   memset (&desc, 0, sizeof desc);
   desc.mode = KEYDB_SEARCH_MODE_FIRST;
-  desc.skipfnc = search_skipfnc;
-  desc.skipfncvalue = visited;
+  if(exclude)
+    {
+      desc.skipfnc = search_skipfnc;
+      desc.skipfncvalue = exclude;
+    }
   rc = keydb_search (hd, &desc, 1);
   if (rc && rc != -1 )
-    log_error ("keydb_search_first failed: %s\n", g10_errstr(rc));
+    log_error ("keydb_search_first failed: %s\n", gpg_strerror (rc));
   else if (!rc)
     {
       desc.mode = KEYDB_SEARCH_MODE_NEXT; /* change mode */
@@ -1420,7 +1848,7 @@ reset_unconnected_keys (KEYDB_HANDLE hd, KeyHashTable visited)
           rc = keydb_get_keyblock (hd, &keyblock);
           if (rc) 
             {
-              log_error ("keydb_get_keyblock failed: %s\n", g10_errstr(rc));
+              log_error ("keydb_get_keyblock failed: %s\n", gpg_strerror (rc));
               break;
             }
           count++;
@@ -1433,14 +1861,12 @@ reset_unconnected_keys (KEYDB_HANDLE hd, KeyHashTable visited)
         }
       while ( !(rc = keydb_search (hd, &desc, 1)) );
       if (rc && rc != -1) 
-        log_error ("keydb_search_next failed: %s\n", g10_errstr(rc));
+        log_error ("keydb_search_next failed: %s\n", gpg_strerror (rc));
     }
   if (opt.verbose)
-    log_info ("%d unconnected keys (%d trust records cleared)\n",
+    log_info (_("%d keys processed (%d validity counts cleared)\n"),
               count, nreset);
-  do_sync ();
-} 
-
+}
 
 /*
  * Run the key validation procedure.
@@ -1480,22 +1906,28 @@ validate_keys (int interactive)
   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;
 
   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 ();
   /* 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");
+      log_info (_("no ultimately trusted keys found\n"));
       goto leave;
     }
 
+  kdb = keydb_new (0);
 
-  /* mark all UTKs as visited and set validity to ultimate */
+  reset_trust_records (kdb,NULL);
+
+  /* mark all UTKs as used and fully_trusted and set validity to
+     ultimate */
   for (k=utk_list; k; k = k->next)
     {
       KBNODE keyblock;
@@ -1508,21 +1940,14 @@ validate_keys (int interactive)
                        " trusted key %08lX not found\n"), (ulong)k->kid[1]);
           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 (pk, node->pkt->pkt.user_id, 0, TRUST_ULTIMATE);
         }
       if ( pk->expiredate && pk->expiredate >= start_time
            && pk->expiredate < next_expire)
@@ -1532,9 +1957,10 @@ validate_keys (int interactive)
       do_sync ();
     }
 
-
   klist = utk_list;
-  kdb = keydb_new (0);
+
+  log_info(_("%d marginal(s) needed, %d complete(s) needed, %s trust model\n"),
+          opt.marginals_needed,opt.completes_needed,trust_model_string());
 
   for (depth=0; depth < opt.max_cert_depth; depth++)
     {
@@ -1544,14 +1970,45 @@ validate_keys (int interactive)
       ot_marginal = ot_full = ot_ultimate = 0;
       for (k=klist; k; k = k->next)
         {
+         int min=0;
+
+         /* 120 and 60 are as per RFC2440 */
+         if(k->trust_value>=120)
+           min=TRUST_FULLY;
+         else if(k->trust_value>=60)
+           min=TRUST_MARGINAL;
+
+         if(min!=k->min_ownertrust)
+           update_min_ownertrust(k->kid,min);
+
           if (interactive && k->ownertrust == TRUST_UNKNOWN)
-              k->ownertrust = ask_ownertrust (k->kid);
-         if (k->ownertrust == -1)
            {
-             quit=1;
-             goto leave;
+             k->ownertrust = ask_ownertrust (k->kid,min);
+
+             if (k->ownertrust == -1)
+               {
+                 quit=1;
+                 goto leave;
+               }
+           }
+
+         /* This can happen during transition from an old trustdb
+            before trust sigs.  It can also happen if a user uses two
+            different versions of GnuPG or changes the --trust-model
+            setting. */
+         if(k->ownertrust<min)
+           {
+             if(DBG_TRUST)
+               log_debug("key %08lX: "
+                         "overriding ownertrust \"%s\" with \"%s\"\n",
+                         (ulong)k->kid[1],
+                         trust_value_to_string(k->ownertrust),
+                         trust_value_to_string(min));
+
+             k->ownertrust=min;
            }
-         else if (k->ownertrust == TRUST_UNKNOWN)
+
+         if (k->ownertrust == TRUST_UNKNOWN)
             ot_unknown++;
           else if (k->ownertrust == TRUST_UNDEFINED)
             ot_undefined++;
@@ -1566,15 +2023,15 @@ validate_keys (int interactive)
         }
 
       /* Find all keys which are signed by a key in kdlist */
-      keys = validate_key_list (kdb, visited, klist, start_time, &next_expire);
+      keys = validate_key_list (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;
         }
 
-
       for (key_count=0, kar=keys; kar->keyblock; kar++, key_count++)
         ;
 
@@ -1582,14 +2039,14 @@ validate_keys (int interactive)
       if (opt.verbose > 1)
         dump_key_array (depth, keys);
 
-      log_info (_("checking at depth %d signed=%d"
+      for (kar=keys; kar->keyblock; kar++)
+          store_validation_status (depth, kar->keyblock, stored);
+
+      log_info (_("checking at depth %d valid=%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);
-
       /* Build a new kdlist from all fully valid keys in KEYS */
       if (klist != utk_list)
         release_key_items (klist);
@@ -1600,29 +2057,53 @@ 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->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 =
+                       (get_ownertrust (kar->keyblock->pkt->pkt.public_key)
+                        & TRUST_MASK);
+                     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=
+                         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);
+  release_key_hash_table (full_trust);
+  release_key_hash_table (used);
+  release_key_hash_table (stored);
   if (!rc && !quit) /* mark trustDB as checked */
     {
       if (next_expire == 0xffffffff || next_expire < start_time )
@@ -1633,10 +2114,17 @@ validate_keys (int interactive)
           log_info (_("next trustdb check due at %s\n"),
                     strtimestamp (next_expire));
         }
+
+      if(tdbio_update_version_record()!=0)
+       {
+         log_error(_("unable to update trustdb version record: "
+                     "write failed: %s\n"), gpg_strerror (rc));
+         tdbio_invalid();
+       }
+
       do_sync ();
       pending_check_trustdb = 0;
     }
+
   return rc;
 }
-
-