* pkclist.c (do_edit_ownertrust): Different prompt when we're using direct
[gnupg.git] / g10 / trustdb.c
1 /* trustdb.c
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003,
3  *               2004 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 %s: accepted as trusted key\n"), keystr(kid));
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 %s occurs more than once in the trustdb\n"),
296                        keystr(kid));
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 %s: no public key for trusted key - skipped\n"),
311                      keystr(k->kid));
312           else
313             {
314               update_ownertrust (&pk,
315                                  ((get_ownertrust (&pk) & ~TRUST_MASK)
316                                   | TRUST_ULTIMATE ));
317               release_public_key_parts (&pk);
318             }
319
320           log_info (_("key %s marked as ultimately trusted\n"),keystr(k->kid));
321         }
322     }
323
324   /* release the helper table table */
325   release_key_items (user_utk_list);
326   user_utk_list = NULL;
327   return;
328 }
329
330 \f
331 /*********************************************
332  *********** TrustDB stuff *******************
333  *********************************************/
334
335 /*
336  * Read a record but die if it does not exist
337  */
338 static void
339 read_record (ulong recno, TRUSTREC *rec, int rectype )
340 {
341   int rc = tdbio_read_record (recno, rec, rectype);
342   if (rc)
343     {
344       log_error(_("trust record %lu, req type %d: read failed: %s\n"),
345                 recno, rec->rectype, g10_errstr(rc) );
346       tdbio_invalid();
347     }
348   if (rectype != rec->rectype)
349     {
350       log_error(_("trust record %lu is not of requested type %d\n"),
351                 rec->recnum, rectype);
352       tdbio_invalid();
353     }
354 }
355
356 /*
357  * Write a record and die on error
358  */
359 static void
360 write_record (TRUSTREC *rec)
361 {
362   int rc = tdbio_write_record (rec);
363   if (rc)
364     {
365       log_error(_("trust record %lu, type %d: write failed: %s\n"),
366                             rec->recnum, rec->rectype, g10_errstr(rc) );
367       tdbio_invalid();
368     }
369 }
370
371 /*
372  * sync the TrustDb and die on error
373  */
374 static void
375 do_sync(void)
376 {
377     int rc = tdbio_sync ();
378     if(rc)
379       {
380         log_error (_("trustdb: sync failed: %s\n"), g10_errstr(rc) );
381         g10_exit(2);
382       }
383 }
384
385 static const char *
386 trust_model_string(void)
387 {
388   switch(opt.trust_model)
389     {
390     case TM_CLASSIC:  return "classic";
391     case TM_PGP:      return "PGP";
392     case TM_EXTERNAL: return "external";
393     case TM_ALWAYS:   return "always";
394     case TM_DIRECT:   return "direct";
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 %s not found: %s\n"),keystr(kid),g10_errstr(rc));
794       return;
795     }
796
797   rc = read_trust_record (pk, &rec);
798   if (!rc)
799     {
800       if (DBG_TRUST)
801         log_debug ("key %08lX%08lX: update min_ownertrust from %u to %u\n",
802                    (ulong)kid[0],(ulong)kid[1],
803                    (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           char *tempkeystr=m_strdup(keystr(pk->main_keyid));
1028           log_error ("error getting main key %s of subkey %s: %s\n",
1029                      tempkeystr, keystr(kid), g10_errstr(rc));
1030           m_free(tempkeystr);
1031           validity = TRUST_UNKNOWN; 
1032           goto leave;
1033         }
1034     }
1035   else
1036     main_pk = pk;
1037
1038   if(opt.trust_model==TM_DIRECT)
1039     {
1040       /* Note that this happens BEFORE any user ID stuff is checked.
1041          The direct trust model applies to keys as a whole. */
1042       validity=get_ownertrust(main_pk);
1043       goto leave;
1044     }
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 = m_alloc_clear (sizeof *pk);
1228   rc = get_pubkey (pk, kid);
1229   if (rc)
1230     {
1231       log_error (_("public key %s not found: %s\n"),
1232                  keystr(kid), g10_errstr(rc) );
1233       return TRUST_UNKNOWN;
1234     }
1235  
1236   if(opt.force_ownertrust)
1237     {
1238       log_info("force trust for key %s to %s\n",
1239                keystr(kid),trust_value_to_string(opt.force_ownertrust));
1240       update_ownertrust(pk,opt.force_ownertrust);
1241       ot=opt.force_ownertrust;
1242     }
1243   else
1244     {
1245       ot=edit_ownertrust(pk,0);
1246       if(ot>0)
1247         ot = get_ownertrust (pk);
1248       else if(ot==0)
1249         ot = minimum?minimum:TRUST_UNDEFINED;
1250       else
1251         ot = -1; /* quit */
1252     }
1253
1254   free_public_key( pk );
1255
1256   return ot;
1257 }
1258
1259
1260 static void
1261 mark_keyblock_seen (KeyHashTable tbl, KBNODE node)
1262 {
1263   for ( ;node; node = node->next )
1264     if (node->pkt->pkttype == PKT_PUBLIC_KEY
1265         || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1266       {
1267         u32 aki[2];
1268
1269         keyid_from_pk (node->pkt->pkt.public_key, aki);
1270         add_key_hash_table (tbl, aki);
1271       }
1272 }
1273
1274
1275 static void
1276 dump_key_array (int depth, struct key_array *keys)
1277 {
1278   struct key_array *kar;
1279
1280   for (kar=keys; kar->keyblock; kar++)
1281     {
1282       KBNODE node = kar->keyblock;
1283       u32 kid[2];
1284
1285       keyid_from_pk(node->pkt->pkt.public_key, kid);
1286       printf ("%d:%08lX%08lX:K::%c::::\n",
1287               depth, (ulong)kid[0], (ulong)kid[1], '?');
1288
1289       for (; node; node = node->next)
1290         {
1291           if (node->pkt->pkttype == PKT_USER_ID)
1292             {
1293               int len = node->pkt->pkt.user_id->len;
1294
1295               if (len > 30)
1296                 len = 30;
1297               printf ("%d:%08lX%08lX:U:::%c:::",
1298                       depth, (ulong)kid[0], (ulong)kid[1],
1299                       (node->flag & 4)? 'f':
1300                       (node->flag & 2)? 'm':
1301                       (node->flag & 1)? 'q':'-');
1302               print_string (stdout,  node->pkt->pkt.user_id->name, len, ':');
1303               putchar (':');
1304               putchar ('\n');
1305             }
1306         }
1307     }
1308 }  
1309
1310
1311 static void
1312 store_validation_status (int depth, KBNODE keyblock, KeyHashTable stored)
1313 {
1314   KBNODE node;
1315   int status;
1316   int any = 0;
1317
1318   for (node=keyblock; node; node = node->next)
1319     {
1320       if (node->pkt->pkttype == PKT_USER_ID)
1321         {
1322           PKT_user_id *uid = node->pkt->pkt.user_id;
1323           if (node->flag & 4)
1324             status = TRUST_FULLY;
1325           else if (node->flag & 2)
1326             status = TRUST_MARGINAL;
1327           else if (node->flag & 1)
1328             status = TRUST_UNDEFINED;
1329           else
1330             status = 0;
1331           
1332           if (status)
1333             {
1334               update_validity (keyblock->pkt->pkt.public_key,
1335                                uid, depth, status);
1336
1337               mark_keyblock_seen(stored,keyblock);
1338
1339               any = 1;
1340             }
1341         }
1342     }
1343
1344   if (any)
1345     do_sync ();
1346 }  
1347
1348 /*
1349  * check whether the signature sig is in the klist k
1350  */
1351 static struct key_item *
1352 is_in_klist (struct key_item *k, PKT_signature *sig)
1353 {
1354   for (; k; k = k->next)
1355     {
1356       if (k->kid[0] == sig->keyid[0] && k->kid[1] == sig->keyid[1])
1357         return k;
1358     }
1359   return NULL;
1360 }
1361
1362 /*
1363  * Mark the signature of the given UID which are used to certify it.
1364  * To do this, we first revmove all signatures which are not valid and
1365  * from the remain ones we look for the latest one.  If this is not a
1366  * certification revocation signature we mark the signature by setting
1367  * node flag bit 8.  Note that flag bits 9 and 10 are used for internal
1368  * purposes.  
1369  */
1370 static void
1371 mark_usable_uid_certs (KBNODE keyblock, KBNODE uidnode,
1372                        u32 *main_kid, struct key_item *klist,
1373                        u32 curtime, u32 *next_expire)
1374 {
1375   KBNODE node;
1376   PKT_signature *sig;
1377   
1378   /* first check all signatures */
1379   for (node=uidnode->next; node; node = node->next)
1380     {
1381       node->flag &= ~(1<<8 | 1<<9 | 1<<10);
1382       if (node->pkt->pkttype == PKT_USER_ID
1383           || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1384         break; /* ready */
1385       if (node->pkt->pkttype != PKT_SIGNATURE)
1386         continue;
1387       
1388       sig = node->pkt->pkt.signature;
1389       if (sig->keyid[0] == main_kid[0] && sig->keyid[1] == main_kid[1])
1390         continue; /* ignore self-signatures */
1391       if (!IS_UID_SIG(sig) && !IS_UID_REV(sig))
1392         continue; /* we only look at these signature classes */
1393       if(sig->sig_class>=0x11 && sig->sig_class<=0x13 &&
1394          sig->sig_class-0x10<opt.min_cert_level)
1395         continue;
1396       if (!is_in_klist (klist, sig))
1397         continue;  /* no need to check it then */
1398       if (check_key_signature (keyblock, node, NULL))
1399         continue; /* ignore invalid signatures */
1400       node->flag |= 1<<9;
1401     }      
1402   /* reset the remaining flags */
1403   for (; node; node = node->next)
1404       node->flag &= ~(1<<8 | 1<<9 | 1 << 10);
1405
1406   /* kbnode flag usage: bit 9 is here set for signatures to consider,
1407    * bit 10 will be set by the loop to keep track of keyIDs already
1408    * processed, bit 8 will be set for the usable signatures */
1409
1410   /* for each cert figure out the latest valid one */
1411   for (node=uidnode->next; node; node = node->next)
1412     {
1413       KBNODE n, signode;
1414       u32 kid[2];
1415       u32 sigdate;
1416       
1417       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1418         break;
1419       if ( !(node->flag & (1<<9)) )
1420         continue; /* not a node to look at */
1421       if ( (node->flag & (1<<10)) )
1422         continue; /* signature with a keyID already processed */
1423       node->flag |= (1<<10); /* mark this node as processed */
1424       sig = node->pkt->pkt.signature;
1425       signode = node;
1426       sigdate = sig->timestamp;
1427       kid[0] = sig->keyid[0]; kid[1] = sig->keyid[1];
1428       for (n=uidnode->next; n; n = n->next)
1429         {
1430           if (n->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1431             break;
1432           if ( !(n->flag & (1<<9)) )
1433             continue;
1434           if ( (n->flag & (1<<10)) )
1435             continue; /* shortcut already processed signatures */
1436           sig = n->pkt->pkt.signature;
1437           if (kid[0] != sig->keyid[0] || kid[1] != sig->keyid[1])
1438             continue;
1439           n->flag |= (1<<10); /* mark this node as processed */
1440
1441           /* If signode is nonrevocable and unexpired and n isn't,
1442              then take signode (skip).  It doesn't matter which is
1443              older: if signode was older then we don't want to take n
1444              as signode is nonrevocable.  If n was older then we're
1445              automatically fine. */
1446           
1447           if(((IS_UID_SIG(signode->pkt->pkt.signature) &&
1448                !signode->pkt->pkt.signature->flags.revocable &&
1449                (signode->pkt->pkt.signature->expiredate==0 ||
1450                 signode->pkt->pkt.signature->expiredate>curtime))) &&
1451              (!(IS_UID_SIG(n->pkt->pkt.signature) &&
1452                 !n->pkt->pkt.signature->flags.revocable &&
1453                 (n->pkt->pkt.signature->expiredate==0 ||
1454                  n->pkt->pkt.signature->expiredate>curtime))))
1455             continue;
1456
1457           /* If n is nonrevocable and unexpired and signode isn't,
1458              then take n.  Again, it doesn't matter which is older: if
1459              n was older then we don't want to take signode as n is
1460              nonrevocable.  If signode was older then we're
1461              automatically fine. */
1462           
1463           if((!(IS_UID_SIG(signode->pkt->pkt.signature) &&
1464                 !signode->pkt->pkt.signature->flags.revocable &&
1465                 (signode->pkt->pkt.signature->expiredate==0 ||
1466                  signode->pkt->pkt.signature->expiredate>curtime))) &&
1467              ((IS_UID_SIG(n->pkt->pkt.signature) &&
1468                !n->pkt->pkt.signature->flags.revocable &&
1469                (n->pkt->pkt.signature->expiredate==0 ||
1470                 n->pkt->pkt.signature->expiredate>curtime))))
1471             {
1472               signode = n;
1473               sigdate = sig->timestamp;
1474               continue;
1475             }
1476
1477           /* At this point, if it's newer, it goes in as the only
1478              remaining possibilities are signode and n are both either
1479              revocable or expired or both nonrevocable and unexpired.
1480              If the timestamps are equal take the later ordered
1481              packet, presuming that the key packets are hopefully in
1482              their original order. */
1483
1484           if (sig->timestamp >= sigdate)
1485             {
1486               signode = n;
1487               sigdate = sig->timestamp;
1488             }
1489         }
1490       sig = signode->pkt->pkt.signature;
1491       if (IS_UID_SIG (sig))
1492         { /* this seems to be a usable one which is not revoked. 
1493            * Just need to check whether there is an expiration time,
1494            * We do the expired certification after finding a suitable
1495            * certification, the assumption is that a signator does not
1496            * want that after the expiration of his certificate the
1497            * system falls back to an older certification which has a
1498            * different expiration time */
1499           const byte *p;
1500           u32 expire;
1501                     
1502           p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_SIG_EXPIRE, NULL );
1503           expire = p? sig->timestamp + buffer_to_u32(p) : 0;
1504
1505           if (expire==0 || expire > curtime )
1506             {
1507               signode->flag |= (1<<8); /* yeah, found a good cert */
1508               if (expire && expire < *next_expire)
1509                 *next_expire = expire;
1510             }
1511         }
1512     }
1513 }
1514
1515 /* Used by validate_one_keyblock to confirm a regexp within a trust
1516    signature.  Returns 1 for match, and 0 for no match or regex
1517    error. */
1518 static int
1519 check_regexp(const char *expr,const char *string)
1520 {
1521 #ifdef DISABLE_REGEX
1522   /* When DISABLE_REGEX is defined, assume all regexps do not
1523      match. */
1524   return 0;
1525 #elif defined(__riscos__)
1526   return riscos_check_regexp(expr, string, DBG_TRUST);
1527 #else
1528   int ret;
1529   regex_t pat;
1530
1531   if(regcomp(&pat,expr,REG_ICASE|REG_NOSUB|REG_EXTENDED)!=0)
1532     return 0;
1533
1534   ret=regexec(&pat,string,0,NULL,0);
1535
1536   regfree(&pat);
1537
1538   if(DBG_TRUST)
1539     log_debug("regexp `%s' on `%s': %s\n",expr,string,ret==0?"YES":"NO");
1540
1541   return (ret==0);
1542 #endif
1543 }
1544
1545 /*
1546  * Return true if the key is signed by one of the keys in the given
1547  * key ID list.  User IDs with a valid signature are marked by node
1548  * flags as follows:
1549  *  flag bit 0: There is at least one signature
1550  *           1: There is marginal confidence that this is a legitimate uid
1551  *           2: There is full confidence that this is a legitimate uid.
1552  *           8: Used for internal purposes.
1553  *           9: Ditto (in mark_usable_uid_certs())
1554  *          10: Ditto (ditto)
1555  * This function assumes that all kbnode flags are cleared on entry.
1556  */
1557 static int
1558 validate_one_keyblock (KBNODE kb, struct key_item *klist,
1559                        u32 curtime, u32 *next_expire)
1560 {
1561   struct key_item *kr;
1562   KBNODE node, uidnode=NULL;
1563   PKT_user_id *uid=NULL;
1564   PKT_public_key *pk = kb->pkt->pkt.public_key;
1565   u32 main_kid[2];
1566   int issigned=0, any_signed = 0;
1567
1568   keyid_from_pk(pk, main_kid);
1569   for (node=kb; node; node = node->next)
1570     {
1571       /* A bit of discussion here: is it better for the web of trust
1572          to be built among only self-signed uids?  On the one hand, a
1573          self-signed uid is a statement that the key owner definitely
1574          intended that uid to be there, but on the other hand, a
1575          signed (but not self-signed) uid does carry trust, of a sort,
1576          even if it is a statement being made by people other than the
1577          key owner "through" the uids on the key owner's key.  I'm
1578          going with the latter.  However, if the user ID was
1579          explicitly revoked, or passively allowed to expire, that
1580          should stop validity through the user ID until it is
1581          resigned.  -dshaw */
1582
1583       if (node->pkt->pkttype == PKT_USER_ID
1584           && !node->pkt->pkt.user_id->is_revoked
1585           && !node->pkt->pkt.user_id->is_expired)
1586         {
1587           if (uidnode && issigned)
1588             {
1589               if (uid->help_full_count >= opt.completes_needed
1590                   || uid->help_marginal_count >= opt.marginals_needed )
1591                 uidnode->flag |= 4; 
1592               else if (uid->help_full_count || uid->help_marginal_count)
1593                 uidnode->flag |= 2;
1594               uidnode->flag |= 1;
1595               any_signed = 1;
1596             }
1597           uidnode = node;
1598           uid=uidnode->pkt->pkt.user_id;
1599
1600           /* If the selfsig is going to expire... */
1601           if(uid->expiredate && uid->expiredate<*next_expire)
1602             *next_expire = uid->expiredate;
1603
1604           issigned = 0;
1605           get_validity_counts(pk,uid);
1606           mark_usable_uid_certs (kb, uidnode, main_kid, klist, 
1607                                  curtime, next_expire);
1608         }
1609       else if (node->pkt->pkttype == PKT_SIGNATURE
1610                && (node->flag & (1<<8)) && uid)
1611         {
1612           /* Note that we are only seeing unrevoked sigs here */
1613           PKT_signature *sig = node->pkt->pkt.signature;
1614           
1615           kr = is_in_klist (klist, sig);
1616           /* If the trust_regexp does not match, it's as if the sig
1617              did not exist.  This is safe for non-trust sigs as well
1618              since we don't accept a regexp on the sig unless it's a
1619              trust sig. */
1620           if (kr && (kr->trust_regexp==NULL || opt.trust_model!=TM_PGP ||
1621                      (uidnode && check_regexp(kr->trust_regexp,
1622                                             uidnode->pkt->pkt.user_id->name))))
1623             {
1624               if(DBG_TRUST && opt.trust_model==TM_PGP && sig->trust_depth)
1625                 log_debug("trust sig on %s, sig depth is %d, kr depth is %d\n",
1626                           uidnode->pkt->pkt.user_id->name,sig->trust_depth,
1627                           kr->trust_depth);
1628
1629               /* Are we part of a trust sig chain?  We always favor
1630                  the latest trust sig, rather than the greater or
1631                  lesser trust sig or value.  I could make a decent
1632                  argument for any of these cases, but this seems to be
1633                  what PGP does, and I'd like to be compatible. -dms */
1634               if(opt.trust_model==TM_PGP && sig->trust_depth
1635                  && pk->trust_timestamp<=sig->timestamp
1636                  && (sig->trust_depth<=kr->trust_depth
1637                      || kr->ownertrust==TRUST_ULTIMATE))
1638                 {
1639                   /* If we got here, we know that:
1640
1641                      this is a trust sig.
1642
1643                      it's a newer trust sig than any previous trust
1644                      sig on this key (not uid).
1645
1646                      it is legal in that it was either generated by an
1647                      ultimate key, or a key that was part of a trust
1648                      chain, and the depth does not violate the
1649                      original trust sig.
1650
1651                      if there is a regexp attached, it matched
1652                      successfully.
1653                   */
1654
1655                   if(DBG_TRUST)
1656                     log_debug("replacing trust value %d with %d and "
1657                               "depth %d with %d\n",
1658                               pk->trust_value,sig->trust_value,
1659                               pk->trust_depth,sig->trust_depth);
1660
1661                   pk->trust_value=sig->trust_value;
1662                   pk->trust_depth=sig->trust_depth-1;
1663
1664                   /* If the trust sig contains a regexp, record it
1665                      on the pk for the next round. */
1666                   if(sig->trust_regexp)
1667                     pk->trust_regexp=sig->trust_regexp;
1668                 }
1669
1670               if (kr->ownertrust == TRUST_ULTIMATE)
1671                 uid->help_full_count = opt.completes_needed;
1672               else if (kr->ownertrust == TRUST_FULLY)
1673                 uid->help_full_count++;
1674               else if (kr->ownertrust == TRUST_MARGINAL)
1675                 uid->help_marginal_count++;
1676               issigned = 1;
1677             }
1678         }
1679     }
1680
1681   if (uidnode && issigned)
1682     {
1683       if (uid->help_full_count >= opt.completes_needed
1684           || uid->help_marginal_count >= opt.marginals_needed )
1685         uidnode->flag |= 4; 
1686       else if (uid->help_full_count || uid->help_marginal_count)
1687         uidnode->flag |= 2;
1688       uidnode->flag |= 1;
1689       any_signed = 1;
1690     }
1691
1692   return any_signed;
1693 }
1694
1695
1696 static int
1697 search_skipfnc (void *opaque, u32 *kid, PKT_user_id *dummy)
1698 {
1699   return test_key_hash_table ((KeyHashTable)opaque, kid);
1700 }
1701
1702
1703 /*
1704  * Scan all keys and return a key_array of all suitable keys from
1705  * kllist.  The caller has to pass keydb handle so that we don't use
1706  * to create our own.  Returns either a key_array or NULL in case of
1707  * an error.  No results found are indicated by an empty array.
1708  * Caller hast to release the returned array.  
1709  */
1710 static struct key_array *
1711 validate_key_list (KEYDB_HANDLE hd, KeyHashTable full_trust,
1712                    struct key_item *klist, u32 curtime, u32 *next_expire)
1713 {
1714   KBNODE keyblock = NULL;
1715   struct key_array *keys = NULL;
1716   size_t nkeys, maxkeys;
1717   int rc;
1718   KEYDB_SEARCH_DESC desc;
1719   
1720   maxkeys = 1000;
1721   keys = m_alloc ((maxkeys+1) * sizeof *keys);
1722   nkeys = 0;
1723   
1724   rc = keydb_search_reset (hd);
1725   if (rc)
1726     {
1727       log_error ("keydb_search_reset failed: %s\n", g10_errstr(rc));
1728       m_free (keys);
1729       return NULL;
1730     }
1731
1732   memset (&desc, 0, sizeof desc);
1733   desc.mode = KEYDB_SEARCH_MODE_FIRST;
1734   desc.skipfnc = search_skipfnc;
1735   desc.skipfncvalue = full_trust;
1736   rc = keydb_search (hd, &desc, 1);
1737   if (rc == -1)
1738     {
1739       keys[nkeys].keyblock = NULL;
1740       return keys;
1741     }
1742   if (rc)
1743     {
1744       log_error ("keydb_search_first failed: %s\n", g10_errstr(rc));
1745       m_free (keys);
1746       return NULL;
1747     }
1748   
1749   desc.mode = KEYDB_SEARCH_MODE_NEXT; /* change mode */
1750   do
1751     {
1752       PKT_public_key *pk;
1753         
1754       rc = keydb_get_keyblock (hd, &keyblock);
1755       if (rc) 
1756         {
1757           log_error ("keydb_get_keyblock failed: %s\n", g10_errstr(rc));
1758           m_free (keys);
1759           return NULL;
1760         }
1761       
1762       if ( keyblock->pkt->pkttype != PKT_PUBLIC_KEY) 
1763         {
1764           log_debug ("ooops: invalid pkttype %d encountered\n",
1765                      keyblock->pkt->pkttype);
1766           dump_kbnode (keyblock);
1767           release_kbnode(keyblock);
1768           continue;
1769         }
1770
1771       /* prepare the keyblock for further processing */
1772       merge_keys_and_selfsig (keyblock); 
1773       clear_kbnode_flags (keyblock);
1774       pk = keyblock->pkt->pkt.public_key;
1775       if (pk->has_expired || pk->is_revoked)
1776         {
1777           /* it does not make sense to look further at those keys */
1778           mark_keyblock_seen (full_trust, keyblock);
1779         }
1780       else if (validate_one_keyblock (keyblock, klist, curtime, next_expire))
1781         {
1782           KBNODE node;
1783
1784           if (pk->expiredate && pk->expiredate >= curtime
1785               && pk->expiredate < *next_expire)
1786             *next_expire = pk->expiredate;
1787
1788           if (nkeys == maxkeys) {
1789             maxkeys += 1000;
1790             keys = m_realloc (keys, (maxkeys+1) * sizeof *keys);
1791           }
1792           keys[nkeys++].keyblock = keyblock;
1793
1794           /* Optimization - if all uids are fully trusted, then we
1795              never need to consider this key as a candidate again. */
1796
1797           for (node=keyblock; node; node = node->next)
1798             if (node->pkt->pkttype == PKT_USER_ID && !(node->flag & 4))
1799               break;
1800
1801           if(node==NULL)
1802             mark_keyblock_seen (full_trust, keyblock);
1803
1804           keyblock = NULL;
1805         }
1806
1807       release_kbnode (keyblock);
1808       keyblock = NULL;
1809     } 
1810   while ( !(rc = keydb_search (hd, &desc, 1)) );
1811   if (rc && rc != -1) 
1812     {
1813       log_error ("keydb_search_next failed: %s\n", g10_errstr(rc));
1814       m_free (keys);
1815       return NULL;
1816     }
1817
1818   keys[nkeys].keyblock = NULL;
1819   return keys;
1820
1821
1822 /* Caller must sync */
1823 static void
1824 reset_trust_records(void)
1825 {
1826   TRUSTREC rec;
1827   ulong recnum;
1828   int count = 0, nreset = 0;
1829
1830   for (recnum=1; !tdbio_read_record (recnum, &rec, 0); recnum++ ) 
1831     {
1832       if(rec.rectype==RECTYPE_TRUST)
1833         {
1834           count++;
1835           if(rec.r.trust.min_ownertrust)
1836             {
1837               rec.r.trust.min_ownertrust=0;
1838               write_record(&rec);
1839             }
1840
1841         }
1842       else if(rec.rectype==RECTYPE_VALID
1843               && ((rec.r.valid.validity&TRUST_MASK)
1844                   || rec.r.valid.marginal_count
1845                   || rec.r.valid.full_count))
1846         {
1847           rec.r.valid.validity &= ~TRUST_MASK;
1848           rec.r.valid.marginal_count=rec.r.valid.full_count=0;
1849           nreset++;
1850           write_record(&rec);
1851         }
1852
1853     }
1854
1855   if (opt.verbose)
1856     log_info (_("%d keys processed (%d validity counts cleared)\n"),
1857               count, nreset);
1858 }
1859
1860 /*
1861  * Run the key validation procedure.
1862  *
1863  * This works this way:
1864  * Step 1: Find all ultimately trusted keys (UTK).
1865  *         mark them all as seen and put them into klist.
1866  * Step 2: loop max_cert_times
1867  * Step 3:   if OWNERTRUST of any key in klist is undefined
1868  *             ask user to assign ownertrust
1869  * Step 4:   Loop over all keys in the keyDB which are not marked seen 
1870  * Step 5:     if key is revoked or expired
1871  *                mark key as seen
1872  *                continue loop at Step 4
1873  * Step 6:     For each user ID of that key signed by a key in klist
1874  *                Calculate validity by counting trusted signatures.
1875  *                Set validity of user ID
1876  * Step 7:     If any signed user ID was found
1877  *                mark key as seen
1878  *             End Loop
1879  * Step 8:   Build a new klist from all fully trusted keys from step 6
1880  *           End Loop
1881  *         Ready  
1882  *
1883  */
1884 static int
1885 validate_keys (int interactive)
1886 {
1887   int rc = 0;
1888   int quit=0;
1889   struct key_item *klist = NULL;
1890   struct key_item *k;
1891   struct key_array *keys = NULL;
1892   struct key_array *kar;
1893   KEYDB_HANDLE kdb = NULL;
1894   KBNODE node;
1895   int depth;
1896   int ot_unknown, ot_undefined, ot_never, ot_marginal, ot_full, ot_ultimate;
1897   KeyHashTable stored,used,full_trust;
1898   u32 start_time, next_expire;
1899
1900   /* Make sure we have all sigs cached.  TODO: This is going to
1901      require some architectual re-thinking, as it is agonizingly slow.
1902      Perhaps combine this with reset_trust_records(), or only check
1903      the caches on keys that are actually involved in the web of
1904      trust. */
1905   keydb_rebuild_caches(0);
1906
1907   start_time = make_timestamp ();
1908   next_expire = 0xffffffff; /* set next expire to the year 2106 */
1909   stored = new_key_hash_table ();
1910   used = new_key_hash_table ();
1911   full_trust = new_key_hash_table ();
1912
1913   kdb = keydb_new (0);
1914   reset_trust_records();
1915
1916   /* Fixme: Instead of always building a UTK list, we could just build it
1917    * here when needed */
1918   if (!utk_list)
1919     {
1920       log_info (_("no ultimately trusted keys found\n"));
1921       goto leave;
1922     }
1923
1924   /* mark all UTKs as used and fully_trusted and set validity to
1925      ultimate */
1926   for (k=utk_list; k; k = k->next)
1927     {
1928       KBNODE keyblock;
1929       PKT_public_key *pk;
1930
1931       keyblock = get_pubkeyblock (k->kid);
1932       if (!keyblock)
1933         {
1934           log_error (_("public key of ultimately"
1935                        " trusted key %s not found\n"), keystr(k->kid));
1936           continue;
1937         }
1938       mark_keyblock_seen (used, keyblock);
1939       mark_keyblock_seen (stored, keyblock);
1940       mark_keyblock_seen (full_trust, keyblock);
1941       pk = keyblock->pkt->pkt.public_key;
1942       for (node=keyblock; node; node = node->next)
1943         {
1944           if (node->pkt->pkttype == PKT_USER_ID)
1945             update_validity (pk, node->pkt->pkt.user_id, 0, TRUST_ULTIMATE);
1946         }
1947       if ( pk->expiredate && pk->expiredate >= start_time
1948            && pk->expiredate < next_expire)
1949         next_expire = pk->expiredate;
1950       
1951       release_kbnode (keyblock);
1952       do_sync ();
1953     }
1954
1955   klist = utk_list;
1956
1957   log_info(_("%d marginal(s) needed, %d complete(s) needed, %s trust model\n"),
1958            opt.marginals_needed,opt.completes_needed,trust_model_string());
1959
1960   for (depth=0; depth < opt.max_cert_depth; depth++)
1961     {
1962       int valids=0,key_count;
1963       /* See whether we should assign ownertrust values to the keys in
1964          klist.  */
1965       ot_unknown = ot_undefined = ot_never = 0;
1966       ot_marginal = ot_full = ot_ultimate = 0;
1967       for (k=klist; k; k = k->next)
1968         {
1969           int min=0;
1970
1971           /* 120 and 60 are as per RFC2440 */
1972           if(k->trust_value>=120)
1973             min=TRUST_FULLY;
1974           else if(k->trust_value>=60)
1975             min=TRUST_MARGINAL;
1976
1977           if(min!=k->min_ownertrust)
1978             update_min_ownertrust(k->kid,min);
1979
1980           if (interactive && k->ownertrust == TRUST_UNKNOWN)
1981             {
1982               k->ownertrust = ask_ownertrust (k->kid,min);
1983
1984               if (k->ownertrust == -1)
1985                 {
1986                   quit=1;
1987                   goto leave;
1988                 }
1989             }
1990
1991           /* This can happen during transition from an old trustdb
1992              before trust sigs.  It can also happen if a user uses two
1993              different versions of GnuPG or changes the --trust-model
1994              setting. */
1995           if(k->ownertrust<min)
1996             {
1997               if(DBG_TRUST)
1998                 log_debug("key %08lX%08lX:"
1999                           " overriding ownertrust `%s' with `%s'\n",
2000                           (ulong)k->kid[0],(ulong)k->kid[1],
2001                           trust_value_to_string(k->ownertrust),
2002                           trust_value_to_string(min));
2003
2004               k->ownertrust=min;
2005             }
2006
2007           if (k->ownertrust == TRUST_UNKNOWN)
2008             ot_unknown++;
2009           else if (k->ownertrust == TRUST_UNDEFINED)
2010             ot_undefined++;
2011           else if (k->ownertrust == TRUST_NEVER)
2012             ot_never++;
2013           else if (k->ownertrust == TRUST_MARGINAL)
2014             ot_marginal++;
2015           else if (k->ownertrust == TRUST_FULLY)
2016             ot_full++;
2017           else if (k->ownertrust == TRUST_ULTIMATE)
2018             ot_ultimate++;
2019
2020           valids++;
2021         }
2022
2023       /* Find all keys which are signed by a key in kdlist */
2024       keys = validate_key_list (kdb, full_trust, klist,
2025                                 start_time, &next_expire);
2026       if (!keys) 
2027         {
2028           log_error ("validate_key_list failed\n");
2029           rc = G10ERR_GENERAL;
2030           goto leave;
2031         }
2032
2033       for (key_count=0, kar=keys; kar->keyblock; kar++, key_count++)
2034         ;
2035
2036       /* Store the calculated valididation status somewhere */
2037       if (opt.verbose > 1)
2038         dump_key_array (depth, keys);
2039
2040       for (kar=keys; kar->keyblock; kar++)
2041           store_validation_status (depth, kar->keyblock, stored);
2042
2043       log_info (_("depth: %d  valid: %3d  signed: %3d"
2044                   "  trust: %d-, %dq, %dn, %dm, %df, %du\n"), 
2045                 depth, valids, key_count, ot_unknown, ot_undefined,
2046                 ot_never, ot_marginal, ot_full, ot_ultimate ); 
2047
2048       /* Build a new kdlist from all fully valid keys in KEYS */
2049       if (klist != utk_list)
2050         release_key_items (klist);
2051       klist = NULL;
2052       for (kar=keys; kar->keyblock; kar++)
2053         {
2054           for (node=kar->keyblock; node; node = node->next)
2055             {
2056               if (node->pkt->pkttype == PKT_USER_ID && (node->flag & 4))
2057                 {
2058                   u32 kid[2];
2059
2060                   /* have we used this key already? */
2061                   keyid_from_pk (kar->keyblock->pkt->pkt.public_key, kid);
2062                   if(test_key_hash_table(used,kid)==0)
2063                     {
2064                       /* Normally we add both the primary and subkey
2065                          ids to the hash via mark_keyblock_seen, but
2066                          since we aren't using this hash as a skipfnc,
2067                          that doesn't matter here. */
2068                       add_key_hash_table (used,kid);
2069                       k = new_key_item ();
2070                       k->kid[0]=kid[0];
2071                       k->kid[1]=kid[1];
2072                       k->ownertrust =
2073                         (get_ownertrust (kar->keyblock->pkt->pkt.public_key)
2074                          & TRUST_MASK);
2075                       k->min_ownertrust =
2076                         get_min_ownertrust(kar->keyblock->pkt->pkt.public_key);
2077                       k->trust_depth=
2078                         kar->keyblock->pkt->pkt.public_key->trust_depth;
2079                       k->trust_value=
2080                         kar->keyblock->pkt->pkt.public_key->trust_value;
2081                       if(kar->keyblock->pkt->pkt.public_key->trust_regexp)
2082                         k->trust_regexp=
2083                           m_strdup(kar->keyblock->pkt->
2084                                    pkt.public_key->trust_regexp);
2085                       k->next = klist;
2086                       klist = k;
2087                       break;
2088                     }
2089                 }
2090             }
2091         }
2092       release_key_array (keys);
2093       keys = NULL;
2094       if (!klist)
2095         break; /* no need to dive in deeper */
2096     }
2097
2098  leave:
2099   keydb_release (kdb);
2100   release_key_array (keys);
2101   release_key_items (klist);
2102   release_key_hash_table (full_trust);
2103   release_key_hash_table (used);
2104   release_key_hash_table (stored);
2105   if (!rc && !quit) /* mark trustDB as checked */
2106     {
2107       if (next_expire == 0xffffffff || next_expire < start_time )
2108         tdbio_write_nextcheck (0); 
2109       else
2110         {
2111           tdbio_write_nextcheck (next_expire); 
2112           log_info (_("next trustdb check due at %s\n"),
2113                     strtimestamp (next_expire));
2114         }
2115
2116       if(tdbio_update_version_record()!=0)
2117         {
2118           log_error(_("unable to update trustdb version record: "
2119                       "write failed: %s\n"), g10_errstr(rc));
2120           tdbio_invalid();
2121         }
2122
2123       do_sync ();
2124       pending_check_trustdb = 0;
2125     }
2126
2127   return rc;
2128 }