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