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