* tdbio.c (create_version_record): Only create new trustdbs with
[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 is_disabled(void *dummy,u32 *keyid)
954 {
955   int rc;
956   TRUSTREC trec;
957   int disabled=0; /* default to not disabled */
958   PKT_public_key *pk=m_alloc_clear(sizeof(PKT_public_key));
959
960   init_trustdb ();
961
962   rc = get_pubkey(pk, keyid);
963   if(rc)
964     {
965       log_error("error checking disabled status of %08lX: %s\n",
966                 (ulong)keyid[1],g10_errstr(rc));
967       goto leave;
968     }
969  
970   rc = read_trust_record (pk, &trec);
971   if (rc && rc != -1)
972     {
973       tdbio_invalid ();
974       goto leave;
975     }
976   if (rc == -1) /* no record found, so assume not disabled */
977     goto leave;
978  
979   if(trec.r.trust.ownertrust & TRUST_FLAG_DISABLED)
980     disabled=1;
981  
982  leave:
983   free_public_key(pk);
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     validity |= TRUST_FLAG_DISABLED;
1089
1090  leave:
1091   /* set some flags direct from the key */
1092   if (main_pk->is_revoked)
1093     validity |= TRUST_FLAG_REVOKED;
1094   if (main_pk != pk && pk->is_revoked)
1095     validity |= TRUST_FLAG_SUB_REVOKED;
1096   /* Note: expiration is a trust value and not a flag - don't know why
1097    * I initially designed it that way */
1098   if (main_pk->has_expired || pk->has_expired)
1099     validity = (validity & ~TRUST_MASK) | TRUST_EXPIRED;
1100   
1101   if (pending_check_trustdb)
1102     validity |= TRUST_FLAG_PENDING_CHECK;
1103
1104   if (main_pk != pk)
1105     free_public_key (main_pk);
1106   return validity;
1107 }
1108
1109 int
1110 get_validity_info (PKT_public_key *pk, PKT_user_id *uid)
1111 {
1112     int trustlevel;
1113
1114     trustlevel = get_validity (pk, uid);
1115     if( trustlevel & TRUST_FLAG_REVOKED )
1116         return 'r';
1117     return trust_letter ( trustlevel );
1118 }
1119
1120 const char *
1121 get_validity_string (PKT_public_key *pk, PKT_user_id *uid)
1122 {
1123   int trustlevel;
1124
1125   trustlevel = get_validity (pk, uid);
1126   if( trustlevel & TRUST_FLAG_REVOKED )
1127     return _("revoked");
1128   return trust_value_to_string(trustlevel);
1129 }
1130
1131 static void
1132 get_validity_counts (PKT_public_key *pk, PKT_user_id *uid)
1133 {
1134   TRUSTREC trec, vrec;
1135   ulong recno;
1136
1137   if(pk==NULL || uid==NULL)
1138     BUG();
1139
1140   namehash_from_uid(uid);
1141
1142   uid->help_marginal_count=uid->help_full_count=0;
1143
1144   init_trustdb ();
1145
1146   if(read_trust_record (pk, &trec)!=0)
1147     return;
1148
1149   /* loop over all user IDs */
1150   recno = trec.r.trust.validlist;
1151   while (recno)
1152     {
1153       read_record (recno, &vrec, RECTYPE_VALID);
1154
1155       if(memcmp(vrec.r.valid.namehash,uid->namehash,20)==0)
1156         {
1157           uid->help_marginal_count=vrec.r.valid.marginal_count;
1158           uid->help_full_count=vrec.r.valid.full_count;
1159           /*  printf("Fetched marginal %d, full %d\n",uid->help_marginal_count,uid->help_full_count); */
1160           break;
1161         }
1162
1163       recno = vrec.r.valid.next;
1164     }
1165 }
1166
1167 void
1168 list_trust_path( const char *username )
1169 {
1170 }
1171
1172 /****************
1173  * Enumerate all keys, which are needed to build all trust paths for
1174  * the given key.  This function does not return the key itself or
1175  * the ultimate key (the last point in cerificate chain).  Only
1176  * certificate chains which ends up at an ultimately trusted key
1177  * are listed.  If ownertrust or validity is not NULL, the corresponding
1178  * value for the returned LID is also returned in these variable(s).
1179  *
1180  *  1) create a void pointer and initialize it to NULL
1181  *  2) pass this void pointer by reference to this function.
1182  *     Set lid to the key you want to enumerate and pass it by reference.
1183  *  3) call this function as long as it does not return -1
1184  *     to indicate EOF. LID does contain the next key used to build the web
1185  *  4) Always call this function a last time with LID set to NULL,
1186  *     so that it can free its context.
1187  *
1188  * Returns: -1 on EOF or the level of the returned LID
1189  */
1190 int
1191 enum_cert_paths( void **context, ulong *lid,
1192                  unsigned *ownertrust, unsigned *validity )
1193 {
1194     return -1;
1195 }
1196
1197
1198 /****************
1199  * Print the current path
1200  */
1201 void
1202 enum_cert_paths_print( void **context, FILE *fp,
1203                                        int refresh, ulong selected_lid )
1204 {
1205     return;
1206 }
1207
1208
1209 \f
1210 /****************************************
1211  *********** NEW NEW NEW ****************
1212  ****************************************/
1213
1214 static int
1215 ask_ownertrust (u32 *kid,int minimum)
1216 {
1217   PKT_public_key *pk;
1218   int rc;
1219   int ot;
1220
1221   pk = m_alloc_clear (sizeof *pk);
1222   rc = get_pubkey (pk, kid);
1223   if (rc)
1224     {
1225       log_error (_("public key %08lX not found: %s\n"),
1226                  (ulong)kid[1], g10_errstr(rc) );
1227       return TRUST_UNKNOWN;
1228     }
1229  
1230   if(opt.force_ownertrust)
1231     {
1232       log_info("force trust for key %08lX%08lX to %s\n",
1233                (ulong)kid[0],(ulong)kid[1],
1234                trust_value_to_string(opt.force_ownertrust));
1235       update_ownertrust(pk,opt.force_ownertrust);
1236       ot=opt.force_ownertrust;
1237     }
1238   else
1239     {
1240       ot=edit_ownertrust(pk,0);
1241       if(ot>0)
1242         ot = get_ownertrust (pk);
1243       else if(ot==0)
1244         ot = minimum?minimum:TRUST_UNDEFINED;
1245       else
1246         ot = -1; /* quit */
1247     }
1248
1249   free_public_key( pk );
1250
1251   return ot;
1252 }
1253
1254
1255 static void
1256 mark_keyblock_seen (KeyHashTable tbl, KBNODE node)
1257 {
1258   for ( ;node; node = node->next )
1259     if (node->pkt->pkttype == PKT_PUBLIC_KEY
1260         || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1261       {
1262         u32 aki[2];
1263
1264         keyid_from_pk (node->pkt->pkt.public_key, aki);
1265         add_key_hash_table (tbl, aki);
1266       }
1267 }
1268
1269
1270 static void
1271 dump_key_array (int depth, struct key_array *keys)
1272 {
1273   struct key_array *kar;
1274
1275   for (kar=keys; kar->keyblock; kar++)
1276     {
1277       KBNODE node = kar->keyblock;
1278       u32 kid[2];
1279
1280       keyid_from_pk(node->pkt->pkt.public_key, kid);
1281       printf ("%d:%08lX%08lX:K::%c::::\n",
1282               depth, (ulong)kid[0], (ulong)kid[1], '?');
1283
1284       for (; node; node = node->next)
1285         {
1286           if (node->pkt->pkttype == PKT_USER_ID)
1287             {
1288               int len = node->pkt->pkt.user_id->len;
1289
1290               if (len > 30)
1291                 len = 30;
1292               printf ("%d:%08lX%08lX:U:::%c:::",
1293                       depth, (ulong)kid[0], (ulong)kid[1],
1294                       (node->flag & 4)? 'f':
1295                       (node->flag & 2)? 'm':
1296                       (node->flag & 1)? 'q':'-');
1297               print_string (stdout,  node->pkt->pkt.user_id->name, len, ':');
1298               putchar (':');
1299               putchar ('\n');
1300             }
1301         }
1302     }
1303 }  
1304
1305
1306 static void
1307 store_validation_status (int depth, KBNODE keyblock, KeyHashTable stored)
1308 {
1309   KBNODE node;
1310   int status;
1311   int any = 0;
1312
1313   for (node=keyblock; node; node = node->next)
1314     {
1315       if (node->pkt->pkttype == PKT_USER_ID)
1316         {
1317           PKT_user_id *uid = node->pkt->pkt.user_id;
1318           if (node->flag & 4)
1319             status = TRUST_FULLY;
1320           else if (node->flag & 2)
1321             status = TRUST_MARGINAL;
1322           else if (node->flag & 1)
1323             status = TRUST_UNDEFINED;
1324           else
1325             status = 0;
1326           
1327           if (status)
1328             {
1329               update_validity (keyblock->pkt->pkt.public_key,
1330                                uid, depth, status);
1331
1332               mark_keyblock_seen(stored,keyblock);
1333
1334               any = 1;
1335             }
1336         }
1337     }
1338
1339   if (any)
1340     do_sync ();
1341 }  
1342
1343 /*
1344  * check whether the signature sig is in the klist k
1345  */
1346 static struct key_item *
1347 is_in_klist (struct key_item *k, PKT_signature *sig)
1348 {
1349   for (; k; k = k->next)
1350     {
1351       if (k->kid[0] == sig->keyid[0] && k->kid[1] == sig->keyid[1])
1352         return k;
1353     }
1354   return NULL;
1355 }
1356
1357 /*
1358  * Mark the signature of the given UID which are used to certify it.
1359  * To do this, we first revmove all signatures which are not valid and
1360  * from the remain ones we look for the latest one.  If this is not a
1361  * certification revocation signature we mark the signature by setting
1362  * node flag bit 8.  Note that flag bits 9 and 10 are used for internal
1363  * purposes.  
1364  */
1365 static void
1366 mark_usable_uid_certs (KBNODE keyblock, KBNODE uidnode,
1367                        u32 *main_kid, struct key_item *klist,
1368                        u32 curtime, u32 *next_expire)
1369 {
1370   KBNODE node;
1371   PKT_signature *sig;
1372   
1373   /* first check all signatures */
1374   for (node=uidnode->next; node; node = node->next)
1375     {
1376       node->flag &= ~(1<<8 | 1<<9 | 1<<10);
1377       if (node->pkt->pkttype == PKT_USER_ID
1378           || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1379         break; /* ready */
1380       if (node->pkt->pkttype != PKT_SIGNATURE)
1381         continue;
1382       
1383       sig = node->pkt->pkt.signature;
1384       if (sig->keyid[0] == main_kid[0] && sig->keyid[1] == main_kid[1])
1385         continue; /* ignore self-signatures */
1386       if (!IS_UID_SIG(sig) && !IS_UID_REV(sig))
1387         continue; /* we only look at these signature classes */
1388       if (!is_in_klist (klist, sig))
1389         continue;  /* no need to check it then */
1390       if (check_key_signature (keyblock, node, NULL))
1391         continue; /* ignore invalid signatures */
1392       node->flag |= 1<<9;
1393     }      
1394   /* reset the remaining flags */
1395   for (; node; node = node->next)
1396       node->flag &= ~(1<<8 | 1<<9 | 1 << 10);
1397
1398   /* kbnode flag usage: bit 9 is here set for signatures to consider,
1399    * bit 10 will be set by the loop to keep track of keyIDs already
1400    * processed, bit 8 will be set for the usable signatures */
1401
1402   /* for each cert figure out the latest valid one */
1403   for (node=uidnode->next; node; node = node->next)
1404     {
1405       KBNODE n, signode;
1406       u32 kid[2];
1407       u32 sigdate;
1408       
1409       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1410         break;
1411       if ( !(node->flag & (1<<9)) )
1412         continue; /* not a node to look at */
1413       if ( (node->flag & (1<<10)) )
1414         continue; /* signature with a keyID already processed */
1415       node->flag |= (1<<10); /* mark this node as processed */
1416       sig = node->pkt->pkt.signature;
1417       signode = node;
1418       sigdate = sig->timestamp;
1419       kid[0] = sig->keyid[0]; kid[1] = sig->keyid[1];
1420       for (n=uidnode->next; n; n = n->next)
1421         {
1422           if (n->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1423             break;
1424           if ( !(n->flag & (1<<9)) )
1425             continue;
1426           if ( (n->flag & (1<<10)) )
1427             continue; /* shortcut already processed signatures */
1428           sig = n->pkt->pkt.signature;
1429           if (kid[0] != sig->keyid[0] || kid[1] != sig->keyid[1])
1430             continue;
1431           n->flag |= (1<<10); /* mark this node as processed */
1432
1433           /* If signode is nonrevocable and unexpired and n isn't,
1434              then take signode (skip).  It doesn't matter which is
1435              older: if signode was older then we don't want to take n
1436              as signode is nonrevocable.  If n was older then we're
1437              automatically fine. */
1438           
1439           if(((IS_UID_SIG(signode->pkt->pkt.signature) &&
1440                !signode->pkt->pkt.signature->flags.revocable &&
1441                (signode->pkt->pkt.signature->expiredate==0 ||
1442                 signode->pkt->pkt.signature->expiredate>curtime))) &&
1443              (!(IS_UID_SIG(n->pkt->pkt.signature) &&
1444                 !n->pkt->pkt.signature->flags.revocable &&
1445                 (n->pkt->pkt.signature->expiredate==0 ||
1446                  n->pkt->pkt.signature->expiredate>curtime))))
1447             continue;
1448
1449           /* If n is nonrevocable and unexpired and signode isn't,
1450              then take n.  Again, it doesn't matter which is older: if
1451              n was older then we don't want to take signode as n is
1452              nonrevocable.  If signode was older then we're
1453              automatically fine. */
1454           
1455           if((!(IS_UID_SIG(signode->pkt->pkt.signature) &&
1456                 !signode->pkt->pkt.signature->flags.revocable &&
1457                 (signode->pkt->pkt.signature->expiredate==0 ||
1458                  signode->pkt->pkt.signature->expiredate>curtime))) &&
1459              ((IS_UID_SIG(n->pkt->pkt.signature) &&
1460                !n->pkt->pkt.signature->flags.revocable &&
1461                (n->pkt->pkt.signature->expiredate==0 ||
1462                 n->pkt->pkt.signature->expiredate>curtime))))
1463             {
1464               signode = n;
1465               sigdate = sig->timestamp;
1466               continue;
1467             }
1468
1469           /* At this point, if it's newer, it goes in as the only
1470              remaining possibilities are signode and n are both either
1471              revocable or expired or both nonrevocable and unexpired.
1472              If the timestamps are equal take the later ordered
1473              packet, presuming that the key packets are hopefully in
1474              their original order. */
1475
1476           if (sig->timestamp >= sigdate)
1477             {
1478               signode = n;
1479               sigdate = sig->timestamp;
1480             }
1481         }
1482       sig = signode->pkt->pkt.signature;
1483       if (IS_UID_SIG (sig))
1484         { /* this seems to be a usable one which is not revoked. 
1485            * Just need to check whether there is an expiration time,
1486            * We do the expired certification after finding a suitable
1487            * certification, the assumption is that a signator does not
1488            * want that after the expiration of his certificate the
1489            * system falls back to an older certification which has a
1490            * different expiration time */
1491           const byte *p;
1492           u32 expire;
1493                     
1494           p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_SIG_EXPIRE, NULL );
1495           expire = p? sig->timestamp + buffer_to_u32(p) : 0;
1496
1497           if (expire==0 || expire > curtime )
1498             {
1499               signode->flag |= (1<<8); /* yeah, found a good cert */
1500               if (expire && expire < *next_expire)
1501                 *next_expire = expire;
1502             }
1503         }
1504     }
1505 }
1506
1507 /* Used by validate_one_keyblock to confirm a regexp within a trust
1508    signature.  Returns 1 for match, and 0 for no match or regex
1509    error. */
1510 static int
1511 check_regexp(const char *exp,const char *string)
1512 {
1513 #ifdef DISABLE_REGEX
1514   /* When DISABLE_REGEX is defined, assume all regexps do not
1515      match. */
1516   return 0;
1517 #elif defined(__riscos__)
1518   return riscos_check_regexp(exp, string, DBG_TRUST);
1519 #else
1520   int ret;
1521   regex_t pat;
1522
1523   if(regcomp(&pat,exp,REG_ICASE|REG_NOSUB|REG_EXTENDED)!=0)
1524     return 0;
1525
1526   ret=regexec(&pat,string,0,NULL,0);
1527
1528   regfree(&pat);
1529
1530   if(DBG_TRUST)
1531     log_debug("regexp \"%s\" on \"%s\": %s\n",exp,string,ret==0?"YES":"NO");
1532
1533   return (ret==0);
1534 #endif
1535 }
1536
1537 /*
1538  * Return true if the key is signed by one of the keys in the given
1539  * key ID list.  User IDs with a valid signature are marked by node
1540  * flags as follows:
1541  *  flag bit 0: There is at least one signature
1542  *           1: There is marginal confidence that this is a legitimate uid
1543  *           2: There is full confidence that this is a legitimate uid.
1544  *           8: Used for internal purposes.
1545  *           9: Ditto (in mark_usable_uid_certs())
1546  *          10: Ditto (ditto)
1547  * This function assumes that all kbnode flags are cleared on entry.
1548  */
1549 static int
1550 validate_one_keyblock (KBNODE kb, struct key_item *klist,
1551                        u32 curtime, u32 *next_expire)
1552 {
1553   struct key_item *kr;
1554   KBNODE node, uidnode=NULL;
1555   PKT_user_id *uid=NULL;
1556   PKT_public_key *pk = kb->pkt->pkt.public_key;
1557   u32 main_kid[2];
1558   int issigned=0, any_signed = 0;
1559
1560   keyid_from_pk(pk, main_kid);
1561   for (node=kb; node; node = node->next)
1562     {
1563       /* A bit of discussion here: is it better for the web of trust
1564          to be built among only self-signed uids?  On the one hand, a
1565          self-signed uid is a statement that the key owner definitely
1566          intended that uid to be there, but on the other hand, a
1567          signed (but not self-signed) uid does carry trust, of a sort,
1568          even if it is a statement being made by people other than the
1569          key owner "through" the uids on the key owner's key.  I'm
1570          going with the latter. -dshaw */
1571
1572       /* && node->pkt->pkt.user_id->created) */
1573       if (node->pkt->pkttype == PKT_USER_ID)
1574         {
1575           if (uidnode && issigned)
1576             {
1577               if (uid->help_full_count >= opt.completes_needed
1578                   || uid->help_marginal_count >= opt.marginals_needed )
1579                 uidnode->flag |= 4; 
1580               else if (uid->help_full_count || uid->help_marginal_count)
1581                 uidnode->flag |= 2;
1582               uidnode->flag |= 1;
1583               any_signed = 1;
1584             }
1585           uidnode = node;
1586           uid=uidnode->pkt->pkt.user_id;
1587 #if 0
1588           /* If the selfsig is going to expire...  This is disabled as
1589              we do count un-self-signed uids in the web of trust. */
1590           if(uid->expiredate && uid->expiredate<*next_expire)
1591             *next_expire = uid->expiredate;
1592 #endif
1593           issigned = 0;
1594           get_validity_counts(pk,uid);
1595           mark_usable_uid_certs (kb, uidnode, main_kid, klist, 
1596                                  curtime, next_expire);
1597         }
1598       else if (node->pkt->pkttype == PKT_SIGNATURE
1599                && (node->flag & (1<<8)) && uid)
1600         {
1601           /* Note that we are only seeing unrevoked sigs here */
1602           PKT_signature *sig = node->pkt->pkt.signature;
1603           
1604           kr = is_in_klist (klist, sig);
1605           /* If the trust_regexp does not match, it's as if the sig
1606              did not exist.  This is safe for non-trust sigs as well
1607              since we don't accept a regexp on the sig unless it's a
1608              trust sig. */
1609           if (kr && (kr->trust_regexp==NULL || opt.trust_model!=TM_PGP ||
1610                      (uidnode && check_regexp(kr->trust_regexp,
1611                                             uidnode->pkt->pkt.user_id->name))))
1612             {
1613               if(DBG_TRUST && opt.trust_model==TM_PGP && sig->trust_depth)
1614                 log_debug("trust sig on %s, sig depth is %d, kr depth is %d\n",
1615                           uidnode->pkt->pkt.user_id->name,sig->trust_depth,
1616                           kr->trust_depth);
1617
1618               /* Are we part of a trust sig chain?  We always favor
1619                  the latest trust sig, rather than the greater or
1620                  lesser trust sig or value.  I could make a decent
1621                  argument for any of these cases, but this seems to be
1622                  what PGP does, and I'd like to be compatible. -dms */
1623               if(opt.trust_model==TM_PGP && sig->trust_depth
1624                  && pk->trust_timestamp<=sig->timestamp
1625                  && (sig->trust_depth<=kr->trust_depth
1626                      || kr->ownertrust==TRUST_ULTIMATE))
1627                 {
1628                   /* If we got here, we know that:
1629
1630                      this is a trust sig.
1631
1632                      it's a newer trust sig than any previous trust
1633                      sig on this key (not uid).
1634
1635                      it is legal in that it was either generated by an
1636                      ultimate key, or a key that was part of a trust
1637                      chain, and the depth does not violate the
1638                      original trust sig.
1639
1640                      if there is a regexp attached, it matched
1641                      successfully.
1642                   */
1643
1644                   if(DBG_TRUST)
1645                     log_debug("replacing trust value %d with %d and "
1646                               "depth %d with %d\n",
1647                               pk->trust_value,sig->trust_value,
1648                               pk->trust_depth,sig->trust_depth);
1649
1650                   pk->trust_value=sig->trust_value;
1651                   pk->trust_depth=sig->trust_depth-1;
1652
1653                   /* If the trust sig contains a regexp, record it
1654                      on the pk for the next round. */
1655                   if(sig->trust_regexp)
1656                     pk->trust_regexp=sig->trust_regexp;
1657                 }
1658
1659               if (kr->ownertrust == TRUST_ULTIMATE)
1660                 uid->help_full_count = opt.completes_needed;
1661               else if (kr->ownertrust == TRUST_FULLY)
1662                 uid->help_full_count++;
1663               else if (kr->ownertrust == TRUST_MARGINAL)
1664                 uid->help_marginal_count++;
1665               issigned = 1;
1666             }
1667         }
1668     }
1669
1670   if (uidnode && issigned)
1671     {
1672       if (uid->help_full_count >= opt.completes_needed
1673           || uid->help_marginal_count >= opt.marginals_needed )
1674         uidnode->flag |= 4; 
1675       else if (uid->help_full_count || uid->help_marginal_count)
1676         uidnode->flag |= 2;
1677       uidnode->flag |= 1;
1678       any_signed = 1;
1679     }
1680
1681   return any_signed;
1682 }
1683
1684
1685 static int
1686 search_skipfnc (void *opaque, u32 *kid)
1687 {
1688   return test_key_hash_table ((KeyHashTable)opaque, kid);
1689 }
1690
1691
1692 /*
1693  * Scan all keys and return a key_array of all suitable keys from
1694  * kllist.  The caller has to pass keydb handle so that we don't use
1695  * to create our own.  Returns either a key_array or NULL in case of
1696  * an error.  No results found are indicated by an empty array.
1697  * Caller hast to release the returned array.  
1698  */
1699 static struct key_array *
1700 validate_key_list (KEYDB_HANDLE hd, KeyHashTable full_trust,
1701                    struct key_item *klist, u32 curtime, u32 *next_expire)
1702 {
1703   KBNODE keyblock = NULL;
1704   struct key_array *keys = NULL;
1705   size_t nkeys, maxkeys;
1706   int rc;
1707   KEYDB_SEARCH_DESC desc;
1708   
1709   maxkeys = 1000;
1710   keys = m_alloc ((maxkeys+1) * sizeof *keys);
1711   nkeys = 0;
1712   
1713   rc = keydb_search_reset (hd);
1714   if (rc)
1715     {
1716       log_error ("keydb_search_reset failed: %s\n", g10_errstr(rc));
1717       m_free (keys);
1718       return NULL;
1719     }
1720
1721   memset (&desc, 0, sizeof desc);
1722   desc.mode = KEYDB_SEARCH_MODE_FIRST;
1723   desc.skipfnc = search_skipfnc;
1724   desc.skipfncvalue = full_trust;
1725   rc = keydb_search (hd, &desc, 1);
1726   if (rc == -1)
1727     {
1728       keys[nkeys].keyblock = NULL;
1729       return keys;
1730     }
1731   if (rc)
1732     {
1733       log_error ("keydb_search_first failed: %s\n", g10_errstr(rc));
1734       m_free (keys);
1735       return NULL;
1736     }
1737   
1738   desc.mode = KEYDB_SEARCH_MODE_NEXT; /* change mode */
1739   do
1740     {
1741       PKT_public_key *pk;
1742         
1743       rc = keydb_get_keyblock (hd, &keyblock);
1744       if (rc) 
1745         {
1746           log_error ("keydb_get_keyblock failed: %s\n", g10_errstr(rc));
1747           m_free (keys);
1748           return NULL;
1749         }
1750       
1751       if ( keyblock->pkt->pkttype != PKT_PUBLIC_KEY) 
1752         {
1753           log_debug ("ooops: invalid pkttype %d encountered\n",
1754                      keyblock->pkt->pkttype);
1755           dump_kbnode (keyblock);
1756           release_kbnode(keyblock);
1757           continue;
1758         }
1759
1760       /* prepare the keyblock for further processing */
1761       merge_keys_and_selfsig (keyblock); 
1762       clear_kbnode_flags (keyblock);
1763       pk = keyblock->pkt->pkt.public_key;
1764       if (pk->has_expired || pk->is_revoked)
1765         {
1766           /* it does not make sense to look further at those keys */
1767           mark_keyblock_seen (full_trust, keyblock);
1768         }
1769       else if (validate_one_keyblock (keyblock, klist, curtime, next_expire))
1770         {
1771           KBNODE node;
1772
1773           if (pk->expiredate && pk->expiredate >= curtime
1774               && pk->expiredate < *next_expire)
1775             *next_expire = pk->expiredate;
1776
1777           if (nkeys == maxkeys) {
1778             maxkeys += 1000;
1779             keys = m_realloc (keys, (maxkeys+1) * sizeof *keys);
1780           }
1781           keys[nkeys++].keyblock = keyblock;
1782
1783           /* Optimization - if all uids are fully trusted, then we
1784              never need to consider this key as a candidate again. */
1785
1786           for (node=keyblock; node; node = node->next)
1787             if (node->pkt->pkttype == PKT_USER_ID && !(node->flag & 4))
1788               break;
1789
1790           if(node==NULL)
1791             mark_keyblock_seen (full_trust, keyblock);
1792
1793           keyblock = NULL;
1794         }
1795
1796       release_kbnode (keyblock);
1797       keyblock = NULL;
1798     } 
1799   while ( !(rc = keydb_search (hd, &desc, 1)) );
1800   if (rc && rc != -1) 
1801     {
1802       log_error ("keydb_search_next failed: %s\n", g10_errstr(rc));
1803       m_free (keys);
1804       return NULL;
1805     }
1806
1807   keys[nkeys].keyblock = NULL;
1808   return keys;
1809
1810
1811 /* Caller must sync */
1812 static void
1813 reset_trust_records (KEYDB_HANDLE hd, KeyHashTable exclude)
1814 {
1815   int rc;
1816   KBNODE keyblock = NULL;
1817   KEYDB_SEARCH_DESC desc;
1818   int count = 0, nreset = 0;
1819   
1820   rc = keydb_search_reset (hd);
1821   if (rc)
1822     {
1823       log_error ("keydb_search_reset failed: %s\n", g10_errstr(rc));
1824       return;
1825     }
1826
1827   memset (&desc, 0, sizeof desc);
1828   desc.mode = KEYDB_SEARCH_MODE_FIRST;
1829   if(exclude)
1830     {
1831       desc.skipfnc = search_skipfnc;
1832       desc.skipfncvalue = exclude;
1833     }
1834   rc = keydb_search (hd, &desc, 1);
1835   if (rc && rc != -1 )
1836     log_error ("keydb_search_first failed: %s\n", g10_errstr(rc));
1837   else if (!rc)
1838     {
1839       desc.mode = KEYDB_SEARCH_MODE_NEXT; /* change mode */
1840       do
1841         {
1842           rc = keydb_get_keyblock (hd, &keyblock);
1843           if (rc) 
1844             {
1845               log_error ("keydb_get_keyblock failed: %s\n", g10_errstr(rc));
1846               break;
1847             }
1848           count++;
1849
1850           if (keyblock->pkt->pkttype == PKT_PUBLIC_KEY) /* paranoid assertion*/
1851             {
1852               nreset += clear_validity (keyblock->pkt->pkt.public_key);
1853               release_kbnode (keyblock);
1854             } 
1855         }
1856       while ( !(rc = keydb_search (hd, &desc, 1)) );
1857       if (rc && rc != -1) 
1858         log_error ("keydb_search_next failed: %s\n", g10_errstr(rc));
1859     }
1860   if (opt.verbose)
1861     log_info (_("%d keys processed (%d validity counts cleared)\n"),
1862               count, nreset);
1863 }
1864
1865 /*
1866  * Run the key validation procedure.
1867  *
1868  * This works this way:
1869  * Step 1: Find all ultimately trusted keys (UTK).
1870  *         mark them all as seen and put them into klist.
1871  * Step 2: loop max_cert_times
1872  * Step 3:   if OWNERTRUST of any key in klist is undefined
1873  *             ask user to assign ownertrust
1874  * Step 4:   Loop over all keys in the keyDB which are not marked seen 
1875  * Step 5:     if key is revoked or expired
1876  *                mark key as seen
1877  *                continue loop at Step 4
1878  * Step 6:     For each user ID of that key signed by a key in klist
1879  *                Calculate validity by counting trusted signatures.
1880  *                Set validity of user ID
1881  * Step 7:     If any signed user ID was found
1882  *                mark key as seen
1883  *             End Loop
1884  * Step 8:   Build a new klist from all fully trusted keys from step 6
1885  *           End Loop
1886  *         Ready  
1887  *
1888  */
1889 static int
1890 validate_keys (int interactive)
1891 {
1892   int rc = 0;
1893   int quit=0;
1894   struct key_item *klist = NULL;
1895   struct key_item *k;
1896   struct key_array *keys = NULL;
1897   struct key_array *kar;
1898   KEYDB_HANDLE kdb = NULL;
1899   KBNODE node;
1900   int depth;
1901   int key_count;
1902   int ot_unknown, ot_undefined, ot_never, ot_marginal, ot_full, ot_ultimate;
1903   KeyHashTable stored,used,full_trust;
1904   u32 start_time, next_expire;
1905
1906   start_time = make_timestamp ();
1907   next_expire = 0xffffffff; /* set next expire to the year 2106 */
1908   stored = new_key_hash_table ();
1909   used = new_key_hash_table ();
1910   full_trust = new_key_hash_table ();
1911   /* Fixme: Instead of always building a UTK list, we could just build it
1912    * here when needed */
1913   if (!utk_list)
1914     {
1915       log_info (_("no ultimately trusted keys found\n"));
1916       goto leave;
1917     }
1918
1919   kdb = keydb_new (0);
1920
1921   reset_trust_records (kdb,NULL);
1922
1923   /* mark all UTKs as used and fully_trusted and set validity to
1924      ultimate */
1925   for (k=utk_list; k; k = k->next)
1926     {
1927       KBNODE keyblock;
1928       PKT_public_key *pk;
1929
1930       keyblock = get_pubkeyblock (k->kid);
1931       if (!keyblock)
1932         {
1933           log_error (_("public key of ultimately"
1934                        " trusted key %08lX not found\n"), (ulong)k->kid[1]);
1935           continue;
1936         }
1937       mark_keyblock_seen (used, keyblock);
1938       mark_keyblock_seen (stored, keyblock);
1939       mark_keyblock_seen (full_trust, keyblock);
1940       pk = keyblock->pkt->pkt.public_key;
1941       for (node=keyblock; node; node = node->next)
1942         {
1943           if (node->pkt->pkttype == PKT_USER_ID)
1944             update_validity (pk, node->pkt->pkt.user_id, 0, TRUST_ULTIMATE);
1945         }
1946       if ( pk->expiredate && pk->expiredate >= start_time
1947            && pk->expiredate < next_expire)
1948         next_expire = pk->expiredate;
1949       
1950       release_kbnode (keyblock);
1951       do_sync ();
1952     }
1953
1954   klist = utk_list;
1955
1956   log_info(_("%d marginal(s) needed, %d complete(s) needed, %s trust model\n"),
1957            opt.marginals_needed,opt.completes_needed,trust_model_string());
1958
1959   for (depth=0; depth < opt.max_cert_depth; depth++)
1960     {
1961       /* See whether we should assign ownertrust values to the keys in
1962          utk_list.  */
1963       ot_unknown = ot_undefined = ot_never = 0;
1964       ot_marginal = ot_full = ot_ultimate = 0;
1965       for (k=klist; k; k = k->next)
1966         {
1967           int min=0;
1968
1969           /* 120 and 60 are as per RFC2440 */
1970           if(k->trust_value>=120)
1971             min=TRUST_FULLY;
1972           else if(k->trust_value>=60)
1973             min=TRUST_MARGINAL;
1974
1975           if(min!=k->min_ownertrust)
1976             update_min_ownertrust(k->kid,min);
1977
1978           if (interactive && k->ownertrust == TRUST_UNKNOWN)
1979             {
1980               k->ownertrust = ask_ownertrust (k->kid,min);
1981
1982               if (k->ownertrust == -1)
1983                 {
1984                   quit=1;
1985                   goto leave;
1986                 }
1987             }
1988
1989           /* This can happen during transition from an old trustdb
1990              before trust sigs.  It can also happen if a user uses two
1991              different versions of GnuPG or changes the --trust-model
1992              setting. */
1993           if(k->ownertrust<min)
1994             {
1995               if(DBG_TRUST)
1996                 log_debug("key %08lX: "
1997                           "overriding ownertrust \"%s\" with \"%s\"\n",
1998                           (ulong)k->kid[1],
1999                           trust_value_to_string(k->ownertrust),
2000                           trust_value_to_string(min));
2001
2002               k->ownertrust=min;
2003             }
2004
2005           if (k->ownertrust == TRUST_UNKNOWN)
2006             ot_unknown++;
2007           else if (k->ownertrust == TRUST_UNDEFINED)
2008             ot_undefined++;
2009           else if (k->ownertrust == TRUST_NEVER)
2010             ot_never++;
2011           else if (k->ownertrust == TRUST_MARGINAL)
2012             ot_marginal++;
2013           else if (k->ownertrust == TRUST_FULLY)
2014             ot_full++;
2015           else if (k->ownertrust == TRUST_ULTIMATE)
2016             ot_ultimate++;
2017         }
2018
2019       /* Find all keys which are signed by a key in kdlist */
2020       keys = validate_key_list (kdb, full_trust, klist,
2021                                 start_time, &next_expire);
2022       if (!keys) 
2023         {
2024           log_error ("validate_key_list failed\n");
2025           rc = G10ERR_GENERAL;
2026           goto leave;
2027         }
2028
2029       for (key_count=0, kar=keys; kar->keyblock; kar++, key_count++)
2030         ;
2031
2032       /* Store the calculated valididation status somewhere */
2033       if (opt.verbose > 1)
2034         dump_key_array (depth, keys);
2035
2036       for (kar=keys; kar->keyblock; kar++)
2037           store_validation_status (depth, kar->keyblock, stored);
2038
2039       log_info (_("checking at depth %d valid=%d"
2040                   " ot(-/q/n/m/f/u)=%d/%d/%d/%d/%d/%d\n"), 
2041                 depth, key_count, ot_unknown, ot_undefined,
2042                 ot_never, ot_marginal, ot_full, ot_ultimate ); 
2043
2044       /* Build a new kdlist from all fully valid keys in KEYS */
2045       if (klist != utk_list)
2046         release_key_items (klist);
2047       klist = NULL;
2048       for (kar=keys; kar->keyblock; kar++)
2049         {
2050           for (node=kar->keyblock; node; node = node->next)
2051             {
2052               if (node->pkt->pkttype == PKT_USER_ID && (node->flag & 4))
2053                 {
2054                   u32 kid[2];
2055
2056                   /* have we used this key already? */
2057                   keyid_from_pk (kar->keyblock->pkt->pkt.public_key, kid);
2058                   if(test_key_hash_table(used,kid)==0)
2059                     {
2060                       /* Normally we add both the primary and subkey
2061                          ids to the hash via mark_keyblock_seen, but
2062                          since we aren't using this hash as a skipfnc,
2063                          that doesn't matter here. */
2064                       add_key_hash_table (used,kid);
2065                       k = new_key_item ();
2066                       k->kid[0]=kid[0];
2067                       k->kid[1]=kid[1];
2068                       k->ownertrust =
2069                         (get_ownertrust (kar->keyblock->pkt->pkt.public_key)
2070                          & TRUST_MASK);
2071                       k->min_ownertrust =
2072                         get_min_ownertrust(kar->keyblock->pkt->pkt.public_key);
2073                       k->trust_depth=
2074                         kar->keyblock->pkt->pkt.public_key->trust_depth;
2075                       k->trust_value=
2076                         kar->keyblock->pkt->pkt.public_key->trust_value;
2077                       if(kar->keyblock->pkt->pkt.public_key->trust_regexp)
2078                         k->trust_regexp=
2079                           m_strdup(kar->keyblock->pkt->
2080                                    pkt.public_key->trust_regexp);
2081                       k->next = klist;
2082                       klist = k;
2083                       break;
2084                     }
2085                 }
2086             }
2087         }
2088       release_key_array (keys);
2089       keys = NULL;
2090       if (!klist)
2091         break; /* no need to dive in deeper */
2092     }
2093
2094  leave:
2095   keydb_release (kdb);
2096   release_key_array (keys);
2097   release_key_items (klist);
2098   release_key_hash_table (full_trust);
2099   release_key_hash_table (used);
2100   release_key_hash_table (stored);
2101   if (!rc && !quit) /* mark trustDB as checked */
2102     {
2103       if (next_expire == 0xffffffff || next_expire < start_time )
2104         tdbio_write_nextcheck (0); 
2105       else
2106         {
2107           tdbio_write_nextcheck (next_expire); 
2108           log_info (_("next trustdb check due at %s\n"),
2109                     strtimestamp (next_expire));
2110         }
2111
2112       if(tdbio_update_version_record()!=0)
2113         {
2114           log_error(_("unable to update trustdb version record: "
2115                       "write failed: %s\n"), g10_errstr(rc));
2116           tdbio_invalid();
2117         }
2118
2119       do_sync ();
2120       pending_check_trustdb = 0;
2121     }
2122
2123   return rc;
2124 }