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