* trustdb.c (get_validity_info): 'd' for disabled is not a validity value
[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_REVOKED )
1052         return 'r';
1053     c = trust_letter ( (trustlevel & TRUST_MASK) );
1054     if( !c )
1055         c = '?';
1056     return c;
1057 }
1058
1059 static void
1060 get_validity_counts (PKT_public_key *pk, PKT_user_id *uid)
1061 {
1062   TRUSTREC trec, vrec;
1063   ulong recno;
1064   byte namehash[20];
1065
1066   if(pk==NULL || uid==NULL)
1067     BUG();
1068
1069   if( uid->attrib_data )
1070     rmd160_hash_buffer (namehash,uid->attrib_data,uid->attrib_len);
1071   else
1072     rmd160_hash_buffer (namehash, uid->name, uid->len );
1073
1074   uid->help_marginal_count=uid->help_full_count=0;
1075
1076   init_trustdb ();
1077
1078   if(read_trust_record (pk, &trec)!=0)
1079     return;
1080
1081   /* loop over all user IDs */
1082   recno = trec.r.trust.validlist;
1083   while (recno)
1084     {
1085       read_record (recno, &vrec, RECTYPE_VALID);
1086
1087       if(memcmp(vrec.r.valid.namehash,namehash,20)==0)
1088         {
1089           uid->help_marginal_count=vrec.r.valid.marginal_count;
1090           uid->help_full_count=vrec.r.valid.full_count;
1091           /*  printf("Fetched marginal %d, full %d\n",uid->help_marginal_count,uid->help_full_count); */
1092           break;
1093         }
1094
1095       recno = vrec.r.valid.next;
1096     }
1097 }
1098
1099 void
1100 list_trust_path( const char *username )
1101 {
1102 }
1103
1104 /****************
1105  * Enumerate all keys, which are needed to build all trust paths for
1106  * the given key.  This function does not return the key itself or
1107  * the ultimate key (the last point in cerificate chain).  Only
1108  * certificate chains which ends up at an ultimately trusted key
1109  * are listed.  If ownertrust or validity is not NULL, the corresponding
1110  * value for the returned LID is also returned in these variable(s).
1111  *
1112  *  1) create a void pointer and initialize it to NULL
1113  *  2) pass this void pointer by reference to this function.
1114  *     Set lid to the key you want to enumerate and pass it by reference.
1115  *  3) call this function as long as it does not return -1
1116  *     to indicate EOF. LID does contain the next key used to build the web
1117  *  4) Always call this function a last time with LID set to NULL,
1118  *     so that it can free its context.
1119  *
1120  * Returns: -1 on EOF or the level of the returned LID
1121  */
1122 int
1123 enum_cert_paths( void **context, ulong *lid,
1124                  unsigned *ownertrust, unsigned *validity )
1125 {
1126     return -1;
1127 }
1128
1129
1130 /****************
1131  * Print the current path
1132  */
1133 void
1134 enum_cert_paths_print( void **context, FILE *fp,
1135                                        int refresh, ulong selected_lid )
1136 {
1137     return;
1138 }
1139
1140
1141 \f
1142 /****************************************
1143  *********** NEW NEW NEW ****************
1144  ****************************************/
1145
1146 static int
1147 ask_ownertrust (u32 *kid,int minimum)
1148 {
1149   PKT_public_key *pk;
1150   int rc;
1151   int ot;
1152
1153   pk = m_alloc_clear (sizeof *pk);
1154   rc = get_pubkey (pk, kid);
1155   if (rc)
1156     {
1157       log_error (_("public key %08lX not found: %s\n"),
1158                  (ulong)kid[1], g10_errstr(rc) );
1159       return TRUST_UNKNOWN;
1160     }
1161  
1162   if(opt.force_ownertrust)
1163     {
1164       log_info("force trust for key %08lX to %s\n",(ulong)kid[1],
1165                trust_string(opt.force_ownertrust));
1166       update_ownertrust(pk,opt.force_ownertrust);
1167       ot=opt.force_ownertrust;
1168     }
1169   else
1170     {
1171       ot=edit_ownertrust(pk,0);
1172       if(ot>0)
1173         ot = get_ownertrust (pk);
1174       else if(ot==0)
1175         ot = minimum?minimum:TRUST_UNDEFINED;
1176       else
1177         ot = -1; /* quit */
1178     }
1179
1180   free_public_key( pk );
1181
1182   return ot;
1183 }
1184
1185
1186 static void
1187 mark_keyblock_seen (KeyHashTable tbl, KBNODE node)
1188 {
1189   for ( ;node; node = node->next )
1190     if (node->pkt->pkttype == PKT_PUBLIC_KEY
1191         || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1192       {
1193         u32 aki[2];
1194
1195         keyid_from_pk (node->pkt->pkt.public_key, aki);
1196         add_key_hash_table (tbl, aki);
1197       }
1198 }
1199
1200
1201 static void
1202 dump_key_array (int depth, struct key_array *keys)
1203 {
1204   struct key_array *kar;
1205
1206   for (kar=keys; kar->keyblock; kar++)
1207     {
1208       KBNODE node = kar->keyblock;
1209       u32 kid[2];
1210
1211       keyid_from_pk(node->pkt->pkt.public_key, kid);
1212       printf ("%d:%08lX%08lX:K::%c::::\n",
1213               depth, (ulong)kid[0], (ulong)kid[1], '?');
1214
1215       for (; node; node = node->next)
1216         {
1217           if (node->pkt->pkttype == PKT_USER_ID)
1218             {
1219               int len = node->pkt->pkt.user_id->len;
1220
1221               if (len > 30)
1222                 len = 30;
1223               printf ("%d:%08lX%08lX:U:::%c:::",
1224                       depth, (ulong)kid[0], (ulong)kid[1],
1225                       (node->flag & 4)? 'f':
1226                       (node->flag & 2)? 'm':
1227                       (node->flag & 1)? 'q':'-');
1228               print_string (stdout,  node->pkt->pkt.user_id->name, len, ':');
1229               putchar (':');
1230               putchar ('\n');
1231             }
1232         }
1233     }
1234 }  
1235
1236
1237 static void
1238 store_validation_status (int depth, KBNODE keyblock, KeyHashTable stored)
1239 {
1240   KBNODE node;
1241   int status;
1242   int any = 0;
1243
1244   for (node=keyblock; node; node = node->next)
1245     {
1246       if (node->pkt->pkttype == PKT_USER_ID)
1247         {
1248           PKT_user_id *uid = node->pkt->pkt.user_id;
1249           if (node->flag & 4)
1250             status = TRUST_FULLY;
1251           else if (node->flag & 2)
1252             status = TRUST_MARGINAL;
1253           else if (node->flag & 1)
1254             status = TRUST_UNDEFINED;
1255           else
1256             status = 0;
1257           
1258           if (status)
1259             {
1260               update_validity (keyblock->pkt->pkt.public_key,
1261                                uid, depth, status);
1262
1263               mark_keyblock_seen(stored,keyblock);
1264
1265               any = 1;
1266             }
1267         }
1268     }
1269
1270   if (any)
1271     do_sync ();
1272 }  
1273
1274 /*
1275  * check whether the signature sig is in the klist k
1276  */
1277 static struct key_item *
1278 is_in_klist (struct key_item *k, PKT_signature *sig)
1279 {
1280   for (; k; k = k->next)
1281     {
1282       if (k->kid[0] == sig->keyid[0] && k->kid[1] == sig->keyid[1])
1283         return k;
1284     }
1285   return NULL;
1286 }
1287
1288 /*
1289  * Mark the signature of the given UID which are used to certify it.
1290  * To do this, we first revmove all signatures which are not valid and
1291  * from the remain ones we look for the latest one.  If this is not a
1292  * certification revocation signature we mark the signature by setting
1293  * node flag bit 8.  Note that flag bits 9 and 10 are used for internal
1294  * purposes.  
1295  */
1296 static void
1297 mark_usable_uid_certs (KBNODE keyblock, KBNODE uidnode,
1298                        u32 *main_kid, struct key_item *klist,
1299                        u32 curtime, u32 *next_expire)
1300 {
1301   KBNODE node;
1302   PKT_signature *sig;
1303   
1304   /* first check all signatures */
1305   for (node=uidnode->next; node; node = node->next)
1306     {
1307       node->flag &= ~(1<<8 | 1<<9 | 1<<10);
1308       if (node->pkt->pkttype == PKT_USER_ID
1309           || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1310         break; /* ready */
1311       if (node->pkt->pkttype != PKT_SIGNATURE)
1312         continue;
1313       
1314       sig = node->pkt->pkt.signature;
1315       if (sig->keyid[0] == main_kid[0] && sig->keyid[1] == main_kid[1])
1316         continue; /* ignore self-signatures */
1317       if (!IS_UID_SIG(sig) && !IS_UID_REV(sig))
1318         continue; /* we only look at these signature classes */
1319       if (!is_in_klist (klist, sig))
1320         continue;  /* no need to check it then */
1321       if (check_key_signature (keyblock, node, NULL))
1322         continue; /* ignore invalid signatures */
1323       node->flag |= 1<<9;
1324     }      
1325   /* reset the remaining flags */
1326   for (; node; node = node->next)
1327       node->flag &= ~(1<<8 | 1<<9 | 1 << 10);
1328
1329   /* kbnode flag usage: bit 9 is here set for signatures to consider,
1330    * bit 10 will be set by the loop to keep track of keyIDs already
1331    * processed, bit 8 will be set for the usable signatures */
1332
1333   /* for each cert figure out the latest valid one */
1334   for (node=uidnode->next; node; node = node->next)
1335     {
1336       KBNODE n, signode;
1337       u32 kid[2];
1338       u32 sigdate;
1339       
1340       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1341         break;
1342       if ( !(node->flag & (1<<9)) )
1343         continue; /* not a node to look at */
1344       if ( (node->flag & (1<<10)) )
1345         continue; /* signature with a keyID already processed */
1346       node->flag |= (1<<10); /* mark this node as processed */
1347       sig = node->pkt->pkt.signature;
1348       signode = node;
1349       sigdate = sig->timestamp;
1350       kid[0] = sig->keyid[0]; kid[1] = sig->keyid[1];
1351       for (n=uidnode->next; n; n = n->next)
1352         {
1353           if (n->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1354             break;
1355           if ( !(n->flag & (1<<9)) )
1356             continue;
1357           if ( (n->flag & (1<<10)) )
1358             continue; /* shortcut already processed signatures */
1359           sig = n->pkt->pkt.signature;
1360           if (kid[0] != sig->keyid[0] || kid[1] != sig->keyid[1])
1361             continue;
1362           n->flag |= (1<<10); /* mark this node as processed */
1363
1364           /* If signode is nonrevocable and unexpired and n isn't,
1365              then take signode (skip).  It doesn't matter which is
1366              older: if signode was older then we don't want to take n
1367              as signode is nonrevocable.  If n was older then we're
1368              automatically fine. */
1369           
1370           if(((IS_UID_SIG(signode->pkt->pkt.signature) &&
1371                !signode->pkt->pkt.signature->flags.revocable &&
1372                (signode->pkt->pkt.signature->expiredate==0 ||
1373                 signode->pkt->pkt.signature->expiredate>curtime))) &&
1374              (!(IS_UID_SIG(n->pkt->pkt.signature) &&
1375                 !n->pkt->pkt.signature->flags.revocable &&
1376                 (n->pkt->pkt.signature->expiredate==0 ||
1377                  n->pkt->pkt.signature->expiredate>curtime))))
1378             continue;
1379
1380           /* If n is nonrevocable and unexpired and signode isn't,
1381              then take n.  Again, it doesn't matter which is older: if
1382              n was older then we don't want to take signode as n is
1383              nonrevocable.  If signode was older then we're
1384              automatically fine. */
1385           
1386           if((!(IS_UID_SIG(signode->pkt->pkt.signature) &&
1387                 !signode->pkt->pkt.signature->flags.revocable &&
1388                 (signode->pkt->pkt.signature->expiredate==0 ||
1389                  signode->pkt->pkt.signature->expiredate>curtime))) &&
1390              ((IS_UID_SIG(n->pkt->pkt.signature) &&
1391                !n->pkt->pkt.signature->flags.revocable &&
1392                (n->pkt->pkt.signature->expiredate==0 ||
1393                 n->pkt->pkt.signature->expiredate>curtime))))
1394             {
1395               signode = n;
1396               sigdate = sig->timestamp;
1397               continue;
1398             }
1399
1400           /* At this point, if it's newer, it goes in as the only
1401              remaining possibilities are signode and n are both either
1402              revocable or expired or both nonrevocable and unexpired.
1403              If the timestamps are equal take the later ordered
1404              packet, presuming that the key packets are hopefully in
1405              their original order. */
1406
1407           if (sig->timestamp >= sigdate)
1408             {
1409               signode = n;
1410               sigdate = sig->timestamp;
1411             }
1412         }
1413       sig = signode->pkt->pkt.signature;
1414       if (IS_UID_SIG (sig))
1415         { /* this seems to be a usable one which is not revoked. 
1416            * Just need to check whether there is an expiration time,
1417            * We do the expired certification after finding a suitable
1418            * certification, the assumption is that a signator does not
1419            * want that after the expiration of his certificate the
1420            * system falls back to an older certification which has a
1421            * different expiration time */
1422           const byte *p;
1423           u32 expire;
1424                     
1425           p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_SIG_EXPIRE, NULL );
1426           expire = p? sig->timestamp + buffer_to_u32(p) : 0;
1427
1428           if (expire==0 || expire > curtime )
1429             {
1430               signode->flag |= (1<<8); /* yeah, found a good cert */
1431               if (expire && expire < *next_expire)
1432                 *next_expire = expire;
1433             }
1434         }
1435     }
1436 }
1437
1438 /* Used by validate_one_keyblock to confirm a regexp within a trust
1439    signature.  Returns 1 for match, and 0 for no match or regex
1440    error. */
1441 static int
1442 check_regexp(const char *exp,const char *string)
1443 {
1444 #ifdef DISABLE_REGEXP
1445   /* When DISABLE_REGEXP is defined, assume all regexps do not
1446      match. */
1447   return 0;
1448 #elif defined(__riscos__)
1449   return riscos_check_regexp(exp, string, DBG_TRUST);
1450 #else
1451   int ret;
1452   regex_t pat;
1453
1454   if(regcomp(&pat,exp,REG_ICASE|REG_NOSUB|REG_EXTENDED)!=0)
1455     return 0;
1456
1457   ret=regexec(&pat,string,0,NULL,0);
1458
1459   regfree(&pat);
1460
1461   if(DBG_TRUST)
1462     log_debug("regexp \"%s\" on \"%s\": %s\n",exp,string,ret==0?"YES":"NO");
1463
1464   return (ret==0);
1465 #endif
1466 }
1467
1468 /*
1469  * Return true if the key is signed by one of the keys in the given
1470  * key ID list.  User IDs with a valid signature are marked by node
1471  * flags as follows:
1472  *  flag bit 0: There is at least one signature
1473  *           1: There is marginal confidence that this is a legitimate uid
1474  *           2: There is full confidence that this is a legitimate uid.
1475  *           8: Used for internal purposes.
1476  *           9: Ditto (in mark_usable_uid_certs())
1477  *          10: Ditto (ditto)
1478  * This function assumes that all kbnode flags are cleared on entry.
1479  */
1480 static int
1481 validate_one_keyblock (KBNODE kb, struct key_item *klist,
1482                        u32 curtime, u32 *next_expire)
1483 {
1484   struct key_item *kr;
1485   KBNODE node, uidnode=NULL;
1486   PKT_user_id *uid=NULL;
1487   PKT_public_key *pk = kb->pkt->pkt.public_key;
1488   u32 main_kid[2];
1489   int issigned=0, any_signed = 0;
1490
1491   keyid_from_pk(pk, main_kid);
1492   for (node=kb; node; node = node->next)
1493     {
1494       if (node->pkt->pkttype == PKT_USER_ID)
1495         {
1496           if (uidnode && issigned)
1497             {
1498               if (uid->help_full_count >= opt.completes_needed
1499                   || uid->help_marginal_count >= opt.marginals_needed )
1500                 uidnode->flag |= 4; 
1501               else if (uid->help_full_count || uid->help_marginal_count)
1502                 uidnode->flag |= 2;
1503               uidnode->flag |= 1;
1504               any_signed = 1;
1505             }
1506           uidnode = node;
1507           uid=uidnode->pkt->pkt.user_id;
1508           issigned = 0;
1509           get_validity_counts(pk,uid);
1510           mark_usable_uid_certs (kb, uidnode, main_kid, klist, 
1511                                  curtime, next_expire);
1512         }
1513       else if (node->pkt->pkttype == PKT_SIGNATURE 
1514                && (node->flag & (1<<8)) && uid)
1515         {
1516           /* Note that we are only seeing unrevoked sigs here */
1517           PKT_signature *sig = node->pkt->pkt.signature;
1518           
1519           kr = is_in_klist (klist, sig);
1520           /* If the trust_regexp does not match, it's as if the sig
1521              did not exist.  This is safe for non-trust sigs as well
1522              since we don't accept a regexp on the sig unless it's a
1523              trust sig. */
1524           if (kr && (kr->trust_regexp==NULL || opt.trust_model!=TM_OPENPGP ||
1525                      (uidnode && check_regexp(kr->trust_regexp,
1526                                             uidnode->pkt->pkt.user_id->name))))
1527             {
1528               if(DBG_TRUST && opt.trust_model==TM_OPENPGP && sig->trust_depth)
1529                 log_debug("trust sig on %s, sig depth is %d, kr depth is %d\n",
1530                           uidnode->pkt->pkt.user_id->name,sig->trust_depth,
1531                           kr->trust_depth);
1532
1533               /* Are we part of a trust sig chain?  We always favor
1534                  the latest trust sig, rather than the greater or
1535                  lesser trust sig or value.  I could make a decent
1536                  argument for any of these cases, but this seems to be
1537                  what PGP does, and I'd like to be compatible. -dms */
1538               if(opt.trust_model==TM_OPENPGP && sig->trust_depth
1539                  && pk->trust_timestamp<=sig->timestamp
1540                  && (sig->trust_depth<=kr->trust_depth
1541                      || kr->ownertrust==TRUST_ULTIMATE))
1542                 {
1543                   /* If we got here, we know that:
1544
1545                      this is a trust sig.
1546
1547                      it's a newer trust sig than any previous trust
1548                      sig on this key (not uid).
1549
1550                      it is legal in that it was either generated by an
1551                      ultimate key, or a key that was part of a trust
1552                      chain, and the depth does not violate the
1553                      original trust sig.
1554
1555                      if there is a regexp attached, it matched
1556                      successfully.
1557                   */
1558
1559                   if(DBG_TRUST)
1560                     log_debug("replacing trust value %d with %d and "
1561                               "depth %d with %d\n",
1562                               pk->trust_value,sig->trust_value,
1563                               pk->trust_depth,sig->trust_depth);
1564
1565                   pk->trust_value=sig->trust_value;
1566                   pk->trust_depth=sig->trust_depth-1;
1567
1568                   /* If the trust sig contains a regexp, record it
1569                      on the pk for the next round. */
1570                   if(sig->trust_regexp)
1571                     pk->trust_regexp=sig->trust_regexp;
1572                 }
1573
1574               if (kr->ownertrust == TRUST_ULTIMATE)
1575                 uid->help_full_count = opt.completes_needed;
1576               else if (kr->ownertrust == TRUST_FULLY)
1577                 uid->help_full_count++;
1578               else if (kr->ownertrust == TRUST_MARGINAL)
1579                 uid->help_marginal_count++;
1580               issigned = 1;
1581             }
1582         }
1583     }
1584
1585   if (uidnode && issigned)
1586     {
1587       if (uid->help_full_count >= opt.completes_needed
1588           || uid->help_marginal_count >= opt.marginals_needed )
1589         uidnode->flag |= 4; 
1590       else if (uid->help_full_count || uid->help_marginal_count)
1591         uidnode->flag |= 2;
1592       uidnode->flag |= 1;
1593       any_signed = 1;
1594     }
1595
1596   return any_signed;
1597 }
1598
1599
1600 static int
1601 search_skipfnc (void *opaque, u32 *kid)
1602 {
1603   return test_key_hash_table ((KeyHashTable)opaque, kid);
1604 }
1605
1606
1607 /*
1608  * Scan all keys and return a key_array of all suitable keys from
1609  * kllist.  The caller has to pass keydb handle so that we don't use
1610  * to create our own.  Returns either a key_array or NULL in case of
1611  * an error.  No results found are indicated by an empty array.
1612  * Caller hast to release the returned array.  
1613  */
1614 static struct key_array *
1615 validate_key_list (KEYDB_HANDLE hd, KeyHashTable full_trust,
1616                    struct key_item *klist, u32 curtime, u32 *next_expire)
1617 {
1618   KBNODE keyblock = NULL;
1619   struct key_array *keys = NULL;
1620   size_t nkeys, maxkeys;
1621   int rc;
1622   KEYDB_SEARCH_DESC desc;
1623   
1624   maxkeys = 1000;
1625   keys = m_alloc ((maxkeys+1) * sizeof *keys);
1626   nkeys = 0;
1627   
1628   rc = keydb_search_reset (hd);
1629   if (rc)
1630     {
1631       log_error ("keydb_search_reset failed: %s\n", g10_errstr(rc));
1632       m_free (keys);
1633       return NULL;
1634     }
1635
1636   memset (&desc, 0, sizeof desc);
1637   desc.mode = KEYDB_SEARCH_MODE_FIRST;
1638   desc.skipfnc = search_skipfnc;
1639   desc.skipfncvalue = full_trust;
1640   rc = keydb_search (hd, &desc, 1);
1641   if (rc == -1)
1642     {
1643       keys[nkeys].keyblock = NULL;
1644       return keys;
1645     }
1646   if (rc)
1647     {
1648       log_error ("keydb_search_first failed: %s\n", g10_errstr(rc));
1649       m_free (keys);
1650       return NULL;
1651     }
1652   
1653   desc.mode = KEYDB_SEARCH_MODE_NEXT; /* change mode */
1654   do
1655     {
1656       PKT_public_key *pk;
1657         
1658       rc = keydb_get_keyblock (hd, &keyblock);
1659       if (rc) 
1660         {
1661           log_error ("keydb_get_keyblock failed: %s\n", g10_errstr(rc));
1662           m_free (keys);
1663           return NULL;
1664         }
1665       
1666       if ( keyblock->pkt->pkttype != PKT_PUBLIC_KEY) 
1667         {
1668           log_debug ("ooops: invalid pkttype %d encountered\n",
1669                      keyblock->pkt->pkttype);
1670           dump_kbnode (keyblock);
1671           release_kbnode(keyblock);
1672           continue;
1673         }
1674
1675       /* prepare the keyblock for further processing */
1676       merge_keys_and_selfsig (keyblock); 
1677       clear_kbnode_flags (keyblock);
1678       pk = keyblock->pkt->pkt.public_key;
1679       if (pk->has_expired || pk->is_revoked)
1680         {
1681           /* it does not make sense to look further at those keys */
1682           mark_keyblock_seen (full_trust, keyblock);
1683         }
1684       else if (validate_one_keyblock (keyblock, klist, curtime, next_expire))
1685         {
1686           KBNODE node;
1687
1688           if (pk->expiredate && pk->expiredate >= curtime
1689               && pk->expiredate < *next_expire)
1690             *next_expire = pk->expiredate;
1691
1692           if (nkeys == maxkeys) {
1693             maxkeys += 1000;
1694             keys = m_realloc (keys, (maxkeys+1) * sizeof *keys);
1695           }
1696           keys[nkeys++].keyblock = keyblock;
1697
1698           /* Optimization - if all uids are fully trusted, then we
1699              never need to consider this key as a candidate again. */
1700
1701           for (node=keyblock; node; node = node->next)
1702             if (node->pkt->pkttype == PKT_USER_ID && !(node->flag & 4))
1703               break;
1704
1705           if(node==NULL)
1706             mark_keyblock_seen (full_trust, keyblock);
1707
1708           keyblock = NULL;
1709         }
1710
1711       release_kbnode (keyblock);
1712       keyblock = NULL;
1713     } 
1714   while ( !(rc = keydb_search (hd, &desc, 1)) );
1715   if (rc && rc != -1) 
1716     {
1717       log_error ("keydb_search_next failed: %s\n", g10_errstr(rc));
1718       m_free (keys);
1719       return NULL;
1720     }
1721
1722   keys[nkeys].keyblock = NULL;
1723   return keys;
1724
1725
1726 /* Caller must sync */
1727 static void
1728 reset_trust_records (KEYDB_HANDLE hd, KeyHashTable exclude)
1729 {
1730   int rc;
1731   KBNODE keyblock = NULL;
1732   KEYDB_SEARCH_DESC desc;
1733   int count = 0, nreset = 0;
1734   
1735   rc = keydb_search_reset (hd);
1736   if (rc)
1737     {
1738       log_error ("keydb_search_reset failed: %s\n", g10_errstr(rc));
1739       return;
1740     }
1741
1742   memset (&desc, 0, sizeof desc);
1743   desc.mode = KEYDB_SEARCH_MODE_FIRST;
1744   if(exclude)
1745     {
1746       desc.skipfnc = search_skipfnc;
1747       desc.skipfncvalue = exclude;
1748     }
1749   rc = keydb_search (hd, &desc, 1);
1750   if (rc && rc != -1 )
1751     log_error ("keydb_search_first failed: %s\n", g10_errstr(rc));
1752   else if (!rc)
1753     {
1754       desc.mode = KEYDB_SEARCH_MODE_NEXT; /* change mode */
1755       do
1756         {
1757           rc = keydb_get_keyblock (hd, &keyblock);
1758           if (rc) 
1759             {
1760               log_error ("keydb_get_keyblock failed: %s\n", g10_errstr(rc));
1761               break;
1762             }
1763           count++;
1764
1765           if (keyblock->pkt->pkttype == PKT_PUBLIC_KEY) /* paranoid assertion*/
1766             {
1767               nreset += clear_validity (keyblock->pkt->pkt.public_key);
1768               release_kbnode (keyblock);
1769             } 
1770         }
1771       while ( !(rc = keydb_search (hd, &desc, 1)) );
1772       if (rc && rc != -1) 
1773         log_error ("keydb_search_next failed: %s\n", g10_errstr(rc));
1774     }
1775   if (opt.verbose)
1776     log_info ("%d keys processed (%d validity counts cleared)\n",
1777               count, nreset);
1778 }
1779
1780 /*
1781  * Run the key validation procedure.
1782  *
1783  * This works this way:
1784  * Step 1: Find all ultimately trusted keys (UTK).
1785  *         mark them all as seen and put them into klist.
1786  * Step 2: loop max_cert_times
1787  * Step 3:   if OWNERTRUST of any key in klist is undefined
1788  *             ask user to assign ownertrust
1789  * Step 4:   Loop over all keys in the keyDB which are not marked seen 
1790  * Step 5:     if key is revoked or expired
1791  *                mark key as seen
1792  *                continue loop at Step 4
1793  * Step 6:     For each user ID of that key signed by a key in klist
1794  *                Calculate validity by counting trusted signatures.
1795  *                Set validity of user ID
1796  * Step 7:     If any signed user ID was found
1797  *                mark key as seen
1798  *             End Loop
1799  * Step 8:   Build a new klist from all fully trusted keys from step 6
1800  *           End Loop
1801  *         Ready  
1802  *
1803  */
1804 static int
1805 validate_keys (int interactive)
1806 {
1807   int rc = 0;
1808   int quit=0;
1809   struct key_item *klist = NULL;
1810   struct key_item *k;
1811   struct key_array *keys = NULL;
1812   struct key_array *kar;
1813   KEYDB_HANDLE kdb = NULL;
1814   KBNODE node;
1815   int depth;
1816   int key_count;
1817   int ot_unknown, ot_undefined, ot_never, ot_marginal, ot_full, ot_ultimate;
1818   KeyHashTable stored,used,full_trust;
1819   u32 start_time, next_expire;
1820
1821   start_time = make_timestamp ();
1822   next_expire = 0xffffffff; /* set next expire to the year 2106 */
1823   stored = new_key_hash_table ();
1824   used = new_key_hash_table ();
1825   full_trust = new_key_hash_table ();
1826   /* Fixme: Instead of always building a UTK list, we could just build it
1827    * here when needed */
1828   if (!utk_list)
1829     {
1830       log_info ("no ultimately trusted keys found\n");
1831       goto leave;
1832     }
1833
1834   kdb = keydb_new (0);
1835
1836   reset_trust_records (kdb,NULL);
1837
1838   /* mark all UTKs as used and fully_trusted and set validity to
1839      ultimate */
1840   for (k=utk_list; k; k = k->next)
1841     {
1842       KBNODE keyblock;
1843       PKT_public_key *pk;
1844
1845       keyblock = get_pubkeyblock (k->kid);
1846       if (!keyblock)
1847         {
1848           log_error (_("public key of ultimately"
1849                        " trusted key %08lX not found\n"), (ulong)k->kid[1]);
1850           continue;
1851         }
1852       mark_keyblock_seen (used, keyblock);
1853       mark_keyblock_seen (stored, keyblock);
1854       mark_keyblock_seen (full_trust, keyblock);
1855       pk = keyblock->pkt->pkt.public_key;
1856       for (node=keyblock; node; node = node->next)
1857         {
1858           if (node->pkt->pkttype == PKT_USER_ID)
1859             update_validity (pk, node->pkt->pkt.user_id, 0, TRUST_ULTIMATE);
1860         }
1861       if ( pk->expiredate && pk->expiredate >= start_time
1862            && pk->expiredate < next_expire)
1863         next_expire = pk->expiredate;
1864       
1865       release_kbnode (keyblock);
1866       do_sync ();
1867     }
1868
1869   klist = utk_list;
1870
1871   log_info(_("%d marginal(s) needed, %d complete(s) needed, %s trust model\n"),
1872            opt.marginals_needed,opt.completes_needed,
1873            opt.trust_model==TM_CLASSIC?"Classic":
1874                           opt.trust_model==TM_OPENPGP?"OpenPGP":"unknown");
1875
1876   for (depth=0; depth < opt.max_cert_depth; depth++)
1877     {
1878       /* See whether we should assign ownertrust values to the keys in
1879          utk_list.  */
1880       ot_unknown = ot_undefined = ot_never = 0;
1881       ot_marginal = ot_full = ot_ultimate = 0;
1882       for (k=klist; k; k = k->next)
1883         {
1884           int min=0;
1885
1886           /* 120 and 60 are as per RFC2440 */
1887           if(k->trust_value>=120)
1888             min=TRUST_FULLY;
1889           else if(k->trust_value>=60)
1890             min=TRUST_MARGINAL;
1891
1892           if(min!=k->min_ownertrust)
1893             update_min_ownertrust(k->kid,min);
1894
1895           if (interactive && k->ownertrust == TRUST_UNKNOWN)
1896             {
1897               k->ownertrust = ask_ownertrust (k->kid,min);
1898
1899               if (k->ownertrust == -1)
1900                 {
1901                   quit=1;
1902                   goto leave;
1903                 }
1904             }
1905
1906           /* This can happen during transition from an old trustdb
1907              before trust sigs.  It can also happen if a user uses two
1908              different versions of GnuPG or changes the --trust-model
1909              setting. */
1910           if(k->ownertrust<min)
1911             {
1912               if(DBG_TRUST)
1913                 log_debug("key %08lX: "
1914                           "overriding ownertrust \"%s\" with \"%s\"\n",
1915                           (ulong)k->kid[1],
1916                           trust_string(k->ownertrust),trust_string(min));
1917
1918               k->ownertrust=min;
1919             }
1920
1921           if (k->ownertrust == TRUST_UNKNOWN)
1922             ot_unknown++;
1923           else if (k->ownertrust == TRUST_UNDEFINED)
1924             ot_undefined++;
1925           else if (k->ownertrust == TRUST_NEVER)
1926             ot_never++;
1927           else if (k->ownertrust == TRUST_MARGINAL)
1928             ot_marginal++;
1929           else if (k->ownertrust == TRUST_FULLY)
1930             ot_full++;
1931           else if (k->ownertrust == TRUST_ULTIMATE)
1932             ot_ultimate++;
1933         }
1934
1935       /* Find all keys which are signed by a key in kdlist */
1936       keys = validate_key_list (kdb, full_trust, klist,
1937                                 start_time, &next_expire);
1938       if (!keys) 
1939         {
1940           log_error ("validate_key_list failed\n");
1941           rc = G10ERR_GENERAL;
1942           goto leave;
1943         }
1944
1945       for (key_count=0, kar=keys; kar->keyblock; kar++, key_count++)
1946         ;
1947
1948       /* Store the calculated valididation status somewhere */
1949       if (opt.verbose > 1)
1950         dump_key_array (depth, keys);
1951
1952       for (kar=keys; kar->keyblock; kar++)
1953           store_validation_status (depth, kar->keyblock, stored);
1954
1955       log_info (_("checking at depth %d valid=%d"
1956                   " ot(-/q/n/m/f/u)=%d/%d/%d/%d/%d/%d\n"), 
1957                 depth, key_count, ot_unknown, ot_undefined,
1958                 ot_never, ot_marginal, ot_full, ot_ultimate ); 
1959
1960       /* Build a new kdlist from all fully valid keys in KEYS */
1961       if (klist != utk_list)
1962         release_key_items (klist);
1963       klist = NULL;
1964       for (kar=keys; kar->keyblock; kar++)
1965         {
1966           for (node=kar->keyblock; node; node = node->next)
1967             {
1968               if (node->pkt->pkttype == PKT_USER_ID && (node->flag & 4))
1969                 {
1970                   u32 kid[2];
1971
1972                   /* have we used this key already? */
1973                   keyid_from_pk (kar->keyblock->pkt->pkt.public_key, kid);
1974                   if(test_key_hash_table(used,kid)==0)
1975                     {
1976                       /* Normally we add both the primary and subkey
1977                          ids to the hash via mark_keyblock_seen, but
1978                          since we aren't using this hash as a skipfnc,
1979                          that doesn't matter here. */
1980                       add_key_hash_table (used,kid);
1981                       k = new_key_item ();
1982                       k->kid[0]=kid[0];
1983                       k->kid[1]=kid[1];
1984                       k->ownertrust =
1985                         get_ownertrust (kar->keyblock->pkt->pkt.public_key);
1986                       k->min_ownertrust =
1987                         get_min_ownertrust(kar->keyblock->pkt->pkt.public_key);
1988                       k->trust_depth=
1989                         kar->keyblock->pkt->pkt.public_key->trust_depth;
1990                       k->trust_value=
1991                         kar->keyblock->pkt->pkt.public_key->trust_value;
1992                       if(kar->keyblock->pkt->pkt.public_key->trust_regexp)
1993                         k->trust_regexp=
1994                           m_strdup(kar->keyblock->pkt->
1995                                    pkt.public_key->trust_regexp);
1996                       k->next = klist;
1997                       klist = k;
1998                       break;
1999                     }
2000                 }
2001             }
2002         }
2003       release_key_array (keys);
2004       keys = NULL;
2005       if (!klist)
2006         break; /* no need to dive in deeper */
2007     }
2008
2009  leave:
2010   keydb_release (kdb);
2011   release_key_array (keys);
2012   release_key_items (klist);
2013   release_key_hash_table (full_trust);
2014   release_key_hash_table (used);
2015   release_key_hash_table (stored);
2016   if (!rc && !quit) /* mark trustDB as checked */
2017     {
2018       if (next_expire == 0xffffffff || next_expire < start_time )
2019         tdbio_write_nextcheck (0); 
2020       else
2021         {
2022           tdbio_write_nextcheck (next_expire); 
2023           log_info (_("next trustdb check due at %s\n"),
2024                     strtimestamp (next_expire));
2025         }
2026
2027       if(tdbio_update_version_record()!=0)
2028         {
2029           log_error(_("unable to update trustdb version record: "
2030                       "write failed: %s\n"), g10_errstr(rc));
2031           tdbio_invalid();
2032         }
2033
2034       do_sync ();
2035       pending_check_trustdb = 0;
2036     }
2037   return rc;
2038 }