* trustdb.c (validate_keys): Show trust parameters when building trustdb,
[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   /* the --trusted-key option is again deprecated; however we automagically
292    * add those keys to 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     pending_check_trustdb=1;
430 }
431
432
433
434 \f
435 /***********************************************
436  *************  Print helpers   ****************
437  ***********************************************/
438
439 /****************
440  * This function returns a letter for a trustvalue  Trust flags
441  * are ignore.
442  */
443 int
444 trust_letter (unsigned int value)
445 {
446   switch( (value & TRUST_MASK) ) 
447     {
448     case TRUST_UNKNOWN:   return '-';
449     case TRUST_EXPIRED:   return 'e';
450     case TRUST_UNDEFINED: return 'q';
451     case TRUST_NEVER:     return 'n';
452     case TRUST_MARGINAL:  return 'm';
453     case TRUST_FULLY:     return 'f';
454     case TRUST_ULTIMATE:  return 'u';
455     default:              return 0;
456     }
457 }
458
459 /* The strings here are similar to those in
460    pkclist.c:do_edit_ownertrust() */
461 const char *
462 trust_string (unsigned int value)
463 {
464   switch( (value & TRUST_MASK) ) 
465     {
466     case TRUST_UNKNOWN:   return _("unknown trust");
467     case TRUST_EXPIRED:   return _("expired");
468     case TRUST_UNDEFINED: return _("undefined trust");
469     case TRUST_NEVER:     return _("do NOT trust");
470     case TRUST_MARGINAL:  return _("marginal trust");
471     case TRUST_FULLY:     return _("full trust");
472     case TRUST_ULTIMATE:  return _("ultimate trust");
473     default:              return "err";
474     }
475 }
476
477 static const char *
478 trust_model_string(void)
479 {
480   switch(opt.trust_model)
481     {
482     case TM_OPENPGP: return "OpenPGP";
483     case TM_CLASSIC: return "classic";
484     case TM_ALWAYS:  return "always";
485     default:         return "unknown";
486     }
487 }
488
489 /****************
490  * Recreate the WoT but do not ask for new ownertrusts.  Special
491  * feature: In batch mode and without a forced yes, this is only done
492  * when a check is due.  This can be used to run the check from a crontab
493  */
494 void
495 check_trustdb ()
496 {
497   if(opt.trust_model==TM_OPENPGP || opt.trust_model==TM_CLASSIC)
498     {
499       init_trustdb();
500       if (opt.batch && !opt.answer_yes)
501         {
502           ulong scheduled;
503
504           scheduled = tdbio_read_nextcheck ();
505           if (!scheduled)
506             {
507               log_info (_("no need for a trustdb check\n"));
508               return;
509             }
510
511           if (scheduled > make_timestamp ())
512             {
513               log_info (_("next trustdb check due at %s\n"),
514                         strtimestamp (scheduled));
515               return;
516             }
517         }
518
519       validate_keys (0);
520     }
521   else
522     log_info (_("no need for a trustdb check with \"%s\" trust model\n"),
523               trust_model_string());
524 }
525
526
527 /*
528  * Recreate the WoT. 
529  */
530 void
531 update_trustdb()
532 {
533   if(opt.trust_model==TM_OPENPGP || opt.trust_model==TM_CLASSIC)
534     {
535       init_trustdb();
536       validate_keys (1);
537     }
538   else
539     log_info (_("no need for a trustdb update with \"%s\" trust model\n"),
540               trust_model_string());
541 }
542
543 void
544 revalidation_mark (void)
545 {
546   init_trustdb();
547   /* we simply set the time for the next check to 1 (far back in 1970)
548    * so that a --update-trustdb will be scheduled */
549   if (tdbio_write_nextcheck (1))
550       do_sync ();
551   pending_check_trustdb = 1;
552 }
553
554 \f
555 /***********************************************
556  ***********  Ownertrust et al. ****************
557  ***********************************************/
558
559 static int 
560 read_trust_record (PKT_public_key *pk, TRUSTREC *rec)
561 {
562   int rc;
563   
564   init_trustdb();
565   rc = tdbio_search_trust_bypk (pk, rec);
566   if (rc == -1)
567     return -1; /* no record yet */
568   if (rc) 
569     {
570       log_error ("trustdb: searching trust record failed: %s\n",
571                  g10_errstr (rc));
572       return rc; 
573     }
574       
575   if (rec->rectype != RECTYPE_TRUST)
576     {
577       log_error ("trustdb: record %lu is not a trust record\n",
578                  rec->recnum);
579       return G10ERR_TRUSTDB; 
580     }      
581   
582   return 0;
583 }
584
585 /****************
586  * Return the assigned ownertrust value for the given public key.
587  * The key should be the primary key.
588  */
589 unsigned int 
590 get_ownertrust ( PKT_public_key *pk)
591 {
592   TRUSTREC rec;
593   int rc;
594   
595   rc = read_trust_record (pk, &rec);
596   if (rc == -1)
597     return TRUST_UNKNOWN; /* no record yet */
598   if (rc) 
599     {
600       tdbio_invalid ();
601       return rc; /* actually never reached */
602     }
603
604   return rec.r.trust.ownertrust;
605 }
606
607 unsigned int 
608 get_min_ownertrust (PKT_public_key *pk)
609 {
610   TRUSTREC rec;
611   int rc;
612   
613   rc = read_trust_record (pk, &rec);
614   if (rc == -1)
615     return TRUST_UNKNOWN; /* no record yet */
616   if (rc) 
617     {
618       tdbio_invalid ();
619       return rc; /* actually never reached */
620     }
621
622   return rec.r.trust.min_ownertrust;
623 }
624
625 /*
626  * Same as get_ownertrust but return a trust letter instead of an value.
627  */
628 int
629 get_ownertrust_info (PKT_public_key *pk)
630 {
631     unsigned int otrust,otrust_min;
632     int c;
633
634     otrust = get_ownertrust (pk);
635     otrust_min = get_min_ownertrust (pk);
636     if(otrust<otrust_min)
637       {
638         /* If the trust that the user has set is less than the trust
639            that was calculated from a trust signature chain, use the
640            higher of the two.  We do this here and not in
641            get_ownertrust since the underlying ownertrust should not
642            really be set - just the appearance of the ownertrust. */
643
644         otrust=otrust_min;
645       }
646
647     c = trust_letter( (otrust & TRUST_MASK) );
648     if( !c )
649         c = '?';
650     return c;
651 }
652
653 /*
654  * Set the trust value of the given public key to the new value.
655  * The key should be a primary one.
656  */
657 void
658 update_ownertrust (PKT_public_key *pk, unsigned int new_trust )
659 {
660   TRUSTREC rec;
661   int rc;
662   
663   rc = read_trust_record (pk, &rec);
664   if (!rc)
665     {
666       if (DBG_TRUST)
667         log_debug ("update ownertrust from %u to %u\n",
668                    (unsigned int)rec.r.trust.ownertrust, new_trust );
669       if (rec.r.trust.ownertrust != new_trust)
670         {
671           rec.r.trust.ownertrust = new_trust;
672           write_record( &rec );
673           revalidation_mark ();
674           do_sync ();
675         }
676     }
677   else if (rc == -1)
678     { /* no record yet - create a new one */
679       size_t dummy;
680
681       if (DBG_TRUST)
682         log_debug ("insert ownertrust %u\n", new_trust );
683
684       memset (&rec, 0, sizeof rec);
685       rec.recnum = tdbio_new_recnum ();
686       rec.rectype = RECTYPE_TRUST;
687       fingerprint_from_pk (pk, rec.r.trust.fingerprint, &dummy);
688       rec.r.trust.ownertrust = new_trust;
689       write_record (&rec);
690       revalidation_mark ();
691       do_sync ();
692       rc = 0;
693     }
694   else 
695     {
696       tdbio_invalid ();
697     }
698 }
699
700 static void
701 update_min_ownertrust (u32 *kid, unsigned int new_trust )
702 {
703   PKT_public_key *pk;
704   TRUSTREC rec;
705   int rc;
706
707   pk = m_alloc_clear (sizeof *pk);
708   rc = get_pubkey (pk, kid);
709   if (rc)
710     {
711       log_error (_("public key %08lX not found: %s\n"),
712                  (ulong)kid[1], g10_errstr(rc) );
713       return;
714     }
715
716   rc = read_trust_record (pk, &rec);
717   if (!rc)
718     {
719       if (DBG_TRUST)
720         log_debug ("key %08lX: update min_ownertrust from %u to %u\n",
721                    (ulong)kid[1],(unsigned int)rec.r.trust.min_ownertrust,
722                    new_trust );
723       if (rec.r.trust.min_ownertrust != new_trust)
724         {
725           rec.r.trust.min_ownertrust = new_trust;
726           write_record( &rec );
727           revalidation_mark ();
728           do_sync ();
729         }
730     }
731   else if (rc == -1)
732     { /* no record yet - create a new one */
733       size_t dummy;
734
735       if (DBG_TRUST)
736         log_debug ("insert min_ownertrust %u\n", new_trust );
737
738       memset (&rec, 0, sizeof rec);
739       rec.recnum = tdbio_new_recnum ();
740       rec.rectype = RECTYPE_TRUST;
741       fingerprint_from_pk (pk, rec.r.trust.fingerprint, &dummy);
742       rec.r.trust.min_ownertrust = new_trust;
743       write_record (&rec);
744       revalidation_mark ();
745       do_sync ();
746       rc = 0;
747     }
748   else 
749     {
750       tdbio_invalid ();
751     }
752 }
753
754 /* Clear the ownertrust and min_ownertrust values.  Return true if a
755    change actually happened. */
756 int
757 clear_ownertrusts (PKT_public_key *pk)
758 {
759   TRUSTREC rec;
760   int rc;
761   
762   rc = read_trust_record (pk, &rec);
763   if (!rc)
764     {
765       if (DBG_TRUST)
766         {
767           log_debug ("clearing ownertrust (old value %u)\n",
768                      (unsigned int)rec.r.trust.ownertrust);
769           log_debug ("clearing min_ownertrust (old value %u)\n",
770                      (unsigned int)rec.r.trust.min_ownertrust);
771         }
772       if (rec.r.trust.ownertrust || rec.r.trust.min_ownertrust)
773         {
774           rec.r.trust.ownertrust = 0;
775           rec.r.trust.min_ownertrust = 0;
776           write_record( &rec );
777           revalidation_mark ();
778           do_sync ();
779           return 1;
780         }
781     }
782   else if (rc != -1)
783     {
784       tdbio_invalid ();
785     }
786   return 0;
787 }
788
789 /* 
790  * Note: Caller has to do a sync 
791  */
792 static void
793 update_validity (PKT_public_key *pk, const byte *namehash,
794                  int depth, int validity)
795 {
796   TRUSTREC trec, vrec;
797   int rc;
798   ulong recno;
799   
800   rc = read_trust_record (pk, &trec);
801   if (rc && rc != -1)
802     {
803       tdbio_invalid ();
804       return;
805     }
806   if (rc == -1) /* no record yet - create a new one */
807     { 
808       size_t dummy;
809
810       rc = 0;
811       memset (&trec, 0, sizeof trec);
812       trec.recnum = tdbio_new_recnum ();
813       trec.rectype = RECTYPE_TRUST;
814       fingerprint_from_pk (pk, trec.r.trust.fingerprint, &dummy);
815       trec.r.trust.ownertrust = 0;
816       }
817
818   /* locate an existing one */
819   recno = trec.r.trust.validlist;
820   while (recno)
821     {
822       read_record (recno, &vrec, RECTYPE_VALID);
823       if ( !memcmp (vrec.r.valid.namehash, namehash, 20) )
824         break;
825       recno = vrec.r.valid.next;
826     }
827
828   if (!recno) /* insert a new validity record */
829     {
830       memset (&vrec, 0, sizeof vrec);
831       vrec.recnum = tdbio_new_recnum ();
832       vrec.rectype = RECTYPE_VALID;
833       memcpy (vrec.r.valid.namehash, namehash, 20);
834       vrec.r.valid.next = trec.r.trust.validlist;
835     }
836   vrec.r.valid.validity = validity;
837   write_record (&vrec);
838   trec.r.trust.depth = depth;
839   trec.r.trust.validlist = vrec.recnum;
840   write_record (&trec);
841 }
842
843
844 /* reset validity for all user IDs.  Caller must sync. */
845 static int
846 clear_validity (PKT_public_key *pk)
847 {
848   TRUSTREC trec, vrec;
849   int rc;
850   ulong recno;
851   int any = 0;
852   
853   rc = read_trust_record (pk, &trec);
854   if (rc && rc != -1)
855     {
856       tdbio_invalid ();
857       return 0;
858     }
859   if (rc == -1) /* no record yet - no need to clear it then ;-) */
860     return 0;
861
862   /* Clear minimum ownertrust, if any */
863   if(trec.r.trust.min_ownertrust)
864     {
865       trec.r.trust.min_ownertrust=0;
866       write_record(&trec);
867     }
868
869   /* reset validity for all user IDs */
870   recno = trec.r.trust.validlist;
871   while (recno)
872     {
873       read_record (recno, &vrec, RECTYPE_VALID);
874       if ((vrec.r.valid.validity & TRUST_MASK))
875         {
876           vrec.r.valid.validity &= ~TRUST_MASK;
877           write_record (&vrec);
878           any = 1;
879         }
880       recno = vrec.r.valid.next;
881     }
882
883   return any;
884 }
885
886 /***********************************************
887  *********  Query trustdb values  **************
888  ***********************************************/
889
890 /*
891  * Return the validity information for PK.  If the namehash is not
892  * NULL, the validity of the corresponsing user ID is returned,
893  * otherwise, a reasonable value for the entire key is returned. 
894  */
895 unsigned int
896 get_validity (PKT_public_key *pk, const byte *namehash)
897 {
898   static int did_nextcheck;
899   TRUSTREC trec, vrec;
900   int rc;
901   ulong recno;
902   unsigned int validity;
903   u32 kid[2];
904   PKT_public_key *main_pk;
905
906   init_trustdb ();
907   if (!did_nextcheck)
908     {
909       ulong scheduled;
910
911       did_nextcheck = 1;
912       scheduled = tdbio_read_nextcheck ();
913       if (scheduled && scheduled <= make_timestamp ())
914         {
915           if (opt.no_auto_check_trustdb) 
916             {
917               pending_check_trustdb = 1;
918               log_info ("please do a --check-trustdb\n");
919             }
920           else
921             {
922               log_info (_("checking the trustdb\n"));
923               validate_keys (0);
924             }
925         }
926     }
927
928   keyid_from_pk (pk, kid);
929   if (pk->main_keyid[0] != kid[0] || pk->main_keyid[1] != kid[1])
930     { /* this is a subkey - get the mainkey */
931       main_pk = m_alloc_clear (sizeof *main_pk);
932       rc = get_pubkey (main_pk, pk->main_keyid);
933       if (rc)
934         {
935           log_error ("error getting main key %08lX of subkey %08lX: %s\n",
936                      (ulong)pk->main_keyid[1], (ulong)kid[1], g10_errstr(rc));
937           validity = TRUST_UNKNOWN; 
938           goto leave;
939         }
940     }
941   else
942     main_pk = pk;
943
944   rc = read_trust_record (main_pk, &trec);
945   if (rc && rc != -1)
946     {
947       tdbio_invalid ();
948       return 0;
949     }
950   if (rc == -1) /* no record found */
951     {
952       validity = TRUST_UNKNOWN; 
953       goto leave;
954     }
955
956   /* loop over all user IDs */
957   recno = trec.r.trust.validlist;
958   validity = 0;
959   while (recno)
960     {
961       read_record (recno, &vrec, RECTYPE_VALID);
962       if ( validity < (vrec.r.valid.validity & TRUST_MASK) )
963         validity = (vrec.r.valid.validity & TRUST_MASK);
964       if ( namehash && !memcmp (vrec.r.valid.namehash, namehash, 20) )
965         break;
966       recno = vrec.r.valid.next;
967     }
968   
969   if (recno) /* okay, use the user ID associated one */
970     validity = (vrec.r.valid.validity & TRUST_MASK);
971
972   if ( (trec.r.trust.ownertrust & TRUST_FLAG_DISABLED) )
973     validity |= TRUST_FLAG_DISABLED;
974
975  leave:
976   /* set some flags direct from the key */
977   if (main_pk->is_revoked)
978     validity |= TRUST_FLAG_REVOKED;
979   if (main_pk != pk && pk->is_revoked)
980     validity |= TRUST_FLAG_SUB_REVOKED;
981   /* Note: expiration is a trust value and not a flag - don't know why
982    * I initially designed it that way */
983   if (main_pk->has_expired || pk->has_expired)
984     validity = (validity & ~TRUST_MASK) | TRUST_EXPIRED;
985   
986   if (pending_check_trustdb)
987     validity |= TRUST_FLAG_PENDING_CHECK;
988
989   if (main_pk != pk)
990     free_public_key (main_pk);
991   return validity;
992 }
993
994
995 int
996 get_validity_info (PKT_public_key *pk, const byte *namehash)
997 {
998     int trustlevel;
999     int c;
1000
1001     trustlevel = get_validity (pk, namehash);
1002     if( trustlevel & TRUST_FLAG_DISABLED )
1003         return 'd';
1004     if( trustlevel & TRUST_FLAG_REVOKED )
1005         return 'r';
1006     c = trust_letter ( (trustlevel & TRUST_MASK) );
1007     if( !c )
1008         c = '?';
1009     return c;
1010 }
1011
1012
1013
1014
1015 void
1016 list_trust_path( const char *username )
1017 {
1018 }
1019
1020
1021
1022
1023 /****************
1024  * Enumerate all keys, which are needed to build all trust paths for
1025  * the given key.  This function does not return the key itself or
1026  * the ultimate key (the last point in cerificate chain).  Only
1027  * certificate chains which ends up at an ultimately trusted key
1028  * are listed.  If ownertrust or validity is not NULL, the corresponding
1029  * value for the returned LID is also returned in these variable(s).
1030  *
1031  *  1) create a void pointer and initialize it to NULL
1032  *  2) pass this void pointer by reference to this function.
1033  *     Set lid to the key you want to enumerate and pass it by reference.
1034  *  3) call this function as long as it does not return -1
1035  *     to indicate EOF. LID does contain the next key used to build the web
1036  *  4) Always call this function a last time with LID set to NULL,
1037  *     so that it can free its context.
1038  *
1039  * Returns: -1 on EOF or the level of the returned LID
1040  */
1041 int
1042 enum_cert_paths( void **context, ulong *lid,
1043                  unsigned *ownertrust, unsigned *validity )
1044 {
1045     return -1;
1046 }
1047
1048
1049 /****************
1050  * Print the current path
1051  */
1052 void
1053 enum_cert_paths_print( void **context, FILE *fp,
1054                                        int refresh, ulong selected_lid )
1055 {
1056     return;
1057 }
1058
1059
1060 \f
1061 /****************************************
1062  *********** NEW NEW NEW ****************
1063  ****************************************/
1064
1065 static int
1066 ask_ownertrust (u32 *kid,int minimum)
1067 {
1068   PKT_public_key *pk;
1069   int rc;
1070   int ot;
1071
1072   pk = m_alloc_clear (sizeof *pk);
1073   rc = get_pubkey (pk, kid);
1074   if (rc)
1075     {
1076       log_error (_("public key %08lX not found: %s\n"),
1077                  (ulong)kid[1], g10_errstr(rc) );
1078       return TRUST_UNKNOWN;
1079     }
1080  
1081   if(opt.force_ownertrust)
1082     {
1083       log_info("force trust for key %08lX to %s\n",(ulong)kid[1],
1084                trust_string(opt.force_ownertrust));
1085       update_ownertrust(pk,opt.force_ownertrust);
1086       ot=opt.force_ownertrust;
1087     }
1088   else
1089     {
1090       ot=edit_ownertrust(pk,0);
1091       if(ot>0)
1092         ot = get_ownertrust (pk);
1093       else if(ot==0)
1094         ot = minimum?minimum:TRUST_UNDEFINED;
1095       else
1096         ot = -1; /* quit */
1097     }
1098
1099   free_public_key( pk );
1100
1101   return ot;
1102 }
1103
1104
1105 static void
1106 mark_keyblock_seen (KeyHashTable tbl, KBNODE node)
1107 {
1108   for ( ;node; node = node->next )
1109     if (node->pkt->pkttype == PKT_PUBLIC_KEY
1110         || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1111       {
1112         u32 aki[2];
1113
1114         keyid_from_pk (node->pkt->pkt.public_key, aki);
1115         add_key_hash_table (tbl, aki);
1116       }
1117 }
1118
1119
1120
1121 static void
1122 dump_key_array (int depth, struct key_array *keys)
1123 {
1124   struct key_array *kar;
1125
1126   for (kar=keys; kar->keyblock; kar++)
1127     {
1128       KBNODE node = kar->keyblock;
1129       u32 kid[2];
1130
1131       keyid_from_pk(node->pkt->pkt.public_key, kid);
1132       printf ("%d:%08lX%08lX:K::%c::::\n",
1133               depth, (ulong)kid[0], (ulong)kid[1], '?');
1134
1135       for (; node; node = node->next)
1136         {
1137           if (node->pkt->pkttype == PKT_USER_ID)
1138             {
1139               int len = node->pkt->pkt.user_id->len;
1140
1141               if (len > 30)
1142                 len = 30;
1143               printf ("%d:%08lX%08lX:U:::%c:::",
1144                       depth, (ulong)kid[0], (ulong)kid[1],
1145                       (node->flag & 4)? 'f':
1146                       (node->flag & 2)? 'm':
1147                       (node->flag & 1)? 'q':'-');
1148               print_string (stdout,  node->pkt->pkt.user_id->name, len, ':');
1149               putchar (':');
1150               putchar ('\n');
1151             }
1152         }
1153     }
1154 }  
1155
1156
1157 static void
1158 store_validation_status (int depth, KBNODE keyblock)
1159 {
1160   KBNODE node;
1161   byte namehash[20];
1162   int status;
1163   int any = 0;
1164
1165   for (node=keyblock; node; node = node->next)
1166     {
1167       if (node->pkt->pkttype == PKT_USER_ID)
1168         {
1169           PKT_user_id *uid = node->pkt->pkt.user_id;
1170
1171           if (node->flag & 4)
1172             status = TRUST_FULLY;
1173           else if (node->flag & 2)
1174             status = TRUST_MARGINAL;
1175           else if (node->flag & 1)
1176             status = TRUST_UNDEFINED;
1177           else
1178             status = 0;
1179           
1180           if (status)
1181             {
1182               if( uid->attrib_data )
1183                 rmd160_hash_buffer (namehash,uid->attrib_data,uid->attrib_len);
1184               else
1185                 rmd160_hash_buffer (namehash, uid->name, uid->len );
1186               
1187               update_validity (keyblock->pkt->pkt.public_key,
1188                                namehash, depth, status);
1189               any = 1;
1190             }
1191         }
1192     }
1193
1194   if (any)
1195     do_sync ();
1196 }  
1197
1198 /*
1199  * check whether the signature sig is in the klist k
1200  */
1201 static struct key_item *
1202 is_in_klist (struct key_item *k, PKT_signature *sig)
1203 {
1204   for (; k; k = k->next)
1205     {
1206       if (k->kid[0] == sig->keyid[0] && k->kid[1] == sig->keyid[1])
1207         return k;
1208     }
1209   return NULL;
1210 }
1211
1212 /*
1213  * Mark the signature of the given UID which are used to certify it.
1214  * To do this, we first revmove all signatures which are not valid and
1215  * from the remain ones we look for the latest one.  If this is not a
1216  * certification revocation signature we mark the signature by setting
1217  * node flag bit 8.  Note that flag bits 9 and 10 are used for internal
1218  * purposes.  
1219  */
1220 static void
1221 mark_usable_uid_certs (KBNODE keyblock, KBNODE uidnode,
1222                        u32 *main_kid, struct key_item *klist,
1223                        u32 curtime, u32 *next_expire)
1224 {
1225   KBNODE node;
1226   PKT_signature *sig;
1227   
1228   /* first check all signatures */
1229   for (node=uidnode->next; node; node = node->next)
1230     {
1231       node->flag &= ~(1<<8 | 1<<9 | 1<<10);
1232       if (node->pkt->pkttype == PKT_USER_ID
1233           || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1234         break; /* ready */
1235       if (node->pkt->pkttype != PKT_SIGNATURE)
1236         continue;
1237       
1238       sig = node->pkt->pkt.signature;
1239       if (sig->keyid[0] == main_kid[0] && sig->keyid[1] == main_kid[1])
1240         continue; /* ignore self-signatures */
1241       if (!IS_UID_SIG(sig) && !IS_UID_REV(sig))
1242         continue; /* we only look at these signature classes */
1243       if (!is_in_klist (klist, sig))
1244         continue;  /* no need to check it then */
1245       if (check_key_signature (keyblock, node, NULL))
1246         continue; /* ignore invalid signatures */
1247       node->flag |= 1<<9;
1248     }      
1249   /* reset the remaining flags */
1250   for (; node; node = node->next)
1251       node->flag &= ~(1<<8 | 1<<9 | 1 << 10);
1252
1253   /* kbnode flag usage: bit 9 is here set for signatures to consider,
1254    * bit 10 will be set by the loop to keep track of keyIDs already
1255    * processed, bit 8 will be set for the usable signatures */
1256
1257   /* for each cert figure out the latest valid one */
1258   for (node=uidnode->next; node; node = node->next)
1259     {
1260       KBNODE n, signode;
1261       u32 kid[2];
1262       u32 sigdate;
1263       
1264       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1265         break;
1266       if ( !(node->flag & (1<<9)) )
1267         continue; /* not a node to look at */
1268       if ( (node->flag & (1<<10)) )
1269         continue; /* signature with a keyID already processed */
1270       node->flag |= (1<<10); /* mark this node as processed */
1271       sig = node->pkt->pkt.signature;
1272       signode = node;
1273       sigdate = sig->timestamp;
1274       kid[0] = sig->keyid[0]; kid[1] = sig->keyid[1];
1275       for (n=uidnode->next; n; n = n->next)
1276         {
1277           if (n->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1278             break;
1279           if ( !(n->flag & (1<<9)) )
1280             continue;
1281           if ( (n->flag & (1<<10)) )
1282             continue; /* shortcut already processed signatures */
1283           sig = n->pkt->pkt.signature;
1284           if (kid[0] != sig->keyid[0] || kid[1] != sig->keyid[1])
1285             continue;
1286           n->flag |= (1<<10); /* mark this node as processed */
1287
1288           /* If signode is nonrevocable and unexpired and n isn't,
1289              then take signode (skip).  It doesn't matter which is
1290              older: if signode was older then we don't want to take n
1291              as signode is nonrevocable.  If n was older then we're
1292              automatically fine. */
1293           
1294           if(((IS_UID_SIG(signode->pkt->pkt.signature) &&
1295                !signode->pkt->pkt.signature->flags.revocable &&
1296                (signode->pkt->pkt.signature->expiredate==0 ||
1297                 signode->pkt->pkt.signature->expiredate>curtime))) &&
1298              (!(IS_UID_SIG(n->pkt->pkt.signature) &&
1299                 !n->pkt->pkt.signature->flags.revocable &&
1300                 (n->pkt->pkt.signature->expiredate==0 ||
1301                  n->pkt->pkt.signature->expiredate>curtime))))
1302             continue;
1303
1304           /* If n is nonrevocable and unexpired and signode isn't,
1305              then take n.  Again, it doesn't matter which is older: if
1306              n was older then we don't want to take signode as n is
1307              nonrevocable.  If signode was older then we're
1308              automatically fine. */
1309           
1310           if((!(IS_UID_SIG(signode->pkt->pkt.signature) &&
1311                 !signode->pkt->pkt.signature->flags.revocable &&
1312                 (signode->pkt->pkt.signature->expiredate==0 ||
1313                  signode->pkt->pkt.signature->expiredate>curtime))) &&
1314              ((IS_UID_SIG(n->pkt->pkt.signature) &&
1315                !n->pkt->pkt.signature->flags.revocable &&
1316                (n->pkt->pkt.signature->expiredate==0 ||
1317                 n->pkt->pkt.signature->expiredate>curtime))))
1318             {
1319               signode = n;
1320               sigdate = sig->timestamp;
1321               continue;
1322             }
1323
1324           /* At this point, if it's newer, it goes in as the only
1325              remaining possibilities are signode and n are both either
1326              revocable or expired or both nonrevocable and unexpired.
1327              If the timestamps are equal take the later ordered
1328              packet, presuming that the key packets are hopefully in
1329              their original order. */
1330
1331           if (sig->timestamp >= sigdate)
1332             {
1333               signode = n;
1334               sigdate = sig->timestamp;
1335             }
1336         }
1337       sig = signode->pkt->pkt.signature;
1338       if (IS_UID_SIG (sig))
1339         { /* this seems to be a usable one which is not revoked. 
1340            * Just need to check whether there is an expiration time,
1341            * We do the expired certification after finding a suitable
1342            * certification, the assumption is that a signator does not
1343            * want that after the expiration of his certificate the
1344            * system falls back to an older certification which has a
1345            * different expiration time */
1346           const byte *p;
1347           u32 expire;
1348                     
1349           p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_SIG_EXPIRE, NULL );
1350           expire = p? sig->timestamp + buffer_to_u32(p) : 0;
1351
1352           if (expire==0 || expire > curtime )
1353             {
1354               signode->flag |= (1<<8); /* yeah, found a good cert */
1355               if (expire && expire < *next_expire)
1356                 *next_expire = expire;
1357             }
1358         }
1359     }
1360 }
1361
1362 /* Used by validate_one_keyblock to confirm a regexp within a trust
1363    signature.  Returns 1 for match, and 0 for no match or regex
1364    error. */
1365 static int
1366 check_regexp(const char *exp,const char *string)
1367 {
1368 #ifdef DISABLE_REGEXP
1369   /* When DISABLE_REGEXP is defined, assume all regexps do not
1370      match. */
1371   return 0;
1372 #elif defined(__riscos__)
1373   return riscos_check_regexp(exp, string, DBG_TRUST);
1374 #else
1375   int ret;
1376   regex_t pat;
1377
1378   if(regcomp(&pat,exp,REG_ICASE|REG_NOSUB|REG_EXTENDED)!=0)
1379     return 0;
1380
1381   ret=regexec(&pat,string,0,NULL,0);
1382
1383   regfree(&pat);
1384
1385   if(DBG_TRUST)
1386     log_debug("regexp \"%s\" on \"%s\": %s\n",exp,string,ret==0?"YES":"NO");
1387
1388   return (ret==0);
1389 #endif
1390 }
1391
1392 /*
1393  * Return true if the key is signed by one of the keys in the given
1394  * key ID list.  User IDs with a valid signature are marked by node
1395  * flags as follows:
1396  *  flag bit 0: There is at least one signature
1397  *           1: There is marginal confidence that this is a legitimate uid
1398  *           2: There is full confidence that this is a legitimate uid.
1399  *           8: Used for internal purposes.
1400  *           9: Ditto (in mark_usable_uid_certs())
1401  *          10: Ditto (ditto)
1402  * This function assumes that all kbnode flags are cleared on entry.
1403  */
1404 static int
1405 validate_one_keyblock (KBNODE kb, struct key_item *klist,
1406                        u32 curtime, u32 *next_expire)
1407 {
1408   struct key_item *kr;
1409   KBNODE node, uidnode=NULL;
1410   PKT_public_key *pk = kb->pkt->pkt.public_key;
1411   u32 main_kid[2];
1412   int issigned=0, any_signed = 0, fully_count =0, marginal_count = 0;
1413
1414   keyid_from_pk(pk, main_kid);
1415   for (node=kb; node; node = node->next)
1416     {
1417       if (node->pkt->pkttype == PKT_USER_ID)
1418         {
1419           if (uidnode && issigned)
1420             {
1421               if (fully_count >= opt.completes_needed
1422                   || marginal_count >= opt.marginals_needed )
1423                 uidnode->flag |= 4; 
1424               else if (fully_count || marginal_count)
1425                 uidnode->flag |= 2;
1426               uidnode->flag |= 1;
1427               any_signed = 1;
1428             }
1429           uidnode = node;
1430           issigned = 0;
1431           fully_count = marginal_count = 0;
1432           mark_usable_uid_certs (kb, uidnode, main_kid, klist, 
1433                                  curtime, next_expire);
1434         }
1435       else if (node->pkt->pkttype == PKT_SIGNATURE 
1436                && (node->flag & (1<<8)) )
1437         {
1438           /* Note that we are only seeing unrevoked sigs here */
1439           PKT_signature *sig = node->pkt->pkt.signature;
1440           
1441           kr = is_in_klist (klist, sig);
1442           /* If the trust_regexp does not match, it's as if the sig
1443              did not exist.  This is safe for non-trust sigs as well
1444              since we don't accept a regexp on the sig unless it's a
1445              trust sig. */
1446           if (kr && (kr->trust_regexp==NULL || opt.trust_model!=TM_OPENPGP ||
1447                      (uidnode && check_regexp(kr->trust_regexp,
1448                                             uidnode->pkt->pkt.user_id->name))))
1449             {
1450               if(DBG_TRUST && opt.trust_model==TM_OPENPGP && sig->trust_depth)
1451                 log_debug("trust sig on %s, sig depth is %d, kr depth is %d\n",
1452                           uidnode->pkt->pkt.user_id->name,sig->trust_depth,
1453                           kr->trust_depth);
1454
1455               /* Are we part of a trust sig chain?  We always favor
1456                  the latest trust sig, rather than the greater or
1457                  lesser trust sig or value.  I could make a decent
1458                  argument for any of these cases, but this seems to be
1459                  what PGP does, and I'd like to be compatible. -dms */
1460               if(opt.trust_model==TM_OPENPGP && sig->trust_depth
1461                  && pk->trust_timestamp<=sig->timestamp
1462                  && (sig->trust_depth<=kr->trust_depth
1463                      || kr->ownertrust==TRUST_ULTIMATE))
1464                 {
1465                   /* If we got here, we know that:
1466
1467                      this is a trust sig.
1468
1469                      it's a newer trust sig than any previous trust
1470                      sig on this key (not uid).
1471
1472                      it is legal in that it was either generated by an
1473                      ultimate key, or a key that was part of a trust
1474                      chain, and the depth does not violate the
1475                      original trust sig.
1476
1477                      if there is a regexp attached, it matched
1478                      successfully.
1479                   */
1480
1481                   if(DBG_TRUST)
1482                     log_debug("replacing trust value %d with %d and "
1483                               "depth %d with %d\n",
1484                               pk->trust_value,sig->trust_value,
1485                               pk->trust_depth,sig->trust_depth);
1486
1487                   pk->trust_value=sig->trust_value;
1488                   pk->trust_depth=sig->trust_depth-1;
1489
1490                   /* If the trust sig contains a regexp, record it
1491                      on the pk for the next round. */
1492                   if(sig->trust_regexp)
1493                     pk->trust_regexp=sig->trust_regexp;
1494                 }
1495
1496               if (kr->ownertrust == TRUST_ULTIMATE)
1497                 fully_count = opt.completes_needed;
1498               else if (kr->ownertrust == TRUST_FULLY)
1499                 fully_count++;
1500               else if (kr->ownertrust == TRUST_MARGINAL)
1501                 marginal_count++;
1502               issigned = 1;
1503             }
1504         }
1505     }
1506
1507   if (uidnode && issigned)
1508     {
1509       if (fully_count >= opt.completes_needed
1510                || marginal_count >= opt.marginals_needed )
1511         uidnode->flag |= 4; 
1512       else if (fully_count || marginal_count)
1513         uidnode->flag |= 2;
1514       uidnode->flag |= 1;
1515       any_signed = 1;
1516     }
1517
1518   return any_signed;
1519 }
1520
1521
1522 static int
1523 search_skipfnc (void *opaque, u32 *kid)
1524 {
1525   return test_key_hash_table ((KeyHashTable)opaque, kid);
1526 }
1527
1528
1529 /*
1530  * Scan all keys and return a key_array of all suitable keys from
1531  * kllist.  The caller has to pass keydb handle so that we don't use
1532  * to create our own.  Returns either a key_array or NULL in case of
1533  * an error.  No results found are indicated by an empty array.
1534  * Caller hast to release the returned array.  
1535  */
1536 static struct key_array *
1537 validate_key_list (KEYDB_HANDLE hd, KeyHashTable visited,
1538                    struct key_item *klist, u32 curtime, u32 *next_expire)
1539 {
1540   KBNODE keyblock = NULL;
1541   struct key_array *keys = NULL;
1542   size_t nkeys, maxkeys;
1543   int rc;
1544   KEYDB_SEARCH_DESC desc;
1545   
1546   maxkeys = 1000;
1547   keys = m_alloc ((maxkeys+1) * sizeof *keys);
1548   nkeys = 0;
1549   
1550   rc = keydb_search_reset (hd);
1551   if (rc)
1552     {
1553       log_error ("keydb_search_reset failed: %s\n", g10_errstr(rc));
1554       m_free (keys);
1555       return NULL;
1556     }
1557
1558   memset (&desc, 0, sizeof desc);
1559   desc.mode = KEYDB_SEARCH_MODE_FIRST;
1560   desc.skipfnc = search_skipfnc;
1561   desc.skipfncvalue = visited;
1562   rc = keydb_search (hd, &desc, 1);
1563   if (rc == -1)
1564     {
1565       keys[nkeys].keyblock = NULL;
1566       return keys;
1567     }
1568   if (rc)
1569     {
1570       log_error ("keydb_search_first failed: %s\n", g10_errstr(rc));
1571       m_free (keys);
1572       return NULL;
1573     }
1574   
1575   desc.mode = KEYDB_SEARCH_MODE_NEXT; /* change mode */
1576   do
1577     {
1578       PKT_public_key *pk;
1579         
1580       rc = keydb_get_keyblock (hd, &keyblock);
1581       if (rc) 
1582         {
1583           log_error ("keydb_get_keyblock failed: %s\n", g10_errstr(rc));
1584           m_free (keys);
1585           return NULL;
1586         }
1587       
1588       if ( keyblock->pkt->pkttype != PKT_PUBLIC_KEY) 
1589         {
1590           log_debug ("ooops: invalid pkttype %d encountered\n",
1591                      keyblock->pkt->pkttype);
1592           dump_kbnode (keyblock);
1593           release_kbnode(keyblock);
1594           continue;
1595         }
1596
1597       /* prepare the keyblock for further processing */
1598       merge_keys_and_selfsig (keyblock); 
1599       clear_kbnode_flags (keyblock);
1600       pk = keyblock->pkt->pkt.public_key;
1601       if (pk->has_expired || pk->is_revoked)
1602         {
1603           /* it does not make sense to look further at those keys */
1604           mark_keyblock_seen (visited, keyblock);
1605         }
1606       else if (validate_one_keyblock (keyblock, klist, curtime, next_expire))
1607         {
1608           if (pk->expiredate && pk->expiredate >= curtime
1609               && pk->expiredate < *next_expire)
1610             *next_expire = pk->expiredate;
1611
1612           if (nkeys == maxkeys) {
1613             maxkeys += 1000;
1614             keys = m_realloc (keys, (maxkeys+1) * sizeof *keys);
1615           }
1616           keys[nkeys++].keyblock = keyblock;
1617           /* this key is signed - don't check it again */
1618           mark_keyblock_seen (visited, keyblock);
1619           keyblock = NULL;
1620         }
1621
1622       release_kbnode (keyblock);
1623       keyblock = NULL;
1624     } 
1625   while ( !(rc = keydb_search (hd, &desc, 1)) );
1626   if (rc && rc != -1) 
1627     {
1628       log_error ("keydb_search_next failed: %s\n", g10_errstr(rc));
1629       m_free (keys);
1630       return NULL;
1631     }
1632
1633   keys[nkeys].keyblock = NULL;
1634   return keys;
1635
1636
1637
1638 static void
1639 reset_unconnected_keys (KEYDB_HANDLE hd, KeyHashTable visited)
1640 {
1641   int rc;
1642   KBNODE keyblock = NULL;
1643   KEYDB_SEARCH_DESC desc;
1644   int count = 0, nreset = 0;
1645   
1646   rc = keydb_search_reset (hd);
1647   if (rc)
1648     {
1649       log_error ("keydb_search_reset failed: %s\n", g10_errstr(rc));
1650       return;
1651     }
1652
1653   memset (&desc, 0, sizeof desc);
1654   desc.mode = KEYDB_SEARCH_MODE_FIRST;
1655   desc.skipfnc = search_skipfnc;
1656   desc.skipfncvalue = visited;
1657   rc = keydb_search (hd, &desc, 1);
1658   if (rc && rc != -1 )
1659     log_error ("keydb_search_first failed: %s\n", g10_errstr(rc));
1660   else if (!rc)
1661     {
1662       desc.mode = KEYDB_SEARCH_MODE_NEXT; /* change mode */
1663       do
1664         {
1665           rc = keydb_get_keyblock (hd, &keyblock);
1666           if (rc) 
1667             {
1668               log_error ("keydb_get_keyblock failed: %s\n", g10_errstr(rc));
1669               break;
1670             }
1671           count++;
1672
1673           if (keyblock->pkt->pkttype == PKT_PUBLIC_KEY) /* paranoid assertion*/
1674             {
1675               nreset += clear_validity (keyblock->pkt->pkt.public_key);
1676               release_kbnode (keyblock);
1677             } 
1678         }
1679       while ( !(rc = keydb_search (hd, &desc, 1)) );
1680       if (rc && rc != -1) 
1681         log_error ("keydb_search_next failed: %s\n", g10_errstr(rc));
1682     }
1683   if (opt.verbose)
1684     log_info ("%d unconnected keys (%d trust records cleared)\n",
1685               count, nreset);
1686   do_sync ();
1687
1688
1689
1690 /*
1691  * Run the key validation procedure.
1692  *
1693  * This works this way:
1694  * Step 1: Find all ultimately trusted keys (UTK).
1695  *         mark them all as seen and put them into klist.
1696  * Step 2: loop max_cert_times
1697  * Step 3:   if OWNERTRUST of any key in klist is undefined
1698  *             ask user to assign ownertrust
1699  * Step 4:   Loop over all keys in the keyDB which are not marked seen 
1700  * Step 5:     if key is revoked or expired
1701  *                mark key as seen
1702  *                continue loop at Step 4
1703  * Step 6:     For each user ID of that key signed by a key in klist
1704  *                Calculate validity by counting trusted signatures.
1705  *                Set validity of user ID
1706  * Step 7:     If any signed user ID was found
1707  *                mark key as seen
1708  *             End Loop
1709  * Step 8:   Build a new klist from all fully trusted keys from step 6
1710  *           End Loop
1711  *         Ready  
1712  *
1713  */
1714 static int
1715 validate_keys (int interactive)
1716 {
1717   int rc = 0;
1718   int quit=0;
1719   struct key_item *klist = NULL;
1720   struct key_item *k;
1721   struct key_array *keys = NULL;
1722   struct key_array *kar;
1723   KEYDB_HANDLE kdb = NULL;
1724   KBNODE node;
1725   int depth;
1726   int key_count;
1727   int ot_unknown, ot_undefined, ot_never, ot_marginal, ot_full, ot_ultimate;
1728   KeyHashTable visited;
1729   u32 start_time, next_expire;
1730
1731   start_time = make_timestamp ();
1732   next_expire = 0xffffffff; /* set next expire to the year 2106 */
1733   visited = new_key_hash_table ();
1734   /* Fixme: Instead of always building a UTK list, we could just build it
1735    * here when needed */
1736   if (!utk_list)
1737     {
1738       log_info ("no ultimately trusted keys found\n");
1739       goto leave;
1740     }
1741
1742   /* mark all UTKs as visited and set validity to ultimate */
1743   for (k=utk_list; k; k = k->next)
1744     {
1745       KBNODE keyblock;
1746       PKT_public_key *pk;
1747
1748       keyblock = get_pubkeyblock (k->kid);
1749       if (!keyblock)
1750         {
1751           log_error (_("public key of ultimately"
1752                        " trusted key %08lX not found\n"), (ulong)k->kid[1]);
1753           continue;
1754         }
1755       mark_keyblock_seen (visited, keyblock);
1756       pk = keyblock->pkt->pkt.public_key;
1757       for (node=keyblock; node; node = node->next)
1758         {
1759           if (node->pkt->pkttype == PKT_USER_ID)
1760             {
1761               byte namehash[20];
1762               PKT_user_id *uid = node->pkt->pkt.user_id;
1763               
1764               if( uid->attrib_data )
1765                 rmd160_hash_buffer (namehash,uid->attrib_data,uid->attrib_len);
1766               else
1767                 rmd160_hash_buffer (namehash, uid->name, uid->len );
1768               update_validity (pk, namehash, 0, TRUST_ULTIMATE);
1769             }
1770         }
1771       if ( pk->expiredate && pk->expiredate >= start_time
1772            && pk->expiredate < next_expire)
1773         next_expire = pk->expiredate;
1774       
1775       release_kbnode (keyblock);
1776       do_sync ();
1777     }
1778
1779   klist = utk_list;
1780   kdb = keydb_new (0);
1781
1782   log_info(_("%d marginal(s) needed, %d complete(s) needed, %s trust model\n"),
1783            opt.marginals_needed,opt.completes_needed,
1784            opt.trust_model==TM_CLASSIC?"Classic":
1785                           opt.trust_model==TM_OPENPGP?"OpenPGP":"unknown");
1786
1787   for (depth=0; depth < opt.max_cert_depth; depth++)
1788     {
1789       /* See whether we should assign ownertrust values to the keys in
1790          utk_list.  */
1791       ot_unknown = ot_undefined = ot_never = 0;
1792       ot_marginal = ot_full = ot_ultimate = 0;
1793       for (k=klist; k; k = k->next)
1794         {
1795           int min=0;
1796
1797           /* 120 and 60 are as per RFC2440 */
1798           if(k->trust_value>=120)
1799             min=TRUST_FULLY;
1800           else if(k->trust_value>=60)
1801             min=TRUST_MARGINAL;
1802
1803           if(min!=k->min_ownertrust)
1804             update_min_ownertrust(k->kid,min);
1805
1806           if (interactive && k->ownertrust == TRUST_UNKNOWN)
1807             {
1808               k->ownertrust = ask_ownertrust (k->kid,min);
1809
1810               if (k->ownertrust == -1)
1811                 {
1812                   quit=1;
1813                   goto leave;
1814                 }
1815             }
1816
1817           /* This can happen during transition from an old trustdb
1818              before trust sigs.  It can also happen if a user uses two
1819              different versions of GnuPG or changes the --trust-model
1820              setting. */
1821           if(k->ownertrust<min)
1822             {
1823               if(DBG_TRUST)
1824                 log_debug("key %08lX: "
1825                           "overriding ownertrust \"%s\" with \"%s\"\n",
1826                           (ulong)k->kid[1],
1827                           trust_string(k->ownertrust),trust_string(min));
1828
1829               k->ownertrust=min;
1830             }
1831
1832           if (k->ownertrust == TRUST_UNKNOWN)
1833             ot_unknown++;
1834           else if (k->ownertrust == TRUST_UNDEFINED)
1835             ot_undefined++;
1836           else if (k->ownertrust == TRUST_NEVER)
1837             ot_never++;
1838           else if (k->ownertrust == TRUST_MARGINAL)
1839             ot_marginal++;
1840           else if (k->ownertrust == TRUST_FULLY)
1841             ot_full++;
1842           else if (k->ownertrust == TRUST_ULTIMATE)
1843             ot_ultimate++;
1844         }
1845
1846       /* Find all keys which are signed by a key in kdlist */
1847       keys = validate_key_list (kdb, visited, klist, start_time, &next_expire);
1848       if (!keys) 
1849         {
1850           log_error ("validate_key_list failed\n");
1851           rc = G10ERR_GENERAL;
1852           goto leave;
1853         }
1854
1855       for (key_count=0, kar=keys; kar->keyblock; kar++, key_count++)
1856         ;
1857
1858       /* Store the calculated valididation status somewhere */
1859       if (opt.verbose > 1)
1860         dump_key_array (depth, keys);
1861
1862       log_info (_("checking at depth %d signed=%d"
1863                   " ot(-/q/n/m/f/u)=%d/%d/%d/%d/%d/%d\n"), 
1864                 depth, key_count, ot_unknown, ot_undefined,
1865                 ot_never, ot_marginal, ot_full, ot_ultimate ); 
1866
1867       for (kar=keys; kar->keyblock; kar++)
1868           store_validation_status (depth, kar->keyblock);
1869
1870       /* Build a new kdlist from all fully valid keys in KEYS */
1871       if (klist != utk_list)
1872         release_key_items (klist);
1873       klist = NULL;
1874       for (kar=keys; kar->keyblock; kar++)
1875         {
1876           for (node=kar->keyblock; node; node = node->next)
1877             {
1878               if (node->pkt->pkttype == PKT_USER_ID && (node->flag & 4))
1879                 {
1880                   k = new_key_item ();
1881                   keyid_from_pk (kar->keyblock->pkt->pkt.public_key, k->kid);
1882                   k->ownertrust = get_ownertrust (kar->keyblock
1883                                                   ->pkt->pkt.public_key);
1884                   k->min_ownertrust = get_min_ownertrust (kar->keyblock
1885                                                         ->pkt->pkt.public_key);
1886                   k->trust_depth=
1887                     kar->keyblock->pkt->pkt.public_key->trust_depth;
1888                   k->trust_value=
1889                     kar->keyblock->pkt->pkt.public_key->trust_value;
1890                   if(kar->keyblock->pkt->pkt.public_key->trust_regexp)
1891                     k->trust_regexp=
1892                       m_strdup(kar->keyblock->pkt->
1893                                pkt.public_key->trust_regexp);
1894                   k->next = klist;
1895                   klist = k;
1896                   break;
1897                 }
1898             }
1899         }
1900       release_key_array (keys);
1901       keys = NULL;
1902       if (!klist)
1903         break; /* no need to dive in deeper */
1904     }
1905
1906   reset_unconnected_keys (kdb, visited);
1907
1908  leave:
1909   keydb_release (kdb);
1910   release_key_array (keys);
1911   release_key_items (klist);
1912   release_key_hash_table (visited);
1913   if (!rc && !quit) /* mark trustDB as checked */
1914     {
1915       if (next_expire == 0xffffffff || next_expire < start_time )
1916         tdbio_write_nextcheck (0); 
1917       else
1918         {
1919           tdbio_write_nextcheck (next_expire); 
1920           log_info (_("next trustdb check due at %s\n"),
1921                     strtimestamp (next_expire));
1922         }
1923
1924       if(tdbio_update_version_record()!=0)
1925         {
1926           log_error(_("unable to update trustdb version record: "
1927                       "write failed: %s\n"), g10_errstr(rc));
1928           tdbio_invalid();
1929         }
1930
1931       do_sync ();
1932       pending_check_trustdb = 0;
1933     }
1934   return rc;
1935 }