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