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