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