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