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