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