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