gpg: Remove unused arg from a function.
[gnupg.git] / g10 / trustdb.c
1 /* trustdb.c
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
3  *               2008, 2012 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <https://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25
26 #ifndef DISABLE_REGEX
27 #include <sys/types.h>
28 #include <regex.h>
29 #endif /* !DISABLE_REGEX */
30
31 #include "gpg.h"
32 #include "../common/status.h"
33 #include "../common/iobuf.h"
34 #include "keydb.h"
35 #include "../common/util.h"
36 #include "options.h"
37 #include "packet.h"
38 #include "main.h"
39 #include "../common/mbox-util.h"
40 #include "../common/i18n.h"
41 #include "tdbio.h"
42 #include "trustdb.h"
43 #include "tofu.h"
44 #include "key-clean.h"
45
46
47 typedef struct key_item **KeyHashTable; /* see new_key_hash_table() */
48
49 /*
50  * Structure to keep track of keys, this is used as an array wherre
51  * the item right after the last one has a keyblock set to NULL.
52  * Maybe we can drop this thing and replace it by key_item
53  */
54 struct key_array
55 {
56   KBNODE keyblock;
57 };
58
59
60 /* Control information for the trust DB.  */
61 static struct
62 {
63   int init;
64   int level;
65   char *dbname;
66   int no_trustdb;
67 } trustdb_args;
68
69 /* Some globals.  */
70 static struct key_item *user_utk_list; /* temp. used to store --trusted-keys */
71 static struct key_item *utk_list;      /* all ultimately trusted keys */
72
73 static int pending_check_trustdb;
74
75 static int validate_keys (ctrl_t ctrl, int interactive);
76
77 \f
78 /**********************************************
79  ************* some helpers *******************
80  **********************************************/
81
82 static struct key_item *
83 new_key_item (void)
84 {
85   struct key_item *k;
86
87   k = xmalloc_clear (sizeof *k);
88   return k;
89 }
90
91 static void
92 release_key_items (struct key_item *k)
93 {
94   struct key_item *k2;
95
96   for (; k; k = k2)
97     {
98       k2 = k->next;
99       xfree (k->trust_regexp);
100       xfree (k);
101     }
102 }
103
104 #define KEY_HASH_TABLE_SIZE 1024
105
106 /*
107  * For fast keylook up we need a hash table.  Each byte of a KeyID
108  * should be distributed equally over the 256 possible values (except
109  * for v3 keyIDs but we consider them as not important here). So we
110  * can just use 10 bits to index a table of KEY_HASH_TABLE_SIZE key items.
111  * Possible optimization: Do not use key_items but other hash_table when the
112  * duplicates lists get too large.
113  */
114 static KeyHashTable
115 new_key_hash_table (void)
116 {
117   struct key_item **tbl;
118
119   tbl = xmalloc_clear (KEY_HASH_TABLE_SIZE * sizeof *tbl);
120   return tbl;
121 }
122
123 static void
124 release_key_hash_table (KeyHashTable tbl)
125 {
126   int i;
127
128   if (!tbl)
129     return;
130   for (i=0; i < KEY_HASH_TABLE_SIZE; i++)
131     release_key_items (tbl[i]);
132   xfree (tbl);
133 }
134
135 /*
136  * Returns: True if the keyID is in the given hash table
137  */
138 static int
139 test_key_hash_table (KeyHashTable tbl, u32 *kid)
140 {
141   struct key_item *k;
142
143   for (k = tbl[(kid[1] % KEY_HASH_TABLE_SIZE)]; k; k = k->next)
144     if (k->kid[0] == kid[0] && k->kid[1] == kid[1])
145       return 1;
146   return 0;
147 }
148
149 /*
150  * Add a new key to the hash table.  The key is identified by its key ID.
151  */
152 static void
153 add_key_hash_table (KeyHashTable tbl, u32 *kid)
154 {
155   int i = kid[1] % KEY_HASH_TABLE_SIZE;
156   struct key_item *k, *kk;
157
158   for (k = tbl[i]; k; k = k->next)
159     if (k->kid[0] == kid[0] && k->kid[1] == kid[1])
160       return; /* already in table */
161
162   kk = new_key_item ();
163   kk->kid[0] = kid[0];
164   kk->kid[1] = kid[1];
165   kk->next = tbl[i];
166   tbl[i] = kk;
167 }
168
169 /*
170  * Release a key_array
171  */
172 static void
173 release_key_array ( struct key_array *keys )
174 {
175     struct key_array *k;
176
177     if (keys) {
178         for (k=keys; k->keyblock; k++)
179             release_kbnode (k->keyblock);
180         xfree (keys);
181     }
182 }
183
184 \f
185 /*********************************************
186  **********  Initialization  *****************
187  *********************************************/
188
189
190
191 /*
192  * Used to register extra ultimately trusted keys - this has to be done
193  * before initializing the validation module.
194  * FIXME: Should be replaced by a function to add those keys to the trustdb.
195  */
196 void
197 tdb_register_trusted_keyid (u32 *keyid)
198 {
199   struct key_item *k;
200
201   k = new_key_item ();
202   k->kid[0] = keyid[0];
203   k->kid[1] = keyid[1];
204   k->next = user_utk_list;
205   user_utk_list = k;
206 }
207
208 void
209 tdb_register_trusted_key( const char *string )
210 {
211   gpg_error_t err;
212   KEYDB_SEARCH_DESC desc;
213
214   err = classify_user_id (string, &desc, 1);
215   if (err || desc.mode != KEYDB_SEARCH_MODE_LONG_KID )
216     {
217       log_error(_("'%s' is not a valid long keyID\n"), string );
218       return;
219     }
220
221   register_trusted_keyid(desc.u.kid);
222 }
223
224 /*
225  * Helper to add a key to the global list of ultimately trusted keys.
226  * Returns: true = inserted, false = already in list.
227  */
228 static int
229 add_utk (u32 *kid)
230 {
231   struct key_item *k;
232
233   if (tdb_keyid_is_utk (kid))
234     return 0;
235
236   k = new_key_item ();
237   k->kid[0] = kid[0];
238   k->kid[1] = kid[1];
239   k->ownertrust = TRUST_ULTIMATE;
240   k->next = utk_list;
241   utk_list = k;
242   if( opt.verbose > 1 )
243     log_info(_("key %s: accepted as trusted key\n"), keystr(kid));
244   return 1;
245 }
246
247
248 /****************
249  * Verify that all our secret keys are usable and put them into the utk_list.
250  */
251 static void
252 verify_own_keys (ctrl_t ctrl)
253 {
254   TRUSTREC rec;
255   ulong recnum;
256   int rc;
257   struct key_item *k;
258
259   if (utk_list)
260     return;
261
262   /* scan the trustdb to find all ultimately trusted keys */
263   for (recnum=1; !tdbio_read_record (recnum, &rec, 0); recnum++ )
264     {
265       if ( rec.rectype == RECTYPE_TRUST
266            && (rec.r.trust.ownertrust & TRUST_MASK) == TRUST_ULTIMATE)
267         {
268             byte *fpr = rec.r.trust.fingerprint;
269             int fprlen;
270             u32 kid[2];
271
272             /* Problem: We do only use fingerprints in the trustdb but
273              * we need the keyID here to indetify the key; we can only
274              * use that ugly hack to distinguish between 16 and 20
275              * butes fpr - it does not work always so we better change
276              * the whole validation code to only work with
277              * fingerprints */
278             fprlen = (!fpr[16] && !fpr[17] && !fpr[18] && !fpr[19])? 16:20;
279             keyid_from_fingerprint (ctrl, fpr, fprlen, kid);
280             if (!add_utk (kid))
281               log_info(_("key %s occurs more than once in the trustdb\n"),
282                        keystr(kid));
283         }
284     }
285
286   /* Put any --trusted-key keys into the trustdb */
287   for (k = user_utk_list; k; k = k->next)
288     {
289       if ( add_utk (k->kid) )
290         { /* not yet in trustDB as ultimately trusted */
291           PKT_public_key pk;
292
293           memset (&pk, 0, sizeof pk);
294           rc = get_pubkey (ctrl, &pk, k->kid);
295           if (rc)
296             log_info(_("key %s: no public key for trusted key - skipped\n"),
297                      keystr(k->kid));
298           else
299             {
300               tdb_update_ownertrust
301                 (ctrl, &pk, ((tdb_get_ownertrust (ctrl, &pk, 0) & ~TRUST_MASK)
302                              | TRUST_ULTIMATE ));
303               release_public_key_parts (&pk);
304             }
305
306           log_info (_("key %s marked as ultimately trusted\n"),keystr(k->kid));
307         }
308     }
309
310   /* release the helper table table */
311   release_key_items (user_utk_list);
312   user_utk_list = NULL;
313   return;
314 }
315
316 /* Returns whether KID is on the list of ultimately trusted keys.  */
317 int
318 tdb_keyid_is_utk (u32 *kid)
319 {
320   struct key_item *k;
321
322   for (k = utk_list; k; k = k->next)
323     if (k->kid[0] == kid[0] && k->kid[1] == kid[1])
324       return 1;
325
326   return 0;
327 }
328
329 /* Return the list of ultimately trusted keys.  */
330 struct key_item *
331 tdb_utks (void)
332 {
333   return utk_list;
334 }
335 \f
336 /*********************************************
337  *********** TrustDB stuff *******************
338  *********************************************/
339
340 /*
341  * Read a record but die if it does not exist
342  */
343 static void
344 read_record (ulong recno, TRUSTREC *rec, int rectype )
345 {
346   int rc = tdbio_read_record (recno, rec, rectype);
347   if (rc)
348     {
349       log_error(_("trust record %lu, req type %d: read failed: %s\n"),
350                 recno, rec->rectype, gpg_strerror (rc) );
351       tdbio_invalid();
352     }
353   if (rectype != rec->rectype)
354     {
355       log_error(_("trust record %lu is not of requested type %d\n"),
356                 rec->recnum, rectype);
357       tdbio_invalid();
358     }
359 }
360
361 /*
362  * Write a record and die on error
363  */
364 static void
365 write_record (ctrl_t ctrl, TRUSTREC *rec)
366 {
367   int rc = tdbio_write_record (ctrl, rec);
368   if (rc)
369     {
370       log_error(_("trust record %lu, type %d: write failed: %s\n"),
371                             rec->recnum, rec->rectype, gpg_strerror (rc) );
372       tdbio_invalid();
373     }
374 }
375
376 /*
377  * sync the TrustDb and die on error
378  */
379 static void
380 do_sync(void)
381 {
382     int rc = tdbio_sync ();
383     if(rc)
384       {
385         log_error (_("trustdb: sync failed: %s\n"), gpg_strerror (rc) );
386         g10_exit(2);
387       }
388 }
389
390 const char *
391 trust_model_string (int model)
392 {
393   switch (model)
394     {
395     case TM_CLASSIC:  return "classic";
396     case TM_PGP:      return "pgp";
397     case TM_EXTERNAL: return "external";
398     case TM_TOFU:     return "tofu";
399     case TM_TOFU_PGP: return "tofu+pgp";
400     case TM_ALWAYS:   return "always";
401     case TM_DIRECT:   return "direct";
402     default:          return "unknown";
403     }
404 }
405
406 /****************
407  * Perform some checks over the trustdb
408  *  level 0: only open the db
409  *        1: used for initial program startup
410  */
411 int
412 setup_trustdb( int level, const char *dbname )
413 {
414     /* just store the args */
415     if( trustdb_args.init )
416         return 0;
417     trustdb_args.level = level;
418     trustdb_args.dbname = dbname? xstrdup(dbname): NULL;
419     return 0;
420 }
421
422 void
423 how_to_fix_the_trustdb ()
424 {
425   const char *name = trustdb_args.dbname;
426
427   if (!name)
428     name = "trustdb.gpg";
429
430   log_info (_("You may try to re-create the trustdb using the commands:\n"));
431   log_info ("  cd %s\n", default_homedir ());
432   log_info ("  %s --export-ownertrust > otrust.tmp\n", GPG_NAME);
433 #ifdef HAVE_W32_SYSTEM
434   log_info ("  del %s\n", name);
435 #else
436   log_info ("  rm %s\n", name);
437 #endif
438   log_info ("  %s --import-ownertrust < otrust.tmp\n", GPG_NAME);
439   log_info (_("If that does not work, please consult the manual\n"));
440 }
441
442
443 /* Initialize the trustdb.  With NO_CREATE set a missing trustdb is
444  * not an error and the function won't terminate the process on error;
445  * in that case 0 is returned if there is a trustdb or an error code
446  * if no trustdb is available.  */
447 gpg_error_t
448 init_trustdb (ctrl_t ctrl, int no_create)
449 {
450   int level = trustdb_args.level;
451   const char* dbname = trustdb_args.dbname;
452
453   if( trustdb_args.init )
454     return 0;
455
456   trustdb_args.init = 1;
457
458   if(level==0 || level==1)
459     {
460       int rc = tdbio_set_dbname (ctrl, dbname, (!no_create && level),
461                                  &trustdb_args.no_trustdb);
462       if (no_create && trustdb_args.no_trustdb)
463         {
464           /* No trustdb found and the caller asked us not to create
465            * it.  Return an error and set the initialization state
466            * back so that we always test for an existing trustdb.  */
467           trustdb_args.init = 0;
468           return gpg_error (GPG_ERR_ENOENT);
469         }
470       if (rc)
471         log_fatal("can't init trustdb: %s\n", gpg_strerror (rc) );
472     }
473   else
474     BUG();
475
476   if(opt.trust_model==TM_AUTO)
477     {
478       /* Try and set the trust model off of whatever the trustdb says
479          it is. */
480       opt.trust_model=tdbio_read_model();
481
482       /* Sanity check this ;) */
483       if(opt.trust_model != TM_CLASSIC
484          && opt.trust_model != TM_PGP
485          && opt.trust_model != TM_TOFU_PGP
486          && opt.trust_model != TM_TOFU
487          && opt.trust_model != TM_EXTERNAL)
488         {
489           log_info(_("unable to use unknown trust model (%d) - "
490                      "assuming %s trust model\n"),opt.trust_model,"pgp");
491           opt.trust_model = TM_PGP;
492         }
493
494       if(opt.verbose)
495         log_info(_("using %s trust model\n"),
496                  trust_model_string (opt.trust_model));
497     }
498
499   if (opt.trust_model==TM_PGP || opt.trust_model==TM_CLASSIC
500       || opt.trust_model == TM_TOFU || opt.trust_model == TM_TOFU_PGP)
501     {
502       /* Verify the list of ultimately trusted keys and move the
503          --trusted-keys list there as well. */
504       if(level==1)
505         verify_own_keys (ctrl);
506
507       if(!tdbio_db_matches_options())
508         pending_check_trustdb=1;
509     }
510
511   return 0;
512 }
513
514
515 /* Check whether we have a trust database, initializing it if
516    necessary if the trust model is not 'always trust'.  Returns true
517    if we do have a usable trust database.  */
518 int
519 have_trustdb (ctrl_t ctrl)
520 {
521   return !init_trustdb (ctrl, opt.trust_model == TM_ALWAYS);
522 }
523
524
525 /****************
526  * Recreate the WoT but do not ask for new ownertrusts.  Special
527  * feature: In batch mode and without a forced yes, this is only done
528  * when a check is due.  This can be used to run the check from a crontab
529  */
530 void
531 check_trustdb (ctrl_t ctrl)
532 {
533   init_trustdb (ctrl, 0);
534   if (opt.trust_model == TM_PGP || opt.trust_model == TM_CLASSIC
535       || opt.trust_model == TM_TOFU_PGP || opt.trust_model == TM_TOFU)
536     {
537       if (opt.batch && !opt.answer_yes)
538         {
539           ulong scheduled;
540
541           scheduled = tdbio_read_nextcheck ();
542           if (!scheduled)
543             {
544               log_info (_("no need for a trustdb check\n"));
545               return;
546             }
547
548           if (scheduled > make_timestamp ())
549             {
550               log_info (_("next trustdb check due at %s\n"),
551                         strtimestamp (scheduled));
552               return;
553             }
554         }
555
556       validate_keys (ctrl, 0);
557     }
558   else
559     log_info (_("no need for a trustdb check with '%s' trust model\n"),
560               trust_model_string(opt.trust_model));
561 }
562
563
564 /*
565  * Recreate the WoT.
566  */
567 void
568 update_trustdb (ctrl_t ctrl)
569 {
570   init_trustdb (ctrl, 0);
571   if (opt.trust_model == TM_PGP || opt.trust_model == TM_CLASSIC
572       || opt.trust_model == TM_TOFU_PGP || opt.trust_model == TM_TOFU)
573     validate_keys (ctrl, 1);
574   else
575     log_info (_("no need for a trustdb update with '%s' trust model\n"),
576               trust_model_string(opt.trust_model));
577 }
578
579 void
580 tdb_revalidation_mark (ctrl_t ctrl)
581 {
582   init_trustdb (ctrl, 0);
583   if (trustdb_args.no_trustdb && opt.trust_model == TM_ALWAYS)
584     return;
585
586   /* We simply set the time for the next check to 1 (far back in 1970)
587      so that a --update-trustdb will be scheduled.  */
588   if (tdbio_write_nextcheck (ctrl, 1))
589     do_sync ();
590   pending_check_trustdb = 1;
591 }
592
593 int
594 trustdb_pending_check(void)
595 {
596   return pending_check_trustdb;
597 }
598
599 /* If the trustdb is dirty, and we're interactive, update it.
600    Otherwise, check it unless no-auto-check-trustdb is set. */
601 void
602 tdb_check_or_update (ctrl_t ctrl)
603 {
604   if (trustdb_pending_check ())
605     {
606       if (opt.interactive)
607         update_trustdb (ctrl);
608       else if (!opt.no_auto_check_trustdb)
609         check_trustdb (ctrl);
610     }
611 }
612
613 void
614 read_trust_options (ctrl_t ctrl,
615                     byte *trust_model, ulong *created, ulong *nextcheck,
616                     byte *marginals, byte *completes, byte *cert_depth,
617                     byte *min_cert_level)
618 {
619   TRUSTREC opts;
620
621   init_trustdb (ctrl, 0);
622   if (trustdb_args.no_trustdb && opt.trust_model == TM_ALWAYS)
623     memset (&opts, 0, sizeof opts);
624   else
625     read_record (0, &opts, RECTYPE_VER);
626
627   if(trust_model)
628     *trust_model=opts.r.ver.trust_model;
629   if(created)
630     *created=opts.r.ver.created;
631   if(nextcheck)
632     *nextcheck=opts.r.ver.nextcheck;
633   if(marginals)
634     *marginals=opts.r.ver.marginals;
635   if(completes)
636     *completes=opts.r.ver.completes;
637   if(cert_depth)
638     *cert_depth=opts.r.ver.cert_depth;
639   if(min_cert_level)
640     *min_cert_level=opts.r.ver.min_cert_level;
641 }
642
643 /***********************************************
644  ***********  Ownertrust et al. ****************
645  ***********************************************/
646
647 static int
648 read_trust_record (ctrl_t ctrl, PKT_public_key *pk, TRUSTREC *rec)
649 {
650   int rc;
651
652   init_trustdb (ctrl, 0);
653   rc = tdbio_search_trust_bypk (ctrl, pk, rec);
654   if (rc)
655     {
656       if (gpg_err_code (rc) != GPG_ERR_NOT_FOUND)
657         log_error ("trustdb: searching trust record failed: %s\n",
658                    gpg_strerror (rc));
659       return rc;
660     }
661
662   if (rec->rectype != RECTYPE_TRUST)
663     {
664       log_error ("trustdb: record %lu is not a trust record\n",
665                  rec->recnum);
666       return GPG_ERR_TRUSTDB;
667     }
668
669   return 0;
670 }
671
672
673 /*
674  * Return the assigned ownertrust value for the given public key.  The
675  * key should be the primary key.  If NO_CREATE is set a missing
676  * trustdb will not be created.  This comes for example handy when we
677  * want to print status lines (DECRYPTION_KEY) which carry ownertrust
678  * values but we usually use --always-trust.
679  */
680 unsigned int
681 tdb_get_ownertrust (ctrl_t ctrl, PKT_public_key *pk, int no_create)
682 {
683   TRUSTREC rec;
684   gpg_error_t err;
685
686   if (trustdb_args.no_trustdb && opt.trust_model == TM_ALWAYS)
687     return TRUST_UNKNOWN;
688
689   /* If the caller asked not to create a trustdb we call init_trustdb
690    * directly and allow it to fail with an error code for a
691    * non-existing trustdb.  */
692   if (no_create && init_trustdb (ctrl, 1))
693     return TRUST_UNKNOWN;
694
695   err = read_trust_record (ctrl, pk, &rec);
696   if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
697     return TRUST_UNKNOWN; /* no record yet */
698   if (err)
699     {
700       tdbio_invalid ();
701       return TRUST_UNKNOWN; /* actually never reached */
702     }
703
704   return rec.r.trust.ownertrust;
705 }
706
707
708 unsigned int
709 tdb_get_min_ownertrust (ctrl_t ctrl, PKT_public_key *pk, int no_create)
710 {
711   TRUSTREC rec;
712   gpg_error_t err;
713
714   if (trustdb_args.no_trustdb && opt.trust_model == TM_ALWAYS)
715     return TRUST_UNKNOWN;
716
717   /* If the caller asked not to create a trustdb we call init_trustdb
718    * directly and allow it to fail with an error code for a
719    * non-existing trustdb.  */
720   if (no_create && init_trustdb (ctrl, 1))
721     return TRUST_UNKNOWN;
722
723   err = read_trust_record (ctrl, pk, &rec);
724   if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
725     return TRUST_UNKNOWN; /* no record yet */
726   if (err)
727     {
728       tdbio_invalid ();
729       return TRUST_UNKNOWN; /* actually never reached */
730     }
731
732   return rec.r.trust.min_ownertrust;
733 }
734
735
736 /*
737  * Set the trust value of the given public key to the new value.
738  * The key should be a primary one.
739  */
740 void
741 tdb_update_ownertrust (ctrl_t ctrl, PKT_public_key *pk, unsigned int new_trust )
742 {
743   TRUSTREC rec;
744   gpg_error_t err;
745
746   if (trustdb_args.no_trustdb && opt.trust_model == TM_ALWAYS)
747     return;
748
749   err = read_trust_record (ctrl, pk, &rec);
750   if (!err)
751     {
752       if (DBG_TRUST)
753         log_debug ("update ownertrust from %u to %u\n",
754                    (unsigned int)rec.r.trust.ownertrust, new_trust );
755       if (rec.r.trust.ownertrust != new_trust)
756         {
757           rec.r.trust.ownertrust = new_trust;
758           write_record (ctrl, &rec);
759           tdb_revalidation_mark (ctrl);
760           do_sync ();
761         }
762     }
763   else if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
764     { /* no record yet - create a new one */
765       size_t dummy;
766
767       if (DBG_TRUST)
768         log_debug ("insert ownertrust %u\n", new_trust );
769
770       memset (&rec, 0, sizeof rec);
771       rec.recnum = tdbio_new_recnum (ctrl);
772       rec.rectype = RECTYPE_TRUST;
773       fingerprint_from_pk (pk, rec.r.trust.fingerprint, &dummy);
774       rec.r.trust.ownertrust = new_trust;
775       write_record (ctrl, &rec);
776       tdb_revalidation_mark (ctrl);
777       do_sync ();
778     }
779   else
780     {
781       tdbio_invalid ();
782     }
783 }
784
785 static void
786 update_min_ownertrust (ctrl_t ctrl, u32 *kid, unsigned int new_trust)
787 {
788   PKT_public_key *pk;
789   TRUSTREC rec;
790   gpg_error_t err;
791
792   if (trustdb_args.no_trustdb && opt.trust_model == TM_ALWAYS)
793     return;
794
795   pk = xmalloc_clear (sizeof *pk);
796   err = get_pubkey (ctrl, pk, kid);
797   if (err)
798     {
799       log_error (_("public key %s not found: %s\n"),
800                  keystr (kid), gpg_strerror (err));
801       xfree (pk);
802       return;
803     }
804
805   err = read_trust_record (ctrl, pk, &rec);
806   if (!err)
807     {
808       if (DBG_TRUST)
809         log_debug ("key %08lX%08lX: update min_ownertrust from %u to %u\n",
810                    (ulong)kid[0],(ulong)kid[1],
811                    (unsigned int)rec.r.trust.min_ownertrust,
812                    new_trust );
813       if (rec.r.trust.min_ownertrust != new_trust)
814         {
815           rec.r.trust.min_ownertrust = new_trust;
816           write_record (ctrl, &rec);
817           tdb_revalidation_mark (ctrl);
818           do_sync ();
819         }
820     }
821   else if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
822     { /* no record yet - create a new one */
823       size_t dummy;
824
825       if (DBG_TRUST)
826         log_debug ("insert min_ownertrust %u\n", new_trust );
827
828       memset (&rec, 0, sizeof rec);
829       rec.recnum = tdbio_new_recnum (ctrl);
830       rec.rectype = RECTYPE_TRUST;
831       fingerprint_from_pk (pk, rec.r.trust.fingerprint, &dummy);
832       rec.r.trust.min_ownertrust = new_trust;
833       write_record (ctrl, &rec);
834       tdb_revalidation_mark (ctrl);
835       do_sync ();
836     }
837   else
838     {
839       tdbio_invalid ();
840     }
841
842   free_public_key (pk);
843 }
844
845
846 /*
847  * Clear the ownertrust and min_ownertrust values.
848  *
849  * Return: True if a change actually happened.
850  */
851 int
852 tdb_clear_ownertrusts (ctrl_t ctrl, PKT_public_key *pk)
853 {
854   TRUSTREC rec;
855   gpg_error_t err;
856
857   init_trustdb (ctrl, 0);
858
859   if (trustdb_args.no_trustdb && opt.trust_model == TM_ALWAYS)
860     return 0;
861
862   err = read_trust_record (ctrl, pk, &rec);
863   if (!err)
864     {
865       if (DBG_TRUST)
866         {
867           log_debug ("clearing ownertrust (old value %u)\n",
868                      (unsigned int)rec.r.trust.ownertrust);
869           log_debug ("clearing min_ownertrust (old value %u)\n",
870                      (unsigned int)rec.r.trust.min_ownertrust);
871         }
872       if (rec.r.trust.ownertrust || rec.r.trust.min_ownertrust)
873         {
874           rec.r.trust.ownertrust = 0;
875           rec.r.trust.min_ownertrust = 0;
876           write_record (ctrl, &rec);
877           tdb_revalidation_mark (ctrl);
878           do_sync ();
879           return 1;
880         }
881     }
882   else if (gpg_err_code (err) != GPG_ERR_NOT_FOUND)
883     {
884       tdbio_invalid ();
885     }
886   return 0;
887 }
888
889 /*
890  * Note: Caller has to do a sync
891  */
892 static void
893 update_validity (ctrl_t ctrl, PKT_public_key *pk, PKT_user_id *uid,
894                  int depth, int validity)
895 {
896   TRUSTREC trec, vrec;
897   gpg_error_t err;
898   ulong recno;
899
900   namehash_from_uid(uid);
901
902   err = read_trust_record (ctrl, pk, &trec);
903   if (err && gpg_err_code (err) != GPG_ERR_NOT_FOUND)
904     {
905       tdbio_invalid ();
906       return;
907     }
908   if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
909     {
910       /* No record yet - create a new one. */
911       size_t dummy;
912
913       memset (&trec, 0, sizeof trec);
914       trec.recnum = tdbio_new_recnum (ctrl);
915       trec.rectype = RECTYPE_TRUST;
916       fingerprint_from_pk (pk, trec.r.trust.fingerprint, &dummy);
917       trec.r.trust.ownertrust = 0;
918       }
919
920   /* locate an existing one */
921   recno = trec.r.trust.validlist;
922   while (recno)
923     {
924       read_record (recno, &vrec, RECTYPE_VALID);
925       if ( !memcmp (vrec.r.valid.namehash, uid->namehash, 20) )
926         break;
927       recno = vrec.r.valid.next;
928     }
929
930   if (!recno) /* insert a new validity record */
931     {
932       memset (&vrec, 0, sizeof vrec);
933       vrec.recnum = tdbio_new_recnum (ctrl);
934       vrec.rectype = RECTYPE_VALID;
935       memcpy (vrec.r.valid.namehash, uid->namehash, 20);
936       vrec.r.valid.next = trec.r.trust.validlist;
937       trec.r.trust.validlist = vrec.recnum;
938     }
939   vrec.r.valid.validity = validity;
940   vrec.r.valid.full_count = uid->help_full_count;
941   vrec.r.valid.marginal_count = uid->help_marginal_count;
942   write_record (ctrl, &vrec);
943   trec.r.trust.depth = depth;
944   write_record (ctrl, &trec);
945 }
946
947
948 /***********************************************
949  *********  Query trustdb values  **************
950  ***********************************************/
951
952 /* Return true if key is disabled.  Note that this is usually used via
953    the pk_is_disabled macro.  */
954 int
955 tdb_cache_disabled_value (ctrl_t ctrl, PKT_public_key *pk)
956 {
957   gpg_error_t err;
958   TRUSTREC trec;
959   int disabled = 0;
960
961   if (pk->flags.disabled_valid)
962     return pk->flags.disabled;
963
964   init_trustdb (ctrl, 0);
965
966   if (trustdb_args.no_trustdb)
967     return 0;  /* No trustdb => not disabled.  */
968
969   err = read_trust_record (ctrl, pk, &trec);
970   if (err && gpg_err_code (err) != GPG_ERR_NOT_FOUND)
971     {
972       tdbio_invalid ();
973       goto leave;
974     }
975   if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
976     {
977       /* No record found, so assume not disabled.  */
978       goto leave;
979     }
980
981   if ((trec.r.trust.ownertrust & TRUST_FLAG_DISABLED))
982     disabled = 1;
983
984   /* Cache it for later so we don't need to look at the trustdb every
985      time */
986   pk->flags.disabled = disabled;
987   pk->flags.disabled_valid = 1;
988
989  leave:
990   return disabled;
991 }
992
993
994 void
995 tdb_check_trustdb_stale (ctrl_t ctrl)
996 {
997   static int did_nextcheck=0;
998
999   init_trustdb (ctrl, 0);
1000
1001   if (trustdb_args.no_trustdb)
1002     return;  /* No trustdb => can't be stale.  */
1003
1004   if (!did_nextcheck
1005       && (opt.trust_model == TM_PGP || opt.trust_model == TM_CLASSIC
1006           || opt.trust_model == TM_TOFU_PGP || opt.trust_model == TM_TOFU))
1007     {
1008       ulong scheduled;
1009
1010       did_nextcheck = 1;
1011       scheduled = tdbio_read_nextcheck ();
1012       if ((scheduled && scheduled <= make_timestamp ())
1013           || pending_check_trustdb)
1014         {
1015           if (opt.no_auto_check_trustdb)
1016             {
1017               pending_check_trustdb = 1;
1018               if (!opt.quiet)
1019                 log_info (_("please do a --check-trustdb\n"));
1020             }
1021           else
1022             {
1023               if (!opt.quiet)
1024                 log_info (_("checking the trustdb\n"));
1025               validate_keys (ctrl, 0);
1026             }
1027         }
1028     }
1029 }
1030
1031 /*
1032  * Return the validity information for KB/PK (at least one of them
1033  * must be non-NULL).  This is the core of get_validity.  If SIG is
1034  * not NULL, then the trust is being evaluated in the context of the
1035  * provided signature.  This is used by the TOFU code to record
1036  * statistics.
1037  */
1038 unsigned int
1039 tdb_get_validity_core (ctrl_t ctrl,
1040                        kbnode_t kb,
1041                        PKT_public_key *pk, PKT_user_id *uid,
1042                        PKT_public_key *main_pk,
1043                        PKT_signature *sig,
1044                        int may_ask)
1045 {
1046   TRUSTREC trec, vrec;
1047   gpg_error_t err = 0;
1048   ulong recno;
1049 #ifdef USE_TOFU
1050   unsigned int tofu_validity = TRUST_UNKNOWN;
1051   int free_kb = 0;
1052 #endif
1053   unsigned int validity = TRUST_UNKNOWN;
1054
1055   if (kb && pk)
1056     log_assert (keyid_cmp (pk_main_keyid (pk),
1057                            pk_main_keyid (kb->pkt->pkt.public_key)) == 0);
1058
1059   if (! pk)
1060     {
1061       log_assert (kb);
1062       pk = kb->pkt->pkt.public_key;
1063     }
1064
1065 #ifndef USE_TOFU
1066   (void)sig;
1067   (void)may_ask;
1068 #endif
1069
1070   init_trustdb (ctrl, 0);
1071
1072   /* If we have no trustdb (which also means it has not been created)
1073      and the trust-model is always, we don't know the validity -
1074      return immediately.  If we won't do that the tdbio code would try
1075      to open the trustdb and run into a fatal error.  */
1076   if (trustdb_args.no_trustdb && opt.trust_model == TM_ALWAYS)
1077     return TRUST_UNKNOWN;
1078
1079   check_trustdb_stale (ctrl);
1080
1081   if(opt.trust_model==TM_DIRECT)
1082     {
1083       /* Note that this happens BEFORE any user ID stuff is checked.
1084          The direct trust model applies to keys as a whole. */
1085       validity = tdb_get_ownertrust (ctrl, main_pk, 0);
1086       goto leave;
1087     }
1088
1089 #ifdef USE_TOFU
1090   if (opt.trust_model == TM_TOFU || opt.trust_model == TM_TOFU_PGP)
1091     {
1092       kbnode_t n = NULL;
1093       strlist_t user_id_list = NULL;
1094       int done = 0;
1095
1096       /* If the caller didn't supply a user id then use all uids.  */
1097       if (! uid)
1098         {
1099           if (! kb)
1100             {
1101               kb = get_pubkeyblock (ctrl, main_pk->keyid);
1102               free_kb = 1;
1103             }
1104           n = kb;
1105         }
1106
1107       if (DBG_TRUST && sig && sig->signers_uid)
1108         log_debug ("TOFU: only considering user id: '%s'\n",
1109                    sig->signers_uid);
1110
1111       while (!done && (uid || (n = find_next_kbnode (n, PKT_USER_ID))))
1112         {
1113           PKT_user_id *user_id;
1114           int expired = 0;
1115
1116           if (uid)
1117             {
1118               user_id = uid;
1119               /* If the caller specified a user id, then we only
1120                  process the specified user id and are done after the
1121                  first iteration.  */
1122               done = 1;
1123             }
1124           else
1125             user_id = n->pkt->pkt.user_id;
1126
1127           if (user_id->attrib_data)
1128             /* Skip user attributes.  */
1129             continue;
1130
1131           if (sig && sig->signers_uid)
1132             /* Make sure the UID matches.  */
1133             {
1134               char *email = mailbox_from_userid (user_id->name);
1135               if (!email || !*email || strcmp (sig->signers_uid, email) != 0)
1136                 {
1137                   if (DBG_TRUST)
1138                     log_debug ("TOFU: skipping user id '%s', which does"
1139                                " not match the signer's email ('%s')\n",
1140                                email, sig->signers_uid);
1141                   xfree (email);
1142                   continue;
1143                 }
1144               xfree (email);
1145             }
1146
1147           /* If the user id is revoked or expired, then skip it.  */
1148           if (user_id->flags.revoked || user_id->flags.expired)
1149             {
1150               if (DBG_TRUST)
1151                 {
1152                   char *s;
1153                   if (user_id->flags.revoked && user_id->flags.expired)
1154                     s = "revoked and expired";
1155                   else if (user_id->flags.revoked)
1156                     s = "revoked";
1157                   else
1158                     s = "expire";
1159
1160                   log_debug ("TOFU: Ignoring %s user id (%s)\n",
1161                              s, user_id->name);
1162                 }
1163
1164               if (user_id->flags.revoked)
1165                 continue;
1166
1167               expired = 1;
1168             }
1169
1170           add_to_strlist (&user_id_list, user_id->name);
1171           user_id_list->flags = expired;
1172         }
1173
1174       /* Process the user ids in the order they appear in the key
1175          block.  */
1176       strlist_rev (&user_id_list);
1177
1178       /* It only makes sense to observe any signature before getting
1179          the validity.  This is because if the current signature
1180          results in a conflict, then we damn well want to take that
1181          into account.  */
1182       if (sig)
1183         {
1184           err = tofu_register_signature (ctrl, main_pk, user_id_list,
1185                                          sig->digest, sig->digest_len,
1186                                          sig->timestamp, "unknown");
1187           if (err)
1188             {
1189               log_error ("TOFU: error registering signature: %s\n",
1190                          gpg_strerror (err));
1191
1192               tofu_validity = TRUST_UNKNOWN;
1193             }
1194         }
1195       if (! err)
1196         tofu_validity = tofu_get_validity (ctrl, main_pk, user_id_list,
1197                                            may_ask);
1198
1199       free_strlist (user_id_list);
1200       if (free_kb)
1201         release_kbnode (kb);
1202     }
1203 #endif /*USE_TOFU*/
1204
1205   if (opt.trust_model == TM_TOFU_PGP
1206       || opt.trust_model == TM_CLASSIC
1207       || opt.trust_model == TM_PGP)
1208     {
1209       err = read_trust_record (ctrl, main_pk, &trec);
1210       if (err && gpg_err_code (err) != GPG_ERR_NOT_FOUND)
1211         {
1212           tdbio_invalid ();
1213           return 0;
1214         }
1215       if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
1216         {
1217           /* No record found.  */
1218           validity = TRUST_UNKNOWN;
1219           goto leave;
1220         }
1221
1222       /* Loop over all user IDs */
1223       recno = trec.r.trust.validlist;
1224       validity = 0;
1225       while (recno)
1226         {
1227           read_record (recno, &vrec, RECTYPE_VALID);
1228
1229           if(uid)
1230             {
1231               /* If a user ID is given we return the validity for that
1232                  user ID ONLY.  If the namehash is not found, then
1233                  there is no validity at all (i.e. the user ID wasn't
1234                  signed). */
1235               if(memcmp(vrec.r.valid.namehash,uid->namehash,20)==0)
1236                 {
1237                   validity=(vrec.r.valid.validity & TRUST_MASK);
1238                   break;
1239                 }
1240             }
1241           else
1242             {
1243               /* If no user ID is given, we take the maximum validity
1244                  over all user IDs */
1245               if (validity < (vrec.r.valid.validity & TRUST_MASK))
1246                 validity = (vrec.r.valid.validity & TRUST_MASK);
1247             }
1248
1249           recno = vrec.r.valid.next;
1250         }
1251
1252       if ((trec.r.trust.ownertrust & TRUST_FLAG_DISABLED))
1253         {
1254           validity |= TRUST_FLAG_DISABLED;
1255           pk->flags.disabled = 1;
1256         }
1257       else
1258         pk->flags.disabled = 0;
1259       pk->flags.disabled_valid = 1;
1260     }
1261
1262  leave:
1263 #ifdef USE_TOFU
1264   validity = tofu_wot_trust_combine (tofu_validity, validity);
1265 #else /*!USE_TOFU*/
1266   validity &= TRUST_MASK;
1267
1268   if (validity == TRUST_NEVER)
1269     /* TRUST_NEVER trumps everything else.  */
1270     validity |= TRUST_NEVER;
1271   if (validity == TRUST_EXPIRED)
1272     /* TRUST_EXPIRED trumps everything but TRUST_NEVER.  */
1273     validity |= TRUST_EXPIRED;
1274 #endif /*!USE_TOFU*/
1275
1276   if (opt.trust_model != TM_TOFU
1277       && pending_check_trustdb)
1278     validity |= TRUST_FLAG_PENDING_CHECK;
1279
1280   return validity;
1281 }
1282
1283
1284 static void
1285 get_validity_counts (ctrl_t ctrl, PKT_public_key *pk, PKT_user_id *uid)
1286 {
1287   TRUSTREC trec, vrec;
1288   ulong recno;
1289
1290   if(pk==NULL || uid==NULL)
1291     BUG();
1292
1293   namehash_from_uid(uid);
1294
1295   uid->help_marginal_count=uid->help_full_count=0;
1296
1297   init_trustdb (ctrl, 0);
1298
1299   if(read_trust_record (ctrl, pk, &trec))
1300     return;
1301
1302   /* loop over all user IDs */
1303   recno = trec.r.trust.validlist;
1304   while (recno)
1305     {
1306       read_record (recno, &vrec, RECTYPE_VALID);
1307
1308       if(memcmp(vrec.r.valid.namehash,uid->namehash,20)==0)
1309         {
1310           uid->help_marginal_count=vrec.r.valid.marginal_count;
1311           uid->help_full_count=vrec.r.valid.full_count;
1312           /*  es_printf("Fetched marginal %d, full %d\n",uid->help_marginal_count,uid->help_full_count); */
1313           break;
1314         }
1315
1316       recno = vrec.r.valid.next;
1317     }
1318 }
1319
1320 void
1321 list_trust_path( const char *username )
1322 {
1323   (void)username;
1324 }
1325
1326 /****************
1327  * Enumerate all keys, which are needed to build all trust paths for
1328  * the given key.  This function does not return the key itself or
1329  * the ultimate key (the last point in cerificate chain).  Only
1330  * certificate chains which ends up at an ultimately trusted key
1331  * are listed.  If ownertrust or validity is not NULL, the corresponding
1332  * value for the returned LID is also returned in these variable(s).
1333  *
1334  *  1) create a void pointer and initialize it to NULL
1335  *  2) pass this void pointer by reference to this function.
1336  *     Set lid to the key you want to enumerate and pass it by reference.
1337  *  3) call this function as long as it does not return -1
1338  *     to indicate EOF. LID does contain the next key used to build the web
1339  *  4) Always call this function a last time with LID set to NULL,
1340  *     so that it can free its context.
1341  *
1342  * Returns: -1 on EOF or the level of the returned LID
1343  */
1344 int
1345 enum_cert_paths( void **context, ulong *lid,
1346                  unsigned *ownertrust, unsigned *validity )
1347 {
1348   (void)context;
1349   (void)lid;
1350   (void)ownertrust;
1351   (void)validity;
1352   return -1;
1353 }
1354
1355
1356 /****************
1357  * Print the current path
1358  */
1359 void
1360 enum_cert_paths_print (void **context, FILE *fp,
1361                        int refresh, ulong selected_lid)
1362 {
1363   (void)context;
1364   (void)fp;
1365   (void)refresh;
1366   (void)selected_lid;
1367 }
1368
1369
1370 \f
1371 /****************************************
1372  *********** NEW NEW NEW ****************
1373  ****************************************/
1374
1375 static int
1376 ask_ownertrust (ctrl_t ctrl, u32 *kid, int minimum)
1377 {
1378   PKT_public_key *pk;
1379   int rc;
1380   int ot;
1381
1382   pk = xmalloc_clear (sizeof *pk);
1383   rc = get_pubkey (ctrl, pk, kid);
1384   if (rc)
1385     {
1386       log_error (_("public key %s not found: %s\n"),
1387                  keystr(kid), gpg_strerror (rc) );
1388       return TRUST_UNKNOWN;
1389     }
1390
1391   if(opt.force_ownertrust)
1392     {
1393       log_info("force trust for key %s to %s\n",
1394                keystr(kid),trust_value_to_string(opt.force_ownertrust));
1395       tdb_update_ownertrust (ctrl, pk, opt.force_ownertrust);
1396       ot=opt.force_ownertrust;
1397     }
1398   else
1399     {
1400       ot=edit_ownertrust (ctrl, pk, 0);
1401       if(ot>0)
1402         ot = tdb_get_ownertrust (ctrl, pk, 0);
1403       else if(ot==0)
1404         ot = minimum?minimum:TRUST_UNDEFINED;
1405       else
1406         ot = -1; /* quit */
1407     }
1408
1409   free_public_key( pk );
1410
1411   return ot;
1412 }
1413
1414
1415 static void
1416 mark_keyblock_seen (KeyHashTable tbl, KBNODE node)
1417 {
1418   for ( ;node; node = node->next )
1419     if (node->pkt->pkttype == PKT_PUBLIC_KEY
1420         || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1421       {
1422         u32 aki[2];
1423
1424         keyid_from_pk (node->pkt->pkt.public_key, aki);
1425         add_key_hash_table (tbl, aki);
1426       }
1427 }
1428
1429
1430 static void
1431 dump_key_array (int depth, struct key_array *keys)
1432 {
1433   struct key_array *kar;
1434
1435   for (kar=keys; kar->keyblock; kar++)
1436     {
1437       KBNODE node = kar->keyblock;
1438       u32 kid[2];
1439
1440       keyid_from_pk(node->pkt->pkt.public_key, kid);
1441       es_printf ("%d:%08lX%08lX:K::%c::::\n",
1442                  depth, (ulong)kid[0], (ulong)kid[1], '?');
1443
1444       for (; node; node = node->next)
1445         {
1446           if (node->pkt->pkttype == PKT_USER_ID)
1447             {
1448               int len = node->pkt->pkt.user_id->len;
1449
1450               if (len > 30)
1451                 len = 30;
1452               es_printf ("%d:%08lX%08lX:U:::%c:::",
1453                          depth, (ulong)kid[0], (ulong)kid[1],
1454                          (node->flag & 4)? 'f':
1455                          (node->flag & 2)? 'm':
1456                          (node->flag & 1)? 'q':'-');
1457               es_write_sanitized (es_stdout, node->pkt->pkt.user_id->name,
1458                                   len, ":", NULL);
1459               es_putc (':', es_stdout);
1460               es_putc ('\n', es_stdout);
1461             }
1462         }
1463     }
1464 }
1465
1466
1467 static void
1468 store_validation_status (ctrl_t ctrl, int depth,
1469                          kbnode_t keyblock, KeyHashTable stored)
1470 {
1471   KBNODE node;
1472   int status;
1473   int any = 0;
1474
1475   for (node=keyblock; node; node = node->next)
1476     {
1477       if (node->pkt->pkttype == PKT_USER_ID)
1478         {
1479           PKT_user_id *uid = node->pkt->pkt.user_id;
1480           if (node->flag & 4)
1481             status = TRUST_FULLY;
1482           else if (node->flag & 2)
1483             status = TRUST_MARGINAL;
1484           else if (node->flag & 1)
1485             status = TRUST_UNDEFINED;
1486           else
1487             status = 0;
1488
1489           if (status)
1490             {
1491               update_validity (ctrl, keyblock->pkt->pkt.public_key,
1492                                uid, depth, status);
1493
1494               mark_keyblock_seen(stored,keyblock);
1495
1496               any = 1;
1497             }
1498         }
1499     }
1500
1501   if (any)
1502     do_sync ();
1503 }
1504
1505
1506 /* Returns a sanitized copy of the regexp (which might be "", but not
1507    NULL). */
1508 #ifndef DISABLE_REGEX
1509 /* Operator charactors except '.' and backslash.
1510    See regex(7) on BSD.  */
1511 #define REGEXP_OPERATOR_CHARS "^[$()|*+?{"
1512
1513 static char *
1514 sanitize_regexp(const char *old)
1515 {
1516   size_t start=0,len=strlen(old),idx=0;
1517   int escaped=0,standard_bracket=0;
1518   char *new=xmalloc((len*2)+1); /* enough to \-escape everything if we
1519                                    have to */
1520
1521   /* There are basically two commonly-used regexps here.  GPG and most
1522      versions of PGP use "<[^>]+[@.]example\.com>$" and PGP (9)
1523      command line uses "example.com" (i.e. whatever the user specifies,
1524      and we can't expect users know to use "\." instead of ".").  So
1525      here are the rules: we're allowed to start with "<[^>]+[@.]" and
1526      end with ">$" or start and end with nothing.  In between, the
1527      only legal regex character is ".", and everything else gets
1528      escaped.  Part of the gotcha here is that some regex packages
1529      allow more than RFC-4880 requires.  For example, 4880 has no "{}"
1530      operator, but GNU regex does.  Commenting removes these operators
1531      from consideration.  A possible future enhancement is to use
1532      commenting to effectively back off a given regex to the Henry
1533      Spencer syntax in 4880. -dshaw */
1534
1535   /* Are we bracketed between "<[^>]+[@.]" and ">$" ? */
1536   if(len>=12 && strncmp(old,"<[^>]+[@.]",10)==0
1537      && old[len-2]=='>' && old[len-1]=='$')
1538     {
1539       strcpy(new,"<[^>]+[@.]");
1540       idx=strlen(new);
1541       standard_bracket=1;
1542       start+=10;
1543       len-=2;
1544     }
1545
1546   /* Walk the remaining characters and ensure that everything that is
1547      left is not an operational regex character. */
1548   for(;start<len;start++)
1549     {
1550       if(!escaped && old[start]=='\\')
1551         escaped=1;
1552       else if (!escaped && strchr (REGEXP_OPERATOR_CHARS, old[start]))
1553         new[idx++]='\\';
1554       else
1555         escaped=0;
1556
1557       new[idx++]=old[start];
1558     }
1559
1560   new[idx]='\0';
1561
1562   /* Note that the (sub)string we look at might end with a bare "\".
1563      If it does, leave it that way.  If the regexp actually ended with
1564      ">$", then it was escaping the ">" and is fine.  If the regexp
1565      actually ended with the bare "\", then it's an illegal regexp and
1566      regcomp should kick it out. */
1567
1568   if(standard_bracket)
1569     strcat(new,">$");
1570
1571   return new;
1572 }
1573 #endif /*!DISABLE_REGEX*/
1574
1575 /* Used by validate_one_keyblock to confirm a regexp within a trust
1576    signature.  Returns 1 for match, and 0 for no match or regex
1577    error. */
1578 static int
1579 check_regexp(const char *expr,const char *string)
1580 {
1581 #ifdef DISABLE_REGEX
1582   (void)expr;
1583   (void)string;
1584   /* When DISABLE_REGEX is defined, assume all regexps do not
1585      match. */
1586   return 0;
1587 #else
1588   int ret;
1589   char *regexp;
1590
1591   regexp=sanitize_regexp(expr);
1592
1593 #ifdef __riscos__
1594   ret=riscos_check_regexp(expr, string, DBG_TRUST);
1595 #else
1596   {
1597     regex_t pat;
1598
1599     ret=regcomp(&pat,regexp,REG_ICASE|REG_NOSUB|REG_EXTENDED);
1600     if(ret==0)
1601       {
1602         ret=regexec(&pat,string,0,NULL,0);
1603         regfree(&pat);
1604       }
1605     ret=(ret==0);
1606   }
1607 #endif
1608
1609   if(DBG_TRUST)
1610     log_debug("regexp '%s' ('%s') on '%s': %s\n",
1611               regexp,expr,string,ret?"YES":"NO");
1612
1613   xfree(regexp);
1614
1615   return ret;
1616 #endif
1617 }
1618
1619 /*
1620  * Return true if the key is signed by one of the keys in the given
1621  * key ID list.  User IDs with a valid signature are marked by node
1622  * flags as follows:
1623  *  flag bit 0: There is at least one signature
1624  *           1: There is marginal confidence that this is a legitimate uid
1625  *           2: There is full confidence that this is a legitimate uid.
1626  *           8: Used for internal purposes.
1627  *           9: Ditto (in mark_usable_uid_certs())
1628  *          10: Ditto (ditto)
1629  * This function assumes that all kbnode flags are cleared on entry.
1630  */
1631 static int
1632 validate_one_keyblock (ctrl_t ctrl, kbnode_t kb, struct key_item *klist,
1633                        u32 curtime, u32 *next_expire)
1634 {
1635   struct key_item *kr;
1636   KBNODE node, uidnode=NULL;
1637   PKT_user_id *uid=NULL;
1638   PKT_public_key *pk = kb->pkt->pkt.public_key;
1639   u32 main_kid[2];
1640   int issigned=0, any_signed = 0;
1641
1642   keyid_from_pk(pk, main_kid);
1643   for (node=kb; node; node = node->next)
1644     {
1645       /* A bit of discussion here: is it better for the web of trust
1646          to be built among only self-signed uids?  On the one hand, a
1647          self-signed uid is a statement that the key owner definitely
1648          intended that uid to be there, but on the other hand, a
1649          signed (but not self-signed) uid does carry trust, of a sort,
1650          even if it is a statement being made by people other than the
1651          key owner "through" the uids on the key owner's key.  I'm
1652          going with the latter.  However, if the user ID was
1653          explicitly revoked, or passively allowed to expire, that
1654          should stop validity through the user ID until it is
1655          resigned.  -dshaw */
1656
1657       if (node->pkt->pkttype == PKT_USER_ID
1658           && !node->pkt->pkt.user_id->flags.revoked
1659           && !node->pkt->pkt.user_id->flags.expired)
1660         {
1661           if (uidnode && issigned)
1662             {
1663               if (uid->help_full_count >= opt.completes_needed
1664                   || uid->help_marginal_count >= opt.marginals_needed )
1665                 uidnode->flag |= 4;
1666               else if (uid->help_full_count || uid->help_marginal_count)
1667                 uidnode->flag |= 2;
1668               uidnode->flag |= 1;
1669               any_signed = 1;
1670             }
1671           uidnode = node;
1672           uid=uidnode->pkt->pkt.user_id;
1673
1674           /* If the selfsig is going to expire... */
1675           if(uid->expiredate && uid->expiredate<*next_expire)
1676             *next_expire = uid->expiredate;
1677
1678           issigned = 0;
1679           get_validity_counts (ctrl, pk, uid);
1680           mark_usable_uid_certs (ctrl, kb, uidnode, main_kid, klist,
1681                                  curtime, next_expire);
1682         }
1683       else if (node->pkt->pkttype == PKT_SIGNATURE
1684                && (node->flag & (1<<8)) && uid)
1685         {
1686           /* Note that we are only seeing unrevoked sigs here */
1687           PKT_signature *sig = node->pkt->pkt.signature;
1688
1689           kr = is_in_klist (klist, sig);
1690           /* If the trust_regexp does not match, it's as if the sig
1691              did not exist.  This is safe for non-trust sigs as well
1692              since we don't accept a regexp on the sig unless it's a
1693              trust sig. */
1694           if (kr && (!kr->trust_regexp
1695                      || !(opt.trust_model == TM_PGP
1696                           || opt.trust_model == TM_TOFU_PGP)
1697                      || (uidnode
1698                          && check_regexp(kr->trust_regexp,
1699                                          uidnode->pkt->pkt.user_id->name))))
1700             {
1701               /* Are we part of a trust sig chain?  We always favor
1702                  the latest trust sig, rather than the greater or
1703                  lesser trust sig or value.  I could make a decent
1704                  argument for any of these cases, but this seems to be
1705                  what PGP does, and I'd like to be compatible. -dms */
1706               if ((opt.trust_model == TM_PGP
1707                    || opt.trust_model == TM_TOFU_PGP)
1708                   && sig->trust_depth
1709                   && pk->trust_timestamp <= sig->timestamp)
1710                 {
1711                   unsigned char depth;
1712
1713                   /* If the depth on the signature is less than the
1714                      chain currently has, then use the signature depth
1715                      so we don't increase the depth beyond what the
1716                      signer wanted.  If the depth on the signature is
1717                      more than the chain currently has, then use the
1718                      chain depth so we use as much of the signature
1719                      depth as the chain will permit.  An ultimately
1720                      trusted signature can restart the depth to
1721                      whatever level it likes. */
1722
1723                   if (sig->trust_depth < kr->trust_depth
1724                       || kr->ownertrust == TRUST_ULTIMATE)
1725                     depth = sig->trust_depth;
1726                   else
1727                     depth = kr->trust_depth;
1728
1729                   if (depth)
1730                     {
1731                       if(DBG_TRUST)
1732                         log_debug ("trust sig on %s, sig depth is %d,"
1733                                    " kr depth is %d\n",
1734                                    uidnode->pkt->pkt.user_id->name,
1735                                    sig->trust_depth,
1736                                    kr->trust_depth);
1737
1738                       /* If we got here, we know that:
1739
1740                          this is a trust sig.
1741
1742                          it's a newer trust sig than any previous trust
1743                          sig on this key (not uid).
1744
1745                          it is legal in that it was either generated by an
1746                          ultimate key, or a key that was part of a trust
1747                          chain, and the depth does not violate the
1748                          original trust sig.
1749
1750                          if there is a regexp attached, it matched
1751                          successfully.
1752                       */
1753
1754                       if (DBG_TRUST)
1755                         log_debug ("replacing trust value %d with %d and "
1756                                    "depth %d with %d\n",
1757                                    pk->trust_value,sig->trust_value,
1758                                    pk->trust_depth,depth);
1759
1760                       pk->trust_value = sig->trust_value;
1761                       pk->trust_depth = depth-1;
1762
1763                       /* If the trust sig contains a regexp, record it
1764                          on the pk for the next round. */
1765                       if (sig->trust_regexp)
1766                         pk->trust_regexp = sig->trust_regexp;
1767                     }
1768                 }
1769
1770               if (kr->ownertrust == TRUST_ULTIMATE)
1771                 uid->help_full_count = opt.completes_needed;
1772               else if (kr->ownertrust == TRUST_FULLY)
1773                 uid->help_full_count++;
1774               else if (kr->ownertrust == TRUST_MARGINAL)
1775                 uid->help_marginal_count++;
1776               issigned = 1;
1777             }
1778         }
1779     }
1780
1781   if (uidnode && issigned)
1782     {
1783       if (uid->help_full_count >= opt.completes_needed
1784           || uid->help_marginal_count >= opt.marginals_needed )
1785         uidnode->flag |= 4;
1786       else if (uid->help_full_count || uid->help_marginal_count)
1787         uidnode->flag |= 2;
1788       uidnode->flag |= 1;
1789       any_signed = 1;
1790     }
1791
1792   return any_signed;
1793 }
1794
1795
1796 static int
1797 search_skipfnc (void *opaque, u32 *kid, int dummy_uid_no)
1798 {
1799   (void)dummy_uid_no;
1800   return test_key_hash_table ((KeyHashTable)opaque, kid);
1801 }
1802
1803
1804 /*
1805  * Scan all keys and return a key_array of all suitable keys from
1806  * kllist.  The caller has to pass keydb handle so that we don't use
1807  * to create our own.  Returns either a key_array or NULL in case of
1808  * an error.  No results found are indicated by an empty array.
1809  * Caller hast to release the returned array.
1810  */
1811 static struct key_array *
1812 validate_key_list (ctrl_t ctrl, KEYDB_HANDLE hd, KeyHashTable full_trust,
1813                    struct key_item *klist, u32 curtime, u32 *next_expire)
1814 {
1815   KBNODE keyblock = NULL;
1816   struct key_array *keys = NULL;
1817   size_t nkeys, maxkeys;
1818   int rc;
1819   KEYDB_SEARCH_DESC desc;
1820
1821   maxkeys = 1000;
1822   keys = xmalloc ((maxkeys+1) * sizeof *keys);
1823   nkeys = 0;
1824
1825   rc = keydb_search_reset (hd);
1826   if (rc)
1827     {
1828       log_error ("keydb_search_reset failed: %s\n", gpg_strerror (rc));
1829       xfree (keys);
1830       return NULL;
1831     }
1832
1833   memset (&desc, 0, sizeof desc);
1834   desc.mode = KEYDB_SEARCH_MODE_FIRST;
1835   desc.skipfnc = search_skipfnc;
1836   desc.skipfncvalue = full_trust;
1837   rc = keydb_search (hd, &desc, 1, NULL);
1838   if (gpg_err_code (rc) == GPG_ERR_NOT_FOUND)
1839     {
1840       keys[nkeys].keyblock = NULL;
1841       return keys;
1842     }
1843   if (rc)
1844     {
1845       log_error ("keydb_search(first) failed: %s\n", gpg_strerror (rc));
1846       goto die;
1847     }
1848
1849   desc.mode = KEYDB_SEARCH_MODE_NEXT; /* change mode */
1850   do
1851     {
1852       PKT_public_key *pk;
1853
1854       rc = keydb_get_keyblock (hd, &keyblock);
1855       if (rc)
1856         {
1857           log_error ("keydb_get_keyblock failed: %s\n", gpg_strerror (rc));
1858           goto die;
1859         }
1860
1861       if ( keyblock->pkt->pkttype != PKT_PUBLIC_KEY)
1862         {
1863           log_debug ("ooops: invalid pkttype %d encountered\n",
1864                      keyblock->pkt->pkttype);
1865           dump_kbnode (keyblock);
1866           release_kbnode(keyblock);
1867           continue;
1868         }
1869
1870       /* prepare the keyblock for further processing */
1871       merge_keys_and_selfsig (ctrl, keyblock);
1872       clear_kbnode_flags (keyblock);
1873       pk = keyblock->pkt->pkt.public_key;
1874       if (pk->has_expired || pk->flags.revoked)
1875         {
1876           /* it does not make sense to look further at those keys */
1877           mark_keyblock_seen (full_trust, keyblock);
1878         }
1879       else if (validate_one_keyblock (ctrl, keyblock, klist,
1880                                       curtime, next_expire))
1881         {
1882           KBNODE node;
1883
1884           if (pk->expiredate && pk->expiredate >= curtime
1885               && pk->expiredate < *next_expire)
1886             *next_expire = pk->expiredate;
1887
1888           if (nkeys == maxkeys) {
1889             maxkeys += 1000;
1890             keys = xrealloc (keys, (maxkeys+1) * sizeof *keys);
1891           }
1892           keys[nkeys++].keyblock = keyblock;
1893
1894           /* Optimization - if all uids are fully trusted, then we
1895              never need to consider this key as a candidate again. */
1896
1897           for (node=keyblock; node; node = node->next)
1898             if (node->pkt->pkttype == PKT_USER_ID && !(node->flag & 4))
1899               break;
1900
1901           if(node==NULL)
1902             mark_keyblock_seen (full_trust, keyblock);
1903
1904           keyblock = NULL;
1905         }
1906
1907       release_kbnode (keyblock);
1908       keyblock = NULL;
1909     }
1910   while (!(rc = keydb_search (hd, &desc, 1, NULL)));
1911
1912   if (rc && gpg_err_code (rc) != GPG_ERR_NOT_FOUND)
1913     {
1914       log_error ("keydb_search_next failed: %s\n", gpg_strerror (rc));
1915       goto die;
1916     }
1917
1918   keys[nkeys].keyblock = NULL;
1919   return keys;
1920
1921  die:
1922   keys[nkeys].keyblock = NULL;
1923   release_key_array (keys);
1924   return NULL;
1925 }
1926
1927 /* Caller must sync */
1928 static void
1929 reset_trust_records (ctrl_t ctrl)
1930 {
1931   TRUSTREC rec;
1932   ulong recnum;
1933   int count = 0, nreset = 0;
1934
1935   for (recnum=1; !tdbio_read_record (recnum, &rec, 0); recnum++ )
1936     {
1937       if(rec.rectype==RECTYPE_TRUST)
1938         {
1939           count++;
1940           if(rec.r.trust.min_ownertrust)
1941             {
1942               rec.r.trust.min_ownertrust=0;
1943               write_record (ctrl, &rec);
1944             }
1945
1946         }
1947       else if(rec.rectype==RECTYPE_VALID
1948               && ((rec.r.valid.validity&TRUST_MASK)
1949                   || rec.r.valid.marginal_count
1950                   || rec.r.valid.full_count))
1951         {
1952           rec.r.valid.validity &= ~TRUST_MASK;
1953           rec.r.valid.marginal_count=rec.r.valid.full_count=0;
1954           nreset++;
1955           write_record (ctrl, &rec);
1956         }
1957
1958     }
1959
1960   if (opt.verbose)
1961     {
1962       log_info (ngettext("%d key processed",
1963                          "%d keys processed",
1964                          count), count);
1965       log_printf (ngettext(" (%d validity count cleared)\n",
1966                            " (%d validity counts cleared)\n",
1967                            nreset), nreset);
1968     }
1969 }
1970
1971 /*
1972  * Run the key validation procedure.
1973  *
1974  * This works this way:
1975  * Step 1: Find all ultimately trusted keys (UTK).
1976  *         mark them all as seen and put them into klist.
1977  * Step 2: loop max_cert_times
1978  * Step 3:   if OWNERTRUST of any key in klist is undefined
1979  *             ask user to assign ownertrust
1980  * Step 4:   Loop over all keys in the keyDB which are not marked seen
1981  * Step 5:     if key is revoked or expired
1982  *                mark key as seen
1983  *                continue loop at Step 4
1984  * Step 6:     For each user ID of that key signed by a key in klist
1985  *                Calculate validity by counting trusted signatures.
1986  *                Set validity of user ID
1987  * Step 7:     If any signed user ID was found
1988  *                mark key as seen
1989  *             End Loop
1990  * Step 8:   Build a new klist from all fully trusted keys from step 6
1991  *           End Loop
1992  *         Ready
1993  *
1994  */
1995 static int
1996 validate_keys (ctrl_t ctrl, int interactive)
1997 {
1998   int rc = 0;
1999   int quit=0;
2000   struct key_item *klist = NULL;
2001   struct key_item *k;
2002   struct key_array *keys = NULL;
2003   struct key_array *kar;
2004   KEYDB_HANDLE kdb = NULL;
2005   KBNODE node;
2006   int depth;
2007   int ot_unknown, ot_undefined, ot_never, ot_marginal, ot_full, ot_ultimate;
2008   KeyHashTable stored,used,full_trust;
2009   u32 start_time, next_expire;
2010
2011   /* Make sure we have all sigs cached.  TODO: This is going to
2012      require some architectural re-thinking, as it is agonizingly slow.
2013      Perhaps combine this with reset_trust_records(), or only check
2014      the caches on keys that are actually involved in the web of
2015      trust. */
2016   keydb_rebuild_caches (ctrl, 0);
2017
2018   kdb = keydb_new ();
2019   if (!kdb)
2020     return gpg_error_from_syserror ();
2021
2022   start_time = make_timestamp ();
2023   next_expire = 0xffffffff; /* set next expire to the year 2106 */
2024   stored = new_key_hash_table ();
2025   used = new_key_hash_table ();
2026   full_trust = new_key_hash_table ();
2027
2028   reset_trust_records (ctrl);
2029
2030   /* Fixme: Instead of always building a UTK list, we could just build it
2031    * here when needed */
2032   if (!utk_list)
2033     {
2034       if (!opt.quiet)
2035         log_info (_("no ultimately trusted keys found\n"));
2036       goto leave;
2037     }
2038
2039   /* mark all UTKs as used and fully_trusted and set validity to
2040      ultimate */
2041   for (k=utk_list; k; k = k->next)
2042     {
2043       KBNODE keyblock;
2044       PKT_public_key *pk;
2045
2046       keyblock = get_pubkeyblock (ctrl, k->kid);
2047       if (!keyblock)
2048         {
2049           log_error (_("public key of ultimately"
2050                        " trusted key %s not found\n"), keystr(k->kid));
2051           continue;
2052         }
2053       mark_keyblock_seen (used, keyblock);
2054       mark_keyblock_seen (stored, keyblock);
2055       mark_keyblock_seen (full_trust, keyblock);
2056       pk = keyblock->pkt->pkt.public_key;
2057       for (node=keyblock; node; node = node->next)
2058         {
2059           if (node->pkt->pkttype == PKT_USER_ID)
2060             update_validity (ctrl, pk, node->pkt->pkt.user_id,
2061                              0, TRUST_ULTIMATE);
2062         }
2063       if ( pk->expiredate && pk->expiredate >= start_time
2064            && pk->expiredate < next_expire)
2065         next_expire = pk->expiredate;
2066
2067       release_kbnode (keyblock);
2068       do_sync ();
2069     }
2070
2071   if (opt.trust_model == TM_TOFU)
2072     /* In the TOFU trust model, we only need to save the ultimately
2073        trusted keys.  */
2074     goto leave;
2075
2076   klist = utk_list;
2077
2078   if (!opt.quiet)
2079     log_info ("marginals needed: %d  completes needed: %d  trust model: %s\n",
2080               opt.marginals_needed, opt.completes_needed,
2081               trust_model_string (opt.trust_model));
2082
2083   for (depth=0; depth < opt.max_cert_depth; depth++)
2084     {
2085       int valids=0,key_count;
2086       /* See whether we should assign ownertrust values to the keys in
2087          klist.  */
2088       ot_unknown = ot_undefined = ot_never = 0;
2089       ot_marginal = ot_full = ot_ultimate = 0;
2090       for (k=klist; k; k = k->next)
2091         {
2092           int min=0;
2093
2094           /* 120 and 60 are as per RFC2440 */
2095           if(k->trust_value>=120)
2096             min=TRUST_FULLY;
2097           else if(k->trust_value>=60)
2098             min=TRUST_MARGINAL;
2099
2100           if(min!=k->min_ownertrust)
2101             update_min_ownertrust (ctrl, k->kid,min);
2102
2103           if (interactive && k->ownertrust == TRUST_UNKNOWN)
2104             {
2105               k->ownertrust = ask_ownertrust (ctrl, k->kid,min);
2106
2107               if (k->ownertrust == (unsigned int)(-1))
2108                 {
2109                   quit=1;
2110                   goto leave;
2111                 }
2112             }
2113
2114           /* This can happen during transition from an old trustdb
2115              before trust sigs.  It can also happen if a user uses two
2116              different versions of GnuPG or changes the --trust-model
2117              setting. */
2118           if(k->ownertrust<min)
2119             {
2120               if(DBG_TRUST)
2121                 log_debug("key %08lX%08lX:"
2122                           " overriding ownertrust '%s' with '%s'\n",
2123                           (ulong)k->kid[0],(ulong)k->kid[1],
2124                           trust_value_to_string(k->ownertrust),
2125                           trust_value_to_string(min));
2126
2127               k->ownertrust=min;
2128             }
2129
2130           if (k->ownertrust == TRUST_UNKNOWN)
2131             ot_unknown++;
2132           else if (k->ownertrust == TRUST_UNDEFINED)
2133             ot_undefined++;
2134           else if (k->ownertrust == TRUST_NEVER)
2135             ot_never++;
2136           else if (k->ownertrust == TRUST_MARGINAL)
2137             ot_marginal++;
2138           else if (k->ownertrust == TRUST_FULLY)
2139             ot_full++;
2140           else if (k->ownertrust == TRUST_ULTIMATE)
2141             ot_ultimate++;
2142
2143           valids++;
2144         }
2145
2146       /* Find all keys which are signed by a key in kdlist */
2147       keys = validate_key_list (ctrl, kdb, full_trust, klist,
2148                                 start_time, &next_expire);
2149       if (!keys)
2150         {
2151           log_error ("validate_key_list failed\n");
2152           rc = GPG_ERR_GENERAL;
2153           goto leave;
2154         }
2155
2156       for (key_count=0, kar=keys; kar->keyblock; kar++, key_count++)
2157         ;
2158
2159       /* Store the calculated valididation status somewhere */
2160       if (opt.verbose > 1 && DBG_TRUST)
2161         dump_key_array (depth, keys);
2162
2163       for (kar=keys; kar->keyblock; kar++)
2164         store_validation_status (ctrl, depth, kar->keyblock, stored);
2165
2166       if (!opt.quiet)
2167         log_info (_("depth: %d  valid: %3d  signed: %3d"
2168                     "  trust: %d-, %dq, %dn, %dm, %df, %du\n"),
2169                   depth, valids, key_count, ot_unknown, ot_undefined,
2170                   ot_never, ot_marginal, ot_full, ot_ultimate );
2171
2172       /* Build a new kdlist from all fully valid keys in KEYS */
2173       if (klist != utk_list)
2174         release_key_items (klist);
2175       klist = NULL;
2176       for (kar=keys; kar->keyblock; kar++)
2177         {
2178           for (node=kar->keyblock; node; node = node->next)
2179             {
2180               if (node->pkt->pkttype == PKT_USER_ID && (node->flag & 4))
2181                 {
2182                   u32 kid[2];
2183
2184                   /* have we used this key already? */
2185                   keyid_from_pk (kar->keyblock->pkt->pkt.public_key, kid);
2186                   if(test_key_hash_table(used,kid)==0)
2187                     {
2188                       /* Normally we add both the primary and subkey
2189                          ids to the hash via mark_keyblock_seen, but
2190                          since we aren't using this hash as a skipfnc,
2191                          that doesn't matter here. */
2192                       add_key_hash_table (used,kid);
2193                       k = new_key_item ();
2194                       k->kid[0]=kid[0];
2195                       k->kid[1]=kid[1];
2196                       k->ownertrust =
2197                         (tdb_get_ownertrust
2198                            (ctrl, kar->keyblock->pkt->pkt.public_key, 0)
2199                          & TRUST_MASK);
2200                       k->min_ownertrust = tdb_get_min_ownertrust
2201                         (ctrl, kar->keyblock->pkt->pkt.public_key, 0);
2202                       k->trust_depth=
2203                         kar->keyblock->pkt->pkt.public_key->trust_depth;
2204                       k->trust_value=
2205                         kar->keyblock->pkt->pkt.public_key->trust_value;
2206                       if(kar->keyblock->pkt->pkt.public_key->trust_regexp)
2207                         k->trust_regexp=
2208                           xstrdup(kar->keyblock->pkt->
2209                                    pkt.public_key->trust_regexp);
2210                       k->next = klist;
2211                       klist = k;
2212                       break;
2213                     }
2214                 }
2215             }
2216         }
2217       release_key_array (keys);
2218       keys = NULL;
2219       if (!klist)
2220         break; /* no need to dive in deeper */
2221     }
2222
2223  leave:
2224   keydb_release (kdb);
2225   release_key_array (keys);
2226   if (klist != utk_list)
2227     release_key_items (klist);
2228   release_key_hash_table (full_trust);
2229   release_key_hash_table (used);
2230   release_key_hash_table (stored);
2231   if (!rc && !quit) /* mark trustDB as checked */
2232     {
2233       int rc2;
2234
2235       if (next_expire == 0xffffffff || next_expire < start_time )
2236         tdbio_write_nextcheck (ctrl, 0);
2237       else
2238         {
2239           tdbio_write_nextcheck (ctrl, next_expire);
2240           if (!opt.quiet)
2241             log_info (_("next trustdb check due at %s\n"),
2242                       strtimestamp (next_expire));
2243         }
2244
2245       rc2 = tdbio_update_version_record (ctrl);
2246       if (rc2)
2247         {
2248           log_error (_("unable to update trustdb version record: "
2249                        "write failed: %s\n"), gpg_strerror (rc2));
2250           tdbio_invalid ();
2251         }
2252
2253       do_sync ();
2254       pending_check_trustdb = 0;
2255     }
2256
2257   return rc;
2258 }