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