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