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