some late minor fixes.
[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 %08lX%08lX: update min_ownertrust from %u to %u\n",
801                    (ulong)kid[0],(ulong)kid[1],
802                    (unsigned int)rec.r.trust.min_ownertrust,
803                    new_trust );
804       if (rec.r.trust.min_ownertrust != new_trust)
805         {
806           rec.r.trust.min_ownertrust = new_trust;
807           write_record( &rec );
808           revalidation_mark ();
809           do_sync ();
810         }
811     }
812   else if (rc == -1)
813     { /* no record yet - create a new one */
814       size_t dummy;
815
816       if (DBG_TRUST)
817         log_debug ("insert min_ownertrust %u\n", new_trust );
818
819       memset (&rec, 0, sizeof rec);
820       rec.recnum = tdbio_new_recnum ();
821       rec.rectype = RECTYPE_TRUST;
822       fingerprint_from_pk (pk, rec.r.trust.fingerprint, &dummy);
823       rec.r.trust.min_ownertrust = new_trust;
824       write_record (&rec);
825       revalidation_mark ();
826       do_sync ();
827       rc = 0;
828     }
829   else 
830     {
831       tdbio_invalid ();
832     }
833 }
834
835 /* Clear the ownertrust and min_ownertrust values.  Return true if a
836    change actually happened. */
837 int
838 clear_ownertrusts (PKT_public_key *pk)
839 {
840   TRUSTREC rec;
841   int rc;
842   
843   rc = read_trust_record (pk, &rec);
844   if (!rc)
845     {
846       if (DBG_TRUST)
847         {
848           log_debug ("clearing ownertrust (old value %u)\n",
849                      (unsigned int)rec.r.trust.ownertrust);
850           log_debug ("clearing min_ownertrust (old value %u)\n",
851                      (unsigned int)rec.r.trust.min_ownertrust);
852         }
853       if (rec.r.trust.ownertrust || rec.r.trust.min_ownertrust)
854         {
855           rec.r.trust.ownertrust = 0;
856           rec.r.trust.min_ownertrust = 0;
857           write_record( &rec );
858           revalidation_mark ();
859           do_sync ();
860           return 1;
861         }
862     }
863   else if (rc != -1)
864     {
865       tdbio_invalid ();
866     }
867   return 0;
868 }
869
870 /* 
871  * Note: Caller has to do a sync 
872  */
873 static void
874 update_validity (PKT_public_key *pk, PKT_user_id *uid,
875                  int depth, int validity)
876 {
877   TRUSTREC trec, vrec;
878   int rc;
879   ulong recno;
880
881   namehash_from_uid(uid);
882
883   rc = read_trust_record (pk, &trec);
884   if (rc && rc != -1)
885     {
886       tdbio_invalid ();
887       return;
888     }
889   if (rc == -1) /* no record yet - create a new one */
890     { 
891       size_t dummy;
892
893       rc = 0;
894       memset (&trec, 0, sizeof trec);
895       trec.recnum = tdbio_new_recnum ();
896       trec.rectype = RECTYPE_TRUST;
897       fingerprint_from_pk (pk, trec.r.trust.fingerprint, &dummy);
898       trec.r.trust.ownertrust = 0;
899       }
900
901   /* locate an existing one */
902   recno = trec.r.trust.validlist;
903   while (recno)
904     {
905       read_record (recno, &vrec, RECTYPE_VALID);
906       if ( !memcmp (vrec.r.valid.namehash, uid->namehash, 20) )
907         break;
908       recno = vrec.r.valid.next;
909     }
910
911   if (!recno) /* insert a new validity record */
912     {
913       memset (&vrec, 0, sizeof vrec);
914       vrec.recnum = tdbio_new_recnum ();
915       vrec.rectype = RECTYPE_VALID;
916       memcpy (vrec.r.valid.namehash, uid->namehash, 20);
917       vrec.r.valid.next = trec.r.trust.validlist;
918       trec.r.trust.validlist = vrec.recnum;
919     }
920   vrec.r.valid.validity = validity;
921   vrec.r.valid.full_count = uid->help_full_count;
922   vrec.r.valid.marginal_count = uid->help_marginal_count;
923   write_record (&vrec);
924   trec.r.trust.depth = depth;
925   write_record (&trec);
926 }
927
928
929 /***********************************************
930  *********  Query trustdb values  **************
931  ***********************************************/
932
933 /* Return true if key is disabled */
934 int
935 cache_disabled_value(PKT_public_key *pk)
936 {
937   int rc;
938   TRUSTREC trec;
939   int disabled=0;
940
941   if(pk->is_disabled)
942     return (pk->is_disabled==2);
943
944   init_trustdb();
945
946   rc = read_trust_record (pk, &trec);
947   if (rc && rc != -1)
948     {
949       tdbio_invalid ();
950       goto leave;
951     }
952   if (rc == -1) /* no record found, so assume not disabled */
953     goto leave;
954  
955   if(trec.r.trust.ownertrust & TRUST_FLAG_DISABLED)
956     disabled=1;
957  
958   /* Cache it for later so we don't need to look at the trustdb every
959      time */
960   if(disabled)
961     pk->is_disabled=2;
962   else
963     pk->is_disabled=1;
964
965  leave:
966    return disabled;
967 }
968
969 void
970 check_trustdb_stale(void)
971 {
972   static int did_nextcheck=0;
973
974   init_trustdb ();
975   if (!did_nextcheck
976       && (opt.trust_model==TM_PGP || opt.trust_model==TM_CLASSIC))
977     {
978       ulong scheduled;
979
980       did_nextcheck = 1;
981       scheduled = tdbio_read_nextcheck ();
982       if (scheduled && scheduled <= make_timestamp ())
983         {
984           if (opt.no_auto_check_trustdb) 
985             {
986               pending_check_trustdb = 1;
987               log_info (_("please do a --check-trustdb\n"));
988             }
989           else
990             {
991               log_info (_("checking the trustdb\n"));
992               validate_keys (0);
993             }
994         }
995     }
996 }
997
998 /*
999  * Return the validity information for PK.  If the namehash is not
1000  * NULL, the validity of the corresponsing user ID is returned,
1001  * otherwise, a reasonable value for the entire key is returned. 
1002  */
1003 unsigned int
1004 get_validity (PKT_public_key *pk, PKT_user_id *uid)
1005 {
1006   TRUSTREC trec, vrec;
1007   int rc;
1008   ulong recno;
1009   unsigned int validity;
1010   u32 kid[2];
1011   PKT_public_key *main_pk;
1012
1013   if(uid)
1014     namehash_from_uid(uid);
1015
1016   init_trustdb ();
1017   check_trustdb_stale();
1018
1019   keyid_from_pk (pk, kid);
1020   if (pk->main_keyid[0] != kid[0] || pk->main_keyid[1] != kid[1])
1021     { /* this is a subkey - get the mainkey */
1022       main_pk = m_alloc_clear (sizeof *main_pk);
1023       rc = get_pubkey (main_pk, pk->main_keyid);
1024       if (rc)
1025         {
1026           char *tempkeystr=m_strdup(keystr(pk->main_keyid));
1027           log_error ("error getting main key %s of subkey %s: %s\n",
1028                      tempkeystr, keystr(kid), g10_errstr(rc));
1029           m_free(tempkeystr);
1030           validity = TRUST_UNKNOWN; 
1031           goto leave;
1032         }
1033     }
1034   else
1035     main_pk = pk;
1036
1037   rc = read_trust_record (main_pk, &trec);
1038   if (rc && rc != -1)
1039     {
1040       tdbio_invalid ();
1041       return 0;
1042     }
1043   if (rc == -1) /* no record found */
1044     {
1045       validity = TRUST_UNKNOWN; 
1046       goto leave;
1047     }
1048
1049   /* loop over all user IDs */
1050   recno = trec.r.trust.validlist;
1051   validity = 0;
1052   while (recno)
1053     {
1054       read_record (recno, &vrec, RECTYPE_VALID);
1055
1056       if(uid)
1057         {
1058           /* If a user ID is given we return the validity for that
1059              user ID ONLY.  If the namehash is not found, then there
1060              is no validity at all (i.e. the user ID wasn't
1061              signed). */
1062           if(memcmp(vrec.r.valid.namehash,uid->namehash,20)==0)
1063             {
1064               validity=(vrec.r.valid.validity & TRUST_MASK);
1065               break;
1066             }
1067         }
1068       else
1069         {
1070           /* If no namehash is given, we take the maximum validity
1071              over all user IDs */
1072           if ( validity < (vrec.r.valid.validity & TRUST_MASK) )
1073             validity = (vrec.r.valid.validity & TRUST_MASK);
1074         }
1075
1076       recno = vrec.r.valid.next;
1077     }
1078   
1079   if ( (trec.r.trust.ownertrust & TRUST_FLAG_DISABLED) )
1080     {
1081       validity |= TRUST_FLAG_DISABLED;
1082       pk->is_disabled=2;
1083     }
1084   else
1085     pk->is_disabled=1;
1086
1087  leave:
1088   /* set some flags direct from the key */
1089   if (main_pk->is_revoked)
1090     validity |= TRUST_FLAG_REVOKED;
1091   if (main_pk != pk && pk->is_revoked)
1092     validity |= TRUST_FLAG_SUB_REVOKED;
1093   /* Note: expiration is a trust value and not a flag - don't know why
1094    * I initially designed it that way */
1095   if (main_pk->has_expired || pk->has_expired)
1096     validity = (validity & ~TRUST_MASK) | TRUST_EXPIRED;
1097   
1098   if (pending_check_trustdb)
1099     validity |= TRUST_FLAG_PENDING_CHECK;
1100
1101   if (main_pk != pk)
1102     free_public_key (main_pk);
1103   return validity;
1104 }
1105
1106 int
1107 get_validity_info (PKT_public_key *pk, PKT_user_id *uid)
1108 {
1109     int trustlevel;
1110
1111     trustlevel = get_validity (pk, uid);
1112     if( trustlevel & TRUST_FLAG_REVOKED )
1113         return 'r';
1114     return trust_letter ( trustlevel );
1115 }
1116
1117 const char *
1118 get_validity_string (PKT_public_key *pk, PKT_user_id *uid)
1119 {
1120   int trustlevel;
1121
1122   trustlevel = get_validity (pk, uid);
1123   if( trustlevel & TRUST_FLAG_REVOKED )
1124     return _("revoked");
1125   return trust_value_to_string(trustlevel);
1126 }
1127
1128 static void
1129 get_validity_counts (PKT_public_key *pk, PKT_user_id *uid)
1130 {
1131   TRUSTREC trec, vrec;
1132   ulong recno;
1133
1134   if(pk==NULL || uid==NULL)
1135     BUG();
1136
1137   namehash_from_uid(uid);
1138
1139   uid->help_marginal_count=uid->help_full_count=0;
1140
1141   init_trustdb ();
1142
1143   if(read_trust_record (pk, &trec)!=0)
1144     return;
1145
1146   /* loop over all user IDs */
1147   recno = trec.r.trust.validlist;
1148   while (recno)
1149     {
1150       read_record (recno, &vrec, RECTYPE_VALID);
1151
1152       if(memcmp(vrec.r.valid.namehash,uid->namehash,20)==0)
1153         {
1154           uid->help_marginal_count=vrec.r.valid.marginal_count;
1155           uid->help_full_count=vrec.r.valid.full_count;
1156           /*  printf("Fetched marginal %d, full %d\n",uid->help_marginal_count,uid->help_full_count); */
1157           break;
1158         }
1159
1160       recno = vrec.r.valid.next;
1161     }
1162 }
1163
1164 void
1165 list_trust_path( const char *username )
1166 {
1167 }
1168
1169 /****************
1170  * Enumerate all keys, which are needed to build all trust paths for
1171  * the given key.  This function does not return the key itself or
1172  * the ultimate key (the last point in cerificate chain).  Only
1173  * certificate chains which ends up at an ultimately trusted key
1174  * are listed.  If ownertrust or validity is not NULL, the corresponding
1175  * value for the returned LID is also returned in these variable(s).
1176  *
1177  *  1) create a void pointer and initialize it to NULL
1178  *  2) pass this void pointer by reference to this function.
1179  *     Set lid to the key you want to enumerate and pass it by reference.
1180  *  3) call this function as long as it does not return -1
1181  *     to indicate EOF. LID does contain the next key used to build the web
1182  *  4) Always call this function a last time with LID set to NULL,
1183  *     so that it can free its context.
1184  *
1185  * Returns: -1 on EOF or the level of the returned LID
1186  */
1187 int
1188 enum_cert_paths( void **context, ulong *lid,
1189                  unsigned *ownertrust, unsigned *validity )
1190 {
1191     return -1;
1192 }
1193
1194
1195 /****************
1196  * Print the current path
1197  */
1198 void
1199 enum_cert_paths_print( void **context, FILE *fp,
1200                                        int refresh, ulong selected_lid )
1201 {
1202     return;
1203 }
1204
1205
1206 \f
1207 /****************************************
1208  *********** NEW NEW NEW ****************
1209  ****************************************/
1210
1211 static int
1212 ask_ownertrust (u32 *kid,int minimum)
1213 {
1214   PKT_public_key *pk;
1215   int rc;
1216   int ot;
1217
1218   pk = m_alloc_clear (sizeof *pk);
1219   rc = get_pubkey (pk, kid);
1220   if (rc)
1221     {
1222       log_error (_("public key %s not found: %s\n"),
1223                  keystr(kid), g10_errstr(rc) );
1224       return TRUST_UNKNOWN;
1225     }
1226  
1227   if(opt.force_ownertrust)
1228     {
1229       log_info("force trust for key %s to %s\n",
1230                keystr(kid),trust_value_to_string(opt.force_ownertrust));
1231       update_ownertrust(pk,opt.force_ownertrust);
1232       ot=opt.force_ownertrust;
1233     }
1234   else
1235     {
1236       ot=edit_ownertrust(pk,0);
1237       if(ot>0)
1238         ot = get_ownertrust (pk);
1239       else if(ot==0)
1240         ot = minimum?minimum:TRUST_UNDEFINED;
1241       else
1242         ot = -1; /* quit */
1243     }
1244
1245   free_public_key( pk );
1246
1247   return ot;
1248 }
1249
1250
1251 static void
1252 mark_keyblock_seen (KeyHashTable tbl, KBNODE node)
1253 {
1254   for ( ;node; node = node->next )
1255     if (node->pkt->pkttype == PKT_PUBLIC_KEY
1256         || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1257       {
1258         u32 aki[2];
1259
1260         keyid_from_pk (node->pkt->pkt.public_key, aki);
1261         add_key_hash_table (tbl, aki);
1262       }
1263 }
1264
1265
1266 static void
1267 dump_key_array (int depth, struct key_array *keys)
1268 {
1269   struct key_array *kar;
1270
1271   for (kar=keys; kar->keyblock; kar++)
1272     {
1273       KBNODE node = kar->keyblock;
1274       u32 kid[2];
1275
1276       keyid_from_pk(node->pkt->pkt.public_key, kid);
1277       printf ("%d:%08lX%08lX:K::%c::::\n",
1278               depth, (ulong)kid[0], (ulong)kid[1], '?');
1279
1280       for (; node; node = node->next)
1281         {
1282           if (node->pkt->pkttype == PKT_USER_ID)
1283             {
1284               int len = node->pkt->pkt.user_id->len;
1285
1286               if (len > 30)
1287                 len = 30;
1288               printf ("%d:%08lX%08lX:U:::%c:::",
1289                       depth, (ulong)kid[0], (ulong)kid[1],
1290                       (node->flag & 4)? 'f':
1291                       (node->flag & 2)? 'm':
1292                       (node->flag & 1)? 'q':'-');
1293               print_string (stdout,  node->pkt->pkt.user_id->name, len, ':');
1294               putchar (':');
1295               putchar ('\n');
1296             }
1297         }
1298     }
1299 }  
1300
1301
1302 static void
1303 store_validation_status (int depth, KBNODE keyblock, KeyHashTable stored)
1304 {
1305   KBNODE node;
1306   int status;
1307   int any = 0;
1308
1309   for (node=keyblock; node; node = node->next)
1310     {
1311       if (node->pkt->pkttype == PKT_USER_ID)
1312         {
1313           PKT_user_id *uid = node->pkt->pkt.user_id;
1314           if (node->flag & 4)
1315             status = TRUST_FULLY;
1316           else if (node->flag & 2)
1317             status = TRUST_MARGINAL;
1318           else if (node->flag & 1)
1319             status = TRUST_UNDEFINED;
1320           else
1321             status = 0;
1322           
1323           if (status)
1324             {
1325               update_validity (keyblock->pkt->pkt.public_key,
1326                                uid, depth, status);
1327
1328               mark_keyblock_seen(stored,keyblock);
1329
1330               any = 1;
1331             }
1332         }
1333     }
1334
1335   if (any)
1336     do_sync ();
1337 }  
1338
1339 /*
1340  * check whether the signature sig is in the klist k
1341  */
1342 static struct key_item *
1343 is_in_klist (struct key_item *k, PKT_signature *sig)
1344 {
1345   for (; k; k = k->next)
1346     {
1347       if (k->kid[0] == sig->keyid[0] && k->kid[1] == sig->keyid[1])
1348         return k;
1349     }
1350   return NULL;
1351 }
1352
1353 /*
1354  * Mark the signature of the given UID which are used to certify it.
1355  * To do this, we first revmove all signatures which are not valid and
1356  * from the remain ones we look for the latest one.  If this is not a
1357  * certification revocation signature we mark the signature by setting
1358  * node flag bit 8.  Note that flag bits 9 and 10 are used for internal
1359  * purposes.  
1360  */
1361 static void
1362 mark_usable_uid_certs (KBNODE keyblock, KBNODE uidnode,
1363                        u32 *main_kid, struct key_item *klist,
1364                        u32 curtime, u32 *next_expire)
1365 {
1366   KBNODE node;
1367   PKT_signature *sig;
1368   
1369   /* first check all signatures */
1370   for (node=uidnode->next; node; node = node->next)
1371     {
1372       node->flag &= ~(1<<8 | 1<<9 | 1<<10);
1373       if (node->pkt->pkttype == PKT_USER_ID
1374           || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1375         break; /* ready */
1376       if (node->pkt->pkttype != PKT_SIGNATURE)
1377         continue;
1378       
1379       sig = node->pkt->pkt.signature;
1380       if (sig->keyid[0] == main_kid[0] && sig->keyid[1] == main_kid[1])
1381         continue; /* ignore self-signatures */
1382       if (!IS_UID_SIG(sig) && !IS_UID_REV(sig))
1383         continue; /* we only look at these signature classes */
1384       if(sig->sig_class>=0x11 && sig->sig_class<=0x13 &&
1385          sig->sig_class-0x10<opt.min_cert_level)
1386         continue;
1387       if (!is_in_klist (klist, sig))
1388         continue;  /* no need to check it then */
1389       if (check_key_signature (keyblock, node, NULL))
1390         continue; /* ignore invalid signatures */
1391       node->flag |= 1<<9;
1392     }      
1393   /* reset the remaining flags */
1394   for (; node; node = node->next)
1395       node->flag &= ~(1<<8 | 1<<9 | 1 << 10);
1396
1397   /* kbnode flag usage: bit 9 is here set for signatures to consider,
1398    * bit 10 will be set by the loop to keep track of keyIDs already
1399    * processed, bit 8 will be set for the usable signatures */
1400
1401   /* for each cert figure out the latest valid one */
1402   for (node=uidnode->next; node; node = node->next)
1403     {
1404       KBNODE n, signode;
1405       u32 kid[2];
1406       u32 sigdate;
1407       
1408       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1409         break;
1410       if ( !(node->flag & (1<<9)) )
1411         continue; /* not a node to look at */
1412       if ( (node->flag & (1<<10)) )
1413         continue; /* signature with a keyID already processed */
1414       node->flag |= (1<<10); /* mark this node as processed */
1415       sig = node->pkt->pkt.signature;
1416       signode = node;
1417       sigdate = sig->timestamp;
1418       kid[0] = sig->keyid[0]; kid[1] = sig->keyid[1];
1419       for (n=uidnode->next; n; n = n->next)
1420         {
1421           if (n->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1422             break;
1423           if ( !(n->flag & (1<<9)) )
1424             continue;
1425           if ( (n->flag & (1<<10)) )
1426             continue; /* shortcut already processed signatures */
1427           sig = n->pkt->pkt.signature;
1428           if (kid[0] != sig->keyid[0] || kid[1] != sig->keyid[1])
1429             continue;
1430           n->flag |= (1<<10); /* mark this node as processed */
1431
1432           /* If signode is nonrevocable and unexpired and n isn't,
1433              then take signode (skip).  It doesn't matter which is
1434              older: if signode was older then we don't want to take n
1435              as signode is nonrevocable.  If n was older then we're
1436              automatically fine. */
1437           
1438           if(((IS_UID_SIG(signode->pkt->pkt.signature) &&
1439                !signode->pkt->pkt.signature->flags.revocable &&
1440                (signode->pkt->pkt.signature->expiredate==0 ||
1441                 signode->pkt->pkt.signature->expiredate>curtime))) &&
1442              (!(IS_UID_SIG(n->pkt->pkt.signature) &&
1443                 !n->pkt->pkt.signature->flags.revocable &&
1444                 (n->pkt->pkt.signature->expiredate==0 ||
1445                  n->pkt->pkt.signature->expiredate>curtime))))
1446             continue;
1447
1448           /* If n is nonrevocable and unexpired and signode isn't,
1449              then take n.  Again, it doesn't matter which is older: if
1450              n was older then we don't want to take signode as n is
1451              nonrevocable.  If signode was older then we're
1452              automatically fine. */
1453           
1454           if((!(IS_UID_SIG(signode->pkt->pkt.signature) &&
1455                 !signode->pkt->pkt.signature->flags.revocable &&
1456                 (signode->pkt->pkt.signature->expiredate==0 ||
1457                  signode->pkt->pkt.signature->expiredate>curtime))) &&
1458              ((IS_UID_SIG(n->pkt->pkt.signature) &&
1459                !n->pkt->pkt.signature->flags.revocable &&
1460                (n->pkt->pkt.signature->expiredate==0 ||
1461                 n->pkt->pkt.signature->expiredate>curtime))))
1462             {
1463               signode = n;
1464               sigdate = sig->timestamp;
1465               continue;
1466             }
1467
1468           /* At this point, if it's newer, it goes in as the only
1469              remaining possibilities are signode and n are both either
1470              revocable or expired or both nonrevocable and unexpired.
1471              If the timestamps are equal take the later ordered
1472              packet, presuming that the key packets are hopefully in
1473              their original order. */
1474
1475           if (sig->timestamp >= sigdate)
1476             {
1477               signode = n;
1478               sigdate = sig->timestamp;
1479             }
1480         }
1481       sig = signode->pkt->pkt.signature;
1482       if (IS_UID_SIG (sig))
1483         { /* this seems to be a usable one which is not revoked. 
1484            * Just need to check whether there is an expiration time,
1485            * We do the expired certification after finding a suitable
1486            * certification, the assumption is that a signator does not
1487            * want that after the expiration of his certificate the
1488            * system falls back to an older certification which has a
1489            * different expiration time */
1490           const byte *p;
1491           u32 expire;
1492                     
1493           p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_SIG_EXPIRE, NULL );
1494           expire = p? sig->timestamp + buffer_to_u32(p) : 0;
1495
1496           if (expire==0 || expire > curtime )
1497             {
1498               signode->flag |= (1<<8); /* yeah, found a good cert */
1499               if (expire && expire < *next_expire)
1500                 *next_expire = expire;
1501             }
1502         }
1503     }
1504 }
1505
1506 /* Used by validate_one_keyblock to confirm a regexp within a trust
1507    signature.  Returns 1 for match, and 0 for no match or regex
1508    error. */
1509 static int
1510 check_regexp(const char *expr,const char *string)
1511 {
1512 #ifdef DISABLE_REGEX
1513   /* When DISABLE_REGEX is defined, assume all regexps do not
1514      match. */
1515   return 0;
1516 #elif defined(__riscos__)
1517   return riscos_check_regexp(expr, string, DBG_TRUST);
1518 #else
1519   int ret;
1520   regex_t pat;
1521
1522   if(regcomp(&pat,expr,REG_ICASE|REG_NOSUB|REG_EXTENDED)!=0)
1523     return 0;
1524
1525   ret=regexec(&pat,string,0,NULL,0);
1526
1527   regfree(&pat);
1528
1529   if(DBG_TRUST)
1530     log_debug("regexp \"%s\" on \"%s\": %s\n",expr,string,ret==0?"YES":"NO");
1531
1532   return (ret==0);
1533 #endif
1534 }
1535
1536 /*
1537  * Return true if the key is signed by one of the keys in the given
1538  * key ID list.  User IDs with a valid signature are marked by node
1539  * flags as follows:
1540  *  flag bit 0: There is at least one signature
1541  *           1: There is marginal confidence that this is a legitimate uid
1542  *           2: There is full confidence that this is a legitimate uid.
1543  *           8: Used for internal purposes.
1544  *           9: Ditto (in mark_usable_uid_certs())
1545  *          10: Ditto (ditto)
1546  * This function assumes that all kbnode flags are cleared on entry.
1547  */
1548 static int
1549 validate_one_keyblock (KBNODE kb, struct key_item *klist,
1550                        u32 curtime, u32 *next_expire)
1551 {
1552   struct key_item *kr;
1553   KBNODE node, uidnode=NULL;
1554   PKT_user_id *uid=NULL;
1555   PKT_public_key *pk = kb->pkt->pkt.public_key;
1556   u32 main_kid[2];
1557   int issigned=0, any_signed = 0;
1558
1559   keyid_from_pk(pk, main_kid);
1560   for (node=kb; node; node = node->next)
1561     {
1562       /* A bit of discussion here: is it better for the web of trust
1563          to be built among only self-signed uids?  On the one hand, a
1564          self-signed uid is a statement that the key owner definitely
1565          intended that uid to be there, but on the other hand, a
1566          signed (but not self-signed) uid does carry trust, of a sort,
1567          even if it is a statement being made by people other than the
1568          key owner "through" the uids on the key owner's key.  I'm
1569          going with the latter.  However, if the user ID was
1570          explicitly revoked, or passively allowed to expire, that
1571          should stop validity through the user ID until it is
1572          resigned.  -dshaw */
1573
1574       if (node->pkt->pkttype == PKT_USER_ID
1575           && !node->pkt->pkt.user_id->is_revoked
1576           && !node->pkt->pkt.user_id->is_expired)
1577         {
1578           if (uidnode && issigned)
1579             {
1580               if (uid->help_full_count >= opt.completes_needed
1581                   || uid->help_marginal_count >= opt.marginals_needed )
1582                 uidnode->flag |= 4; 
1583               else if (uid->help_full_count || uid->help_marginal_count)
1584                 uidnode->flag |= 2;
1585               uidnode->flag |= 1;
1586               any_signed = 1;
1587             }
1588           uidnode = node;
1589           uid=uidnode->pkt->pkt.user_id;
1590
1591           /* If the selfsig is going to expire... */
1592           if(uid->expiredate && uid->expiredate<*next_expire)
1593             *next_expire = uid->expiredate;
1594
1595           issigned = 0;
1596           get_validity_counts(pk,uid);
1597           mark_usable_uid_certs (kb, uidnode, main_kid, klist, 
1598                                  curtime, next_expire);
1599         }
1600       else if (node->pkt->pkttype == PKT_SIGNATURE
1601                && (node->flag & (1<<8)) && uid)
1602         {
1603           /* Note that we are only seeing unrevoked sigs here */
1604           PKT_signature *sig = node->pkt->pkt.signature;
1605           
1606           kr = is_in_klist (klist, sig);
1607           /* If the trust_regexp does not match, it's as if the sig
1608              did not exist.  This is safe for non-trust sigs as well
1609              since we don't accept a regexp on the sig unless it's a
1610              trust sig. */
1611           if (kr && (kr->trust_regexp==NULL || opt.trust_model!=TM_PGP ||
1612                      (uidnode && check_regexp(kr->trust_regexp,
1613                                             uidnode->pkt->pkt.user_id->name))))
1614             {
1615               if(DBG_TRUST && opt.trust_model==TM_PGP && sig->trust_depth)
1616                 log_debug("trust sig on %s, sig depth is %d, kr depth is %d\n",
1617                           uidnode->pkt->pkt.user_id->name,sig->trust_depth,
1618                           kr->trust_depth);
1619
1620               /* Are we part of a trust sig chain?  We always favor
1621                  the latest trust sig, rather than the greater or
1622                  lesser trust sig or value.  I could make a decent
1623                  argument for any of these cases, but this seems to be
1624                  what PGP does, and I'd like to be compatible. -dms */
1625               if(opt.trust_model==TM_PGP && sig->trust_depth
1626                  && pk->trust_timestamp<=sig->timestamp
1627                  && (sig->trust_depth<=kr->trust_depth
1628                      || kr->ownertrust==TRUST_ULTIMATE))
1629                 {
1630                   /* If we got here, we know that:
1631
1632                      this is a trust sig.
1633
1634                      it's a newer trust sig than any previous trust
1635                      sig on this key (not uid).
1636
1637                      it is legal in that it was either generated by an
1638                      ultimate key, or a key that was part of a trust
1639                      chain, and the depth does not violate the
1640                      original trust sig.
1641
1642                      if there is a regexp attached, it matched
1643                      successfully.
1644                   */
1645
1646                   if(DBG_TRUST)
1647                     log_debug("replacing trust value %d with %d and "
1648                               "depth %d with %d\n",
1649                               pk->trust_value,sig->trust_value,
1650                               pk->trust_depth,sig->trust_depth);
1651
1652                   pk->trust_value=sig->trust_value;
1653                   pk->trust_depth=sig->trust_depth-1;
1654
1655                   /* If the trust sig contains a regexp, record it
1656                      on the pk for the next round. */
1657                   if(sig->trust_regexp)
1658                     pk->trust_regexp=sig->trust_regexp;
1659                 }
1660
1661               if (kr->ownertrust == TRUST_ULTIMATE)
1662                 uid->help_full_count = opt.completes_needed;
1663               else if (kr->ownertrust == TRUST_FULLY)
1664                 uid->help_full_count++;
1665               else if (kr->ownertrust == TRUST_MARGINAL)
1666                 uid->help_marginal_count++;
1667               issigned = 1;
1668             }
1669         }
1670     }
1671
1672   if (uidnode && issigned)
1673     {
1674       if (uid->help_full_count >= opt.completes_needed
1675           || uid->help_marginal_count >= opt.marginals_needed )
1676         uidnode->flag |= 4; 
1677       else if (uid->help_full_count || uid->help_marginal_count)
1678         uidnode->flag |= 2;
1679       uidnode->flag |= 1;
1680       any_signed = 1;
1681     }
1682
1683   return any_signed;
1684 }
1685
1686
1687 static int
1688 search_skipfnc (void *opaque, u32 *kid, PKT_user_id *dummy)
1689 {
1690   return test_key_hash_table ((KeyHashTable)opaque, kid);
1691 }
1692
1693
1694 /*
1695  * Scan all keys and return a key_array of all suitable keys from
1696  * kllist.  The caller has to pass keydb handle so that we don't use
1697  * to create our own.  Returns either a key_array or NULL in case of
1698  * an error.  No results found are indicated by an empty array.
1699  * Caller hast to release the returned array.  
1700  */
1701 static struct key_array *
1702 validate_key_list (KEYDB_HANDLE hd, KeyHashTable full_trust,
1703                    struct key_item *klist, u32 curtime, u32 *next_expire)
1704 {
1705   KBNODE keyblock = NULL;
1706   struct key_array *keys = NULL;
1707   size_t nkeys, maxkeys;
1708   int rc;
1709   KEYDB_SEARCH_DESC desc;
1710   
1711   maxkeys = 1000;
1712   keys = m_alloc ((maxkeys+1) * sizeof *keys);
1713   nkeys = 0;
1714   
1715   rc = keydb_search_reset (hd);
1716   if (rc)
1717     {
1718       log_error ("keydb_search_reset failed: %s\n", g10_errstr(rc));
1719       m_free (keys);
1720       return NULL;
1721     }
1722
1723   memset (&desc, 0, sizeof desc);
1724   desc.mode = KEYDB_SEARCH_MODE_FIRST;
1725   desc.skipfnc = search_skipfnc;
1726   desc.skipfncvalue = full_trust;
1727   rc = keydb_search (hd, &desc, 1);
1728   if (rc == -1)
1729     {
1730       keys[nkeys].keyblock = NULL;
1731       return keys;
1732     }
1733   if (rc)
1734     {
1735       log_error ("keydb_search_first failed: %s\n", g10_errstr(rc));
1736       m_free (keys);
1737       return NULL;
1738     }
1739   
1740   desc.mode = KEYDB_SEARCH_MODE_NEXT; /* change mode */
1741   do
1742     {
1743       PKT_public_key *pk;
1744         
1745       rc = keydb_get_keyblock (hd, &keyblock);
1746       if (rc) 
1747         {
1748           log_error ("keydb_get_keyblock failed: %s\n", g10_errstr(rc));
1749           m_free (keys);
1750           return NULL;
1751         }
1752       
1753       if ( keyblock->pkt->pkttype != PKT_PUBLIC_KEY) 
1754         {
1755           log_debug ("ooops: invalid pkttype %d encountered\n",
1756                      keyblock->pkt->pkttype);
1757           dump_kbnode (keyblock);
1758           release_kbnode(keyblock);
1759           continue;
1760         }
1761
1762       /* prepare the keyblock for further processing */
1763       merge_keys_and_selfsig (keyblock); 
1764       clear_kbnode_flags (keyblock);
1765       pk = keyblock->pkt->pkt.public_key;
1766       if (pk->has_expired || pk->is_revoked)
1767         {
1768           /* it does not make sense to look further at those keys */
1769           mark_keyblock_seen (full_trust, keyblock);
1770         }
1771       else if (validate_one_keyblock (keyblock, klist, curtime, next_expire))
1772         {
1773           KBNODE node;
1774
1775           if (pk->expiredate && pk->expiredate >= curtime
1776               && pk->expiredate < *next_expire)
1777             *next_expire = pk->expiredate;
1778
1779           if (nkeys == maxkeys) {
1780             maxkeys += 1000;
1781             keys = m_realloc (keys, (maxkeys+1) * sizeof *keys);
1782           }
1783           keys[nkeys++].keyblock = keyblock;
1784
1785           /* Optimization - if all uids are fully trusted, then we
1786              never need to consider this key as a candidate again. */
1787
1788           for (node=keyblock; node; node = node->next)
1789             if (node->pkt->pkttype == PKT_USER_ID && !(node->flag & 4))
1790               break;
1791
1792           if(node==NULL)
1793             mark_keyblock_seen (full_trust, keyblock);
1794
1795           keyblock = NULL;
1796         }
1797
1798       release_kbnode (keyblock);
1799       keyblock = NULL;
1800     } 
1801   while ( !(rc = keydb_search (hd, &desc, 1)) );
1802   if (rc && rc != -1) 
1803     {
1804       log_error ("keydb_search_next failed: %s\n", g10_errstr(rc));
1805       m_free (keys);
1806       return NULL;
1807     }
1808
1809   keys[nkeys].keyblock = NULL;
1810   return keys;
1811
1812
1813 /* Caller must sync */
1814 static void
1815 reset_trust_records(void)
1816 {
1817   TRUSTREC rec;
1818   ulong recnum;
1819   int count = 0, nreset = 0;
1820
1821   for (recnum=1; !tdbio_read_record (recnum, &rec, 0); recnum++ ) 
1822     {
1823       if(rec.rectype==RECTYPE_TRUST)
1824         {
1825           count++;
1826           if(rec.r.trust.min_ownertrust)
1827             {
1828               rec.r.trust.min_ownertrust=0;
1829               write_record(&rec);
1830             }
1831
1832         }
1833       else if(rec.rectype==RECTYPE_VALID
1834               && ((rec.r.valid.validity&TRUST_MASK)
1835                   || rec.r.valid.marginal_count
1836                   || rec.r.valid.full_count))
1837         {
1838           rec.r.valid.validity &= ~TRUST_MASK;
1839           rec.r.valid.marginal_count=rec.r.valid.full_count=0;
1840           nreset++;
1841           write_record(&rec);
1842         }
1843
1844     }
1845
1846   if (opt.verbose)
1847     log_info (_("%d keys processed (%d validity counts cleared)\n"),
1848               count, nreset);
1849 }
1850
1851 /*
1852  * Run the key validation procedure.
1853  *
1854  * This works this way:
1855  * Step 1: Find all ultimately trusted keys (UTK).
1856  *         mark them all as seen and put them into klist.
1857  * Step 2: loop max_cert_times
1858  * Step 3:   if OWNERTRUST of any key in klist is undefined
1859  *             ask user to assign ownertrust
1860  * Step 4:   Loop over all keys in the keyDB which are not marked seen 
1861  * Step 5:     if key is revoked or expired
1862  *                mark key as seen
1863  *                continue loop at Step 4
1864  * Step 6:     For each user ID of that key signed by a key in klist
1865  *                Calculate validity by counting trusted signatures.
1866  *                Set validity of user ID
1867  * Step 7:     If any signed user ID was found
1868  *                mark key as seen
1869  *             End Loop
1870  * Step 8:   Build a new klist from all fully trusted keys from step 6
1871  *           End Loop
1872  *         Ready  
1873  *
1874  */
1875 static int
1876 validate_keys (int interactive)
1877 {
1878   int rc = 0;
1879   int quit=0;
1880   struct key_item *klist = NULL;
1881   struct key_item *k;
1882   struct key_array *keys = NULL;
1883   struct key_array *kar;
1884   KEYDB_HANDLE kdb = NULL;
1885   KBNODE node;
1886   int depth;
1887   int ot_unknown, ot_undefined, ot_never, ot_marginal, ot_full, ot_ultimate;
1888   KeyHashTable stored,used,full_trust;
1889   u32 start_time, next_expire;
1890
1891   /* Make sure we have all sigs cached.  TODO: This is going to
1892      require some architectual re-thinking, as it is agonizingly slow.
1893      Perhaps combine this with reset_trust_records(), or only check
1894      the caches on keys that are actually involved in the web of
1895      trust. */
1896   keydb_rebuild_caches(0);
1897
1898   start_time = make_timestamp ();
1899   next_expire = 0xffffffff; /* set next expire to the year 2106 */
1900   stored = new_key_hash_table ();
1901   used = new_key_hash_table ();
1902   full_trust = new_key_hash_table ();
1903
1904   kdb = keydb_new (0);
1905   reset_trust_records();
1906
1907   /* Fixme: Instead of always building a UTK list, we could just build it
1908    * here when needed */
1909   if (!utk_list)
1910     {
1911       log_info (_("no ultimately trusted keys found\n"));
1912       goto leave;
1913     }
1914
1915   /* mark all UTKs as used and fully_trusted and set validity to
1916      ultimate */
1917   for (k=utk_list; k; k = k->next)
1918     {
1919       KBNODE keyblock;
1920       PKT_public_key *pk;
1921
1922       keyblock = get_pubkeyblock (k->kid);
1923       if (!keyblock)
1924         {
1925           log_error (_("public key of ultimately"
1926                        " trusted key %s not found\n"), keystr(k->kid));
1927           continue;
1928         }
1929       mark_keyblock_seen (used, keyblock);
1930       mark_keyblock_seen (stored, keyblock);
1931       mark_keyblock_seen (full_trust, keyblock);
1932       pk = keyblock->pkt->pkt.public_key;
1933       for (node=keyblock; node; node = node->next)
1934         {
1935           if (node->pkt->pkttype == PKT_USER_ID)
1936             update_validity (pk, node->pkt->pkt.user_id, 0, TRUST_ULTIMATE);
1937         }
1938       if ( pk->expiredate && pk->expiredate >= start_time
1939            && pk->expiredate < next_expire)
1940         next_expire = pk->expiredate;
1941       
1942       release_kbnode (keyblock);
1943       do_sync ();
1944     }
1945
1946   klist = utk_list;
1947
1948   log_info(_("%d marginal(s) needed, %d complete(s) needed, %s trust model\n"),
1949            opt.marginals_needed,opt.completes_needed,trust_model_string());
1950
1951   for (depth=0; depth < opt.max_cert_depth; depth++)
1952     {
1953       int valids=0,key_count;
1954       /* See whether we should assign ownertrust values to the keys in
1955          klist.  */
1956       ot_unknown = ot_undefined = ot_never = 0;
1957       ot_marginal = ot_full = ot_ultimate = 0;
1958       for (k=klist; k; k = k->next)
1959         {
1960           int min=0;
1961
1962           /* 120 and 60 are as per RFC2440 */
1963           if(k->trust_value>=120)
1964             min=TRUST_FULLY;
1965           else if(k->trust_value>=60)
1966             min=TRUST_MARGINAL;
1967
1968           if(min!=k->min_ownertrust)
1969             update_min_ownertrust(k->kid,min);
1970
1971           if (interactive && k->ownertrust == TRUST_UNKNOWN)
1972             {
1973               k->ownertrust = ask_ownertrust (k->kid,min);
1974
1975               if (k->ownertrust == -1)
1976                 {
1977                   quit=1;
1978                   goto leave;
1979                 }
1980             }
1981
1982           /* This can happen during transition from an old trustdb
1983              before trust sigs.  It can also happen if a user uses two
1984              different versions of GnuPG or changes the --trust-model
1985              setting. */
1986           if(k->ownertrust<min)
1987             {
1988               if(DBG_TRUST)
1989                 log_debug("key %08lX%08lX:"
1990                           " overriding ownertrust \"%s\" with \"%s\"\n",
1991                           (ulong)k->kid[0],(ulong)k->kid[1],
1992                           trust_value_to_string(k->ownertrust),
1993                           trust_value_to_string(min));
1994
1995               k->ownertrust=min;
1996             }
1997
1998           if (k->ownertrust == TRUST_UNKNOWN)
1999             ot_unknown++;
2000           else if (k->ownertrust == TRUST_UNDEFINED)
2001             ot_undefined++;
2002           else if (k->ownertrust == TRUST_NEVER)
2003             ot_never++;
2004           else if (k->ownertrust == TRUST_MARGINAL)
2005             ot_marginal++;
2006           else if (k->ownertrust == TRUST_FULLY)
2007             ot_full++;
2008           else if (k->ownertrust == TRUST_ULTIMATE)
2009             ot_ultimate++;
2010
2011           valids++;
2012         }
2013
2014       /* Find all keys which are signed by a key in kdlist */
2015       keys = validate_key_list (kdb, full_trust, klist,
2016                                 start_time, &next_expire);
2017       if (!keys) 
2018         {
2019           log_error ("validate_key_list failed\n");
2020           rc = G10ERR_GENERAL;
2021           goto leave;
2022         }
2023
2024       for (key_count=0, kar=keys; kar->keyblock; kar++, key_count++)
2025         ;
2026
2027       /* Store the calculated valididation status somewhere */
2028       if (opt.verbose > 1)
2029         dump_key_array (depth, keys);
2030
2031       for (kar=keys; kar->keyblock; kar++)
2032           store_validation_status (depth, kar->keyblock, stored);
2033
2034       log_info (_("depth: %d  valid: %3d  signed: %3d"
2035                   "  trust: %d-, %dq, %dn, %dm, %df, %du\n"), 
2036                 depth, valids, key_count, ot_unknown, ot_undefined,
2037                 ot_never, ot_marginal, ot_full, ot_ultimate ); 
2038
2039       /* Build a new kdlist from all fully valid keys in KEYS */
2040       if (klist != utk_list)
2041         release_key_items (klist);
2042       klist = NULL;
2043       for (kar=keys; kar->keyblock; kar++)
2044         {
2045           for (node=kar->keyblock; node; node = node->next)
2046             {
2047               if (node->pkt->pkttype == PKT_USER_ID && (node->flag & 4))
2048                 {
2049                   u32 kid[2];
2050
2051                   /* have we used this key already? */
2052                   keyid_from_pk (kar->keyblock->pkt->pkt.public_key, kid);
2053                   if(test_key_hash_table(used,kid)==0)
2054                     {
2055                       /* Normally we add both the primary and subkey
2056                          ids to the hash via mark_keyblock_seen, but
2057                          since we aren't using this hash as a skipfnc,
2058                          that doesn't matter here. */
2059                       add_key_hash_table (used,kid);
2060                       k = new_key_item ();
2061                       k->kid[0]=kid[0];
2062                       k->kid[1]=kid[1];
2063                       k->ownertrust =
2064                         (get_ownertrust (kar->keyblock->pkt->pkt.public_key)
2065                          & TRUST_MASK);
2066                       k->min_ownertrust =
2067                         get_min_ownertrust(kar->keyblock->pkt->pkt.public_key);
2068                       k->trust_depth=
2069                         kar->keyblock->pkt->pkt.public_key->trust_depth;
2070                       k->trust_value=
2071                         kar->keyblock->pkt->pkt.public_key->trust_value;
2072                       if(kar->keyblock->pkt->pkt.public_key->trust_regexp)
2073                         k->trust_regexp=
2074                           m_strdup(kar->keyblock->pkt->
2075                                    pkt.public_key->trust_regexp);
2076                       k->next = klist;
2077                       klist = k;
2078                       break;
2079                     }
2080                 }
2081             }
2082         }
2083       release_key_array (keys);
2084       keys = NULL;
2085       if (!klist)
2086         break; /* no need to dive in deeper */
2087     }
2088
2089  leave:
2090   keydb_release (kdb);
2091   release_key_array (keys);
2092   release_key_items (klist);
2093   release_key_hash_table (full_trust);
2094   release_key_hash_table (used);
2095   release_key_hash_table (stored);
2096   if (!rc && !quit) /* mark trustDB as checked */
2097     {
2098       if (next_expire == 0xffffffff || next_expire < start_time )
2099         tdbio_write_nextcheck (0); 
2100       else
2101         {
2102           tdbio_write_nextcheck (next_expire); 
2103           log_info (_("next trustdb check due at %s\n"),
2104                     strtimestamp (next_expire));
2105         }
2106
2107       if(tdbio_update_version_record()!=0)
2108         {
2109           log_error(_("unable to update trustdb version record: "
2110                       "write failed: %s\n"), g10_errstr(rc));
2111           tdbio_invalid();
2112         }
2113
2114       do_sync ();
2115       pending_check_trustdb = 0;
2116     }
2117
2118   return rc;
2119 }