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