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