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