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