* parse-packet.c (parse_signature): No need to reserve 8 bytes for the
[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.  However, if the user ID was
1576          explicitly revoked, or passively allowed to expire, that
1577          should stop validity through the user ID until it is
1578          resigned.  -dshaw */
1579
1580       if (node->pkt->pkttype == PKT_USER_ID
1581           && !node->pkt->pkt.user_id->is_revoked
1582           && !node->pkt->pkt.user_id->is_expired)
1583         {
1584           if (uidnode && issigned)
1585             {
1586               if (uid->help_full_count >= opt.completes_needed
1587                   || uid->help_marginal_count >= opt.marginals_needed )
1588                 uidnode->flag |= 4; 
1589               else if (uid->help_full_count || uid->help_marginal_count)
1590                 uidnode->flag |= 2;
1591               uidnode->flag |= 1;
1592               any_signed = 1;
1593             }
1594           uidnode = node;
1595           uid=uidnode->pkt->pkt.user_id;
1596
1597           /* If the selfsig is going to expire... */
1598           if(uid->expiredate && uid->expiredate<*next_expire)
1599             *next_expire = uid->expiredate;
1600
1601           issigned = 0;
1602           get_validity_counts(pk,uid);
1603           mark_usable_uid_certs (kb, uidnode, main_kid, klist, 
1604                                  curtime, next_expire);
1605         }
1606       else if (node->pkt->pkttype == PKT_SIGNATURE
1607                && (node->flag & (1<<8)) && uid)
1608         {
1609           /* Note that we are only seeing unrevoked sigs here */
1610           PKT_signature *sig = node->pkt->pkt.signature;
1611           
1612           kr = is_in_klist (klist, sig);
1613           /* If the trust_regexp does not match, it's as if the sig
1614              did not exist.  This is safe for non-trust sigs as well
1615              since we don't accept a regexp on the sig unless it's a
1616              trust sig. */
1617           if (kr && (kr->trust_regexp==NULL || opt.trust_model!=TM_PGP ||
1618                      (uidnode && check_regexp(kr->trust_regexp,
1619                                             uidnode->pkt->pkt.user_id->name))))
1620             {
1621               if(DBG_TRUST && opt.trust_model==TM_PGP && sig->trust_depth)
1622                 log_debug("trust sig on %s, sig depth is %d, kr depth is %d\n",
1623                           uidnode->pkt->pkt.user_id->name,sig->trust_depth,
1624                           kr->trust_depth);
1625
1626               /* Are we part of a trust sig chain?  We always favor
1627                  the latest trust sig, rather than the greater or
1628                  lesser trust sig or value.  I could make a decent
1629                  argument for any of these cases, but this seems to be
1630                  what PGP does, and I'd like to be compatible. -dms */
1631               if(opt.trust_model==TM_PGP && sig->trust_depth
1632                  && pk->trust_timestamp<=sig->timestamp
1633                  && (sig->trust_depth<=kr->trust_depth
1634                      || kr->ownertrust==TRUST_ULTIMATE))
1635                 {
1636                   /* If we got here, we know that:
1637
1638                      this is a trust sig.
1639
1640                      it's a newer trust sig than any previous trust
1641                      sig on this key (not uid).
1642
1643                      it is legal in that it was either generated by an
1644                      ultimate key, or a key that was part of a trust
1645                      chain, and the depth does not violate the
1646                      original trust sig.
1647
1648                      if there is a regexp attached, it matched
1649                      successfully.
1650                   */
1651
1652                   if(DBG_TRUST)
1653                     log_debug("replacing trust value %d with %d and "
1654                               "depth %d with %d\n",
1655                               pk->trust_value,sig->trust_value,
1656                               pk->trust_depth,sig->trust_depth);
1657
1658                   pk->trust_value=sig->trust_value;
1659                   pk->trust_depth=sig->trust_depth-1;
1660
1661                   /* If the trust sig contains a regexp, record it
1662                      on the pk for the next round. */
1663                   if(sig->trust_regexp)
1664                     pk->trust_regexp=sig->trust_regexp;
1665                 }
1666
1667               if (kr->ownertrust == TRUST_ULTIMATE)
1668                 uid->help_full_count = opt.completes_needed;
1669               else if (kr->ownertrust == TRUST_FULLY)
1670                 uid->help_full_count++;
1671               else if (kr->ownertrust == TRUST_MARGINAL)
1672                 uid->help_marginal_count++;
1673               issigned = 1;
1674             }
1675         }
1676     }
1677
1678   if (uidnode && issigned)
1679     {
1680       if (uid->help_full_count >= opt.completes_needed
1681           || uid->help_marginal_count >= opt.marginals_needed )
1682         uidnode->flag |= 4; 
1683       else if (uid->help_full_count || uid->help_marginal_count)
1684         uidnode->flag |= 2;
1685       uidnode->flag |= 1;
1686       any_signed = 1;
1687     }
1688
1689   return any_signed;
1690 }
1691
1692
1693 static int
1694 search_skipfnc (void *opaque, u32 *kid)
1695 {
1696   return test_key_hash_table ((KeyHashTable)opaque, kid);
1697 }
1698
1699
1700 /*
1701  * Scan all keys and return a key_array of all suitable keys from
1702  * kllist.  The caller has to pass keydb handle so that we don't use
1703  * to create our own.  Returns either a key_array or NULL in case of
1704  * an error.  No results found are indicated by an empty array.
1705  * Caller hast to release the returned array.  
1706  */
1707 static struct key_array *
1708 validate_key_list (KEYDB_HANDLE hd, KeyHashTable full_trust,
1709                    struct key_item *klist, u32 curtime, u32 *next_expire)
1710 {
1711   KBNODE keyblock = NULL;
1712   struct key_array *keys = NULL;
1713   size_t nkeys, maxkeys;
1714   int rc;
1715   KEYDB_SEARCH_DESC desc;
1716   
1717   maxkeys = 1000;
1718   keys = m_alloc ((maxkeys+1) * sizeof *keys);
1719   nkeys = 0;
1720   
1721   rc = keydb_search_reset (hd);
1722   if (rc)
1723     {
1724       log_error ("keydb_search_reset failed: %s\n", g10_errstr(rc));
1725       m_free (keys);
1726       return NULL;
1727     }
1728
1729   memset (&desc, 0, sizeof desc);
1730   desc.mode = KEYDB_SEARCH_MODE_FIRST;
1731   desc.skipfnc = search_skipfnc;
1732   desc.skipfncvalue = full_trust;
1733   rc = keydb_search (hd, &desc, 1);
1734   if (rc == -1)
1735     {
1736       keys[nkeys].keyblock = NULL;
1737       return keys;
1738     }
1739   if (rc)
1740     {
1741       log_error ("keydb_search_first failed: %s\n", g10_errstr(rc));
1742       m_free (keys);
1743       return NULL;
1744     }
1745   
1746   desc.mode = KEYDB_SEARCH_MODE_NEXT; /* change mode */
1747   do
1748     {
1749       PKT_public_key *pk;
1750         
1751       rc = keydb_get_keyblock (hd, &keyblock);
1752       if (rc) 
1753         {
1754           log_error ("keydb_get_keyblock failed: %s\n", g10_errstr(rc));
1755           m_free (keys);
1756           return NULL;
1757         }
1758       
1759       if ( keyblock->pkt->pkttype != PKT_PUBLIC_KEY) 
1760         {
1761           log_debug ("ooops: invalid pkttype %d encountered\n",
1762                      keyblock->pkt->pkttype);
1763           dump_kbnode (keyblock);
1764           release_kbnode(keyblock);
1765           continue;
1766         }
1767
1768       /* prepare the keyblock for further processing */
1769       merge_keys_and_selfsig (keyblock); 
1770       clear_kbnode_flags (keyblock);
1771       pk = keyblock->pkt->pkt.public_key;
1772       if (pk->has_expired || pk->is_revoked)
1773         {
1774           /* it does not make sense to look further at those keys */
1775           mark_keyblock_seen (full_trust, keyblock);
1776         }
1777       else if (validate_one_keyblock (keyblock, klist, curtime, next_expire))
1778         {
1779           KBNODE node;
1780
1781           if (pk->expiredate && pk->expiredate >= curtime
1782               && pk->expiredate < *next_expire)
1783             *next_expire = pk->expiredate;
1784
1785           if (nkeys == maxkeys) {
1786             maxkeys += 1000;
1787             keys = m_realloc (keys, (maxkeys+1) * sizeof *keys);
1788           }
1789           keys[nkeys++].keyblock = keyblock;
1790
1791           /* Optimization - if all uids are fully trusted, then we
1792              never need to consider this key as a candidate again. */
1793
1794           for (node=keyblock; node; node = node->next)
1795             if (node->pkt->pkttype == PKT_USER_ID && !(node->flag & 4))
1796               break;
1797
1798           if(node==NULL)
1799             mark_keyblock_seen (full_trust, keyblock);
1800
1801           keyblock = NULL;
1802         }
1803
1804       release_kbnode (keyblock);
1805       keyblock = NULL;
1806     } 
1807   while ( !(rc = keydb_search (hd, &desc, 1)) );
1808   if (rc && rc != -1) 
1809     {
1810       log_error ("keydb_search_next failed: %s\n", g10_errstr(rc));
1811       m_free (keys);
1812       return NULL;
1813     }
1814
1815   keys[nkeys].keyblock = NULL;
1816   return keys;
1817
1818
1819 /* Caller must sync */
1820 static void
1821 reset_trust_records (KEYDB_HANDLE hd, KeyHashTable exclude)
1822 {
1823   int rc;
1824   KBNODE keyblock = NULL;
1825   KEYDB_SEARCH_DESC desc;
1826   int count = 0, nreset = 0;
1827   
1828   rc = keydb_search_reset (hd);
1829   if (rc)
1830     {
1831       log_error ("keydb_search_reset failed: %s\n", g10_errstr(rc));
1832       return;
1833     }
1834
1835   memset (&desc, 0, sizeof desc);
1836   desc.mode = KEYDB_SEARCH_MODE_FIRST;
1837   if(exclude)
1838     {
1839       desc.skipfnc = search_skipfnc;
1840       desc.skipfncvalue = exclude;
1841     }
1842   rc = keydb_search (hd, &desc, 1);
1843   if (rc && rc != -1 )
1844     log_error ("keydb_search_first failed: %s\n", g10_errstr(rc));
1845   else if (!rc)
1846     {
1847       desc.mode = KEYDB_SEARCH_MODE_NEXT; /* change mode */
1848       do
1849         {
1850           rc = keydb_get_keyblock (hd, &keyblock);
1851           if (rc) 
1852             {
1853               log_error ("keydb_get_keyblock failed: %s\n", g10_errstr(rc));
1854               break;
1855             }
1856           count++;
1857
1858           if (keyblock->pkt->pkttype == PKT_PUBLIC_KEY) /* paranoid assertion*/
1859             {
1860               nreset += clear_validity (keyblock->pkt->pkt.public_key);
1861               release_kbnode (keyblock);
1862             } 
1863         }
1864       while ( !(rc = keydb_search (hd, &desc, 1)) );
1865       if (rc && rc != -1) 
1866         log_error ("keydb_search_next failed: %s\n", g10_errstr(rc));
1867     }
1868   if (opt.verbose)
1869     log_info (_("%d keys processed (%d validity counts cleared)\n"),
1870               count, nreset);
1871 }
1872
1873 /*
1874  * Run the key validation procedure.
1875  *
1876  * This works this way:
1877  * Step 1: Find all ultimately trusted keys (UTK).
1878  *         mark them all as seen and put them into klist.
1879  * Step 2: loop max_cert_times
1880  * Step 3:   if OWNERTRUST of any key in klist is undefined
1881  *             ask user to assign ownertrust
1882  * Step 4:   Loop over all keys in the keyDB which are not marked seen 
1883  * Step 5:     if key is revoked or expired
1884  *                mark key as seen
1885  *                continue loop at Step 4
1886  * Step 6:     For each user ID of that key signed by a key in klist
1887  *                Calculate validity by counting trusted signatures.
1888  *                Set validity of user ID
1889  * Step 7:     If any signed user ID was found
1890  *                mark key as seen
1891  *             End Loop
1892  * Step 8:   Build a new klist from all fully trusted keys from step 6
1893  *           End Loop
1894  *         Ready  
1895  *
1896  */
1897 static int
1898 validate_keys (int interactive)
1899 {
1900   int rc = 0;
1901   int quit=0;
1902   struct key_item *klist = NULL;
1903   struct key_item *k;
1904   struct key_array *keys = NULL;
1905   struct key_array *kar;
1906   KEYDB_HANDLE kdb = NULL;
1907   KBNODE node;
1908   int depth;
1909   int key_count;
1910   int ot_unknown, ot_undefined, ot_never, ot_marginal, ot_full, ot_ultimate;
1911   KeyHashTable stored,used,full_trust;
1912   u32 start_time, next_expire;
1913
1914   start_time = make_timestamp ();
1915   next_expire = 0xffffffff; /* set next expire to the year 2106 */
1916   stored = new_key_hash_table ();
1917   used = new_key_hash_table ();
1918   full_trust = new_key_hash_table ();
1919   /* Fixme: Instead of always building a UTK list, we could just build it
1920    * here when needed */
1921   if (!utk_list)
1922     {
1923       log_info (_("no ultimately trusted keys found\n"));
1924       goto leave;
1925     }
1926
1927   kdb = keydb_new (0);
1928
1929   reset_trust_records (kdb,NULL);
1930
1931   /* mark all UTKs as used and fully_trusted and set validity to
1932      ultimate */
1933   for (k=utk_list; k; k = k->next)
1934     {
1935       KBNODE keyblock;
1936       PKT_public_key *pk;
1937
1938       keyblock = get_pubkeyblock (k->kid);
1939       if (!keyblock)
1940         {
1941           log_error (_("public key of ultimately"
1942                        " trusted key %08lX not found\n"), (ulong)k->kid[1]);
1943           continue;
1944         }
1945       mark_keyblock_seen (used, keyblock);
1946       mark_keyblock_seen (stored, keyblock);
1947       mark_keyblock_seen (full_trust, keyblock);
1948       pk = keyblock->pkt->pkt.public_key;
1949       for (node=keyblock; node; node = node->next)
1950         {
1951           if (node->pkt->pkttype == PKT_USER_ID)
1952             update_validity (pk, node->pkt->pkt.user_id, 0, TRUST_ULTIMATE);
1953         }
1954       if ( pk->expiredate && pk->expiredate >= start_time
1955            && pk->expiredate < next_expire)
1956         next_expire = pk->expiredate;
1957       
1958       release_kbnode (keyblock);
1959       do_sync ();
1960     }
1961
1962   klist = utk_list;
1963
1964   log_info(_("%d marginal(s) needed, %d complete(s) needed, %s trust model\n"),
1965            opt.marginals_needed,opt.completes_needed,trust_model_string());
1966
1967   for (depth=0; depth < opt.max_cert_depth; depth++)
1968     {
1969       /* See whether we should assign ownertrust values to the keys in
1970          utk_list.  */
1971       ot_unknown = ot_undefined = ot_never = 0;
1972       ot_marginal = ot_full = ot_ultimate = 0;
1973       for (k=klist; k; k = k->next)
1974         {
1975           int min=0;
1976
1977           /* 120 and 60 are as per RFC2440 */
1978           if(k->trust_value>=120)
1979             min=TRUST_FULLY;
1980           else if(k->trust_value>=60)
1981             min=TRUST_MARGINAL;
1982
1983           if(min!=k->min_ownertrust)
1984             update_min_ownertrust(k->kid,min);
1985
1986           if (interactive && k->ownertrust == TRUST_UNKNOWN)
1987             {
1988               k->ownertrust = ask_ownertrust (k->kid,min);
1989
1990               if (k->ownertrust == -1)
1991                 {
1992                   quit=1;
1993                   goto leave;
1994                 }
1995             }
1996
1997           /* This can happen during transition from an old trustdb
1998              before trust sigs.  It can also happen if a user uses two
1999              different versions of GnuPG or changes the --trust-model
2000              setting. */
2001           if(k->ownertrust<min)
2002             {
2003               if(DBG_TRUST)
2004                 log_debug("key %08lX: "
2005                           "overriding ownertrust \"%s\" with \"%s\"\n",
2006                           (ulong)k->kid[1],
2007                           trust_value_to_string(k->ownertrust),
2008                           trust_value_to_string(min));
2009
2010               k->ownertrust=min;
2011             }
2012
2013           if (k->ownertrust == TRUST_UNKNOWN)
2014             ot_unknown++;
2015           else if (k->ownertrust == TRUST_UNDEFINED)
2016             ot_undefined++;
2017           else if (k->ownertrust == TRUST_NEVER)
2018             ot_never++;
2019           else if (k->ownertrust == TRUST_MARGINAL)
2020             ot_marginal++;
2021           else if (k->ownertrust == TRUST_FULLY)
2022             ot_full++;
2023           else if (k->ownertrust == TRUST_ULTIMATE)
2024             ot_ultimate++;
2025         }
2026
2027       /* Find all keys which are signed by a key in kdlist */
2028       keys = validate_key_list (kdb, full_trust, klist,
2029                                 start_time, &next_expire);
2030       if (!keys) 
2031         {
2032           log_error ("validate_key_list failed\n");
2033           rc = G10ERR_GENERAL;
2034           goto leave;
2035         }
2036
2037       for (key_count=0, kar=keys; kar->keyblock; kar++, key_count++)
2038         ;
2039
2040       /* Store the calculated valididation status somewhere */
2041       if (opt.verbose > 1)
2042         dump_key_array (depth, keys);
2043
2044       for (kar=keys; kar->keyblock; kar++)
2045           store_validation_status (depth, kar->keyblock, stored);
2046
2047       log_info (_("checking at depth %d valid=%d"
2048                   " ot(-/q/n/m/f/u)=%d/%d/%d/%d/%d/%d\n"), 
2049                 depth, key_count, ot_unknown, ot_undefined,
2050                 ot_never, ot_marginal, ot_full, ot_ultimate ); 
2051
2052       /* Build a new kdlist from all fully valid keys in KEYS */
2053       if (klist != utk_list)
2054         release_key_items (klist);
2055       klist = NULL;
2056       for (kar=keys; kar->keyblock; kar++)
2057         {
2058           for (node=kar->keyblock; node; node = node->next)
2059             {
2060               if (node->pkt->pkttype == PKT_USER_ID && (node->flag & 4))
2061                 {
2062                   u32 kid[2];
2063
2064                   /* have we used this key already? */
2065                   keyid_from_pk (kar->keyblock->pkt->pkt.public_key, kid);
2066                   if(test_key_hash_table(used,kid)==0)
2067                     {
2068                       /* Normally we add both the primary and subkey
2069                          ids to the hash via mark_keyblock_seen, but
2070                          since we aren't using this hash as a skipfnc,
2071                          that doesn't matter here. */
2072                       add_key_hash_table (used,kid);
2073                       k = new_key_item ();
2074                       k->kid[0]=kid[0];
2075                       k->kid[1]=kid[1];
2076                       k->ownertrust =
2077                         (get_ownertrust (kar->keyblock->pkt->pkt.public_key)
2078                          & TRUST_MASK);
2079                       k->min_ownertrust =
2080                         get_min_ownertrust(kar->keyblock->pkt->pkt.public_key);
2081                       k->trust_depth=
2082                         kar->keyblock->pkt->pkt.public_key->trust_depth;
2083                       k->trust_value=
2084                         kar->keyblock->pkt->pkt.public_key->trust_value;
2085                       if(kar->keyblock->pkt->pkt.public_key->trust_regexp)
2086                         k->trust_regexp=
2087                           m_strdup(kar->keyblock->pkt->
2088                                    pkt.public_key->trust_regexp);
2089                       k->next = klist;
2090                       klist = k;
2091                       break;
2092                     }
2093                 }
2094             }
2095         }
2096       release_key_array (keys);
2097       keys = NULL;
2098       if (!klist)
2099         break; /* no need to dive in deeper */
2100     }
2101
2102  leave:
2103   keydb_release (kdb);
2104   release_key_array (keys);
2105   release_key_items (klist);
2106   release_key_hash_table (full_trust);
2107   release_key_hash_table (used);
2108   release_key_hash_table (stored);
2109   if (!rc && !quit) /* mark trustDB as checked */
2110     {
2111       if (next_expire == 0xffffffff || next_expire < start_time )
2112         tdbio_write_nextcheck (0); 
2113       else
2114         {
2115           tdbio_write_nextcheck (next_expire); 
2116           log_info (_("next trustdb check due at %s\n"),
2117                     strtimestamp (next_expire));
2118         }
2119
2120       if(tdbio_update_version_record()!=0)
2121         {
2122           log_error(_("unable to update trustdb version record: "
2123                       "write failed: %s\n"), g10_errstr(rc));
2124           tdbio_invalid();
2125         }
2126
2127       do_sync ();
2128       pending_check_trustdb = 0;
2129     }
2130
2131   return rc;
2132 }