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