gpg: Avoid cluttering stdout with trustdb info in verbose mode.
[gnupg.git] / g10 / trustdb.c
1 /* trustdb.c
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
3  *               2008, 2012 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 3 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, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <assert.h>
26
27 #ifndef DISABLE_REGEX
28 #include <sys/types.h>
29 #include <regex.h>
30 #endif /* !DISABLE_REGEX */
31
32 #include "gpg.h"
33 #include "status.h"
34 #include "iobuf.h"
35 #include "keydb.h"
36 #include "util.h"
37 #include "options.h"
38 #include "packet.h"
39 #include "main.h"
40 #include "i18n.h"
41 #include "tdbio.h"
42 #include "trustdb.h"
43
44
45 /*
46  * A structure to store key identification as well as some stuff needed
47  * for validation
48  */
49 struct key_item {
50   struct key_item *next;
51   unsigned int ownertrust,min_ownertrust;
52   byte trust_depth;
53   byte trust_value;
54   char *trust_regexp;
55   u32 kid[2];
56 };
57
58
59 typedef struct key_item **KeyHashTable; /* see new_key_hash_table() */
60
61 /*
62  * Structure to keep track of keys, this is used as an array wherre
63  * the item right after the last one has a keyblock set to NULL.
64  * Maybe we can drop this thing and replace it by key_item
65  */
66 struct key_array {
67   KBNODE keyblock;
68 };
69
70
71 /* control information for the trust DB */
72 static struct {
73     int init;
74     int level;
75     char *dbname;
76     int no_trustdb;   /* Set if a trustdb file is not available.  */
77 } trustdb_args;
78
79 /* some globals */
80 static struct key_item *user_utk_list; /* temp. used to store --trusted-keys */
81 static struct key_item *utk_list;      /* all ultimately trusted keys */
82
83 static int pending_check_trustdb;
84
85 static int validate_keys (int interactive);
86
87 \f
88 /**********************************************
89  ************* some helpers *******************
90  **********************************************/
91
92 static struct key_item *
93 new_key_item (void)
94 {
95   struct key_item *k;
96
97   k = xmalloc_clear (sizeof *k);
98   return k;
99 }
100
101 static void
102 release_key_items (struct key_item *k)
103 {
104   struct key_item *k2;
105
106   for (; k; k = k2)
107     {
108       k2 = k->next;
109       xfree (k->trust_regexp);
110       xfree (k);
111     }
112 }
113
114 /*
115  * For fast keylook up we need a hash table.  Each byte of a KeyIDs
116  * should be distributed equally over the 256 possible values (except
117  * for v3 keyIDs but we consider them as not important here). So we
118  * can just use 10 bits to index a table of 1024 key items.
119  * Possible optimization: Don not use key_items but other hash_table when the
120  * duplicates lists gets too large.
121  */
122 static KeyHashTable
123 new_key_hash_table (void)
124 {
125   struct key_item **tbl;
126
127   tbl = xmalloc_clear (1024 * sizeof *tbl);
128   return tbl;
129 }
130
131 static void
132 release_key_hash_table (KeyHashTable tbl)
133 {
134   int i;
135
136   if (!tbl)
137     return;
138   for (i=0; i < 1024; i++)
139     release_key_items (tbl[i]);
140   xfree (tbl);
141 }
142
143 /*
144  * Returns: True if the keyID is in the given hash table
145  */
146 static int
147 test_key_hash_table (KeyHashTable tbl, u32 *kid)
148 {
149   struct key_item *k;
150
151   for (k = tbl[(kid[1] & 0x03ff)]; k; k = k->next)
152     if (k->kid[0] == kid[0] && k->kid[1] == kid[1])
153       return 1;
154   return 0;
155 }
156
157 /*
158  * Add a new key to the hash table.  The key is identified by its key ID.
159  */
160 static void
161 add_key_hash_table (KeyHashTable tbl, u32 *kid)
162 {
163   struct key_item *k, *kk;
164
165   for (k = tbl[(kid[1] & 0x03ff)]; k; k = k->next)
166     if (k->kid[0] == kid[0] && k->kid[1] == kid[1])
167       return; /* already in table */
168
169   kk = new_key_item ();
170   kk->kid[0] = kid[0];
171   kk->kid[1] = kid[1];
172   kk->next = tbl[(kid[1] & 0x03ff)];
173   tbl[(kid[1] & 0x03ff)] = kk;
174 }
175
176 /*
177  * Release a key_array
178  */
179 static void
180 release_key_array ( struct key_array *keys )
181 {
182     struct key_array *k;
183
184     if (keys) {
185         for (k=keys; k->keyblock; k++)
186             release_kbnode (k->keyblock);
187         xfree (keys);
188     }
189 }
190
191 \f
192 /*********************************************
193  **********  Initialization  *****************
194  *********************************************/
195
196
197
198 /*
199  * Used to register extra ultimately trusted keys - this has to be done
200  * before initializing the validation module.
201  * FIXME: Should be replaced by a function to add those keys to the trustdb.
202  */
203 void
204 register_trusted_keyid(u32 *keyid)
205 {
206   struct key_item *k;
207
208   k = new_key_item ();
209   k->kid[0] = keyid[0];
210   k->kid[1] = keyid[1];
211   k->next = user_utk_list;
212   user_utk_list = k;
213 }
214
215 void
216 register_trusted_key( const char *string )
217 {
218   KEYDB_SEARCH_DESC desc;
219
220   if (classify_user_id (string, &desc) != KEYDB_SEARCH_MODE_LONG_KID )
221     {
222       log_error(_("`%s' is not a valid long keyID\n"), string );
223       return;
224     }
225
226   register_trusted_keyid(desc.u.kid);
227 }
228
229 /*
230  * Helper to add a key to the global list of ultimately trusted keys.
231  * Retruns: true = inserted, false = already in in list.
232  */
233 static int
234 add_utk (u32 *kid)
235 {
236   struct key_item *k;
237
238   for (k = utk_list; k; k = k->next)
239     {
240       if (k->kid[0] == kid[0] && k->kid[1] == kid[1])
241         {
242           return 0;
243         }
244     }
245
246   k = new_key_item ();
247   k->kid[0] = kid[0];
248   k->kid[1] = kid[1];
249   k->ownertrust = TRUST_ULTIMATE;
250   k->next = utk_list;
251   utk_list = k;
252   if( opt.verbose > 1 )
253     log_info(_("key %s: accepted as trusted key\n"), keystr(kid));
254   return 1;
255 }
256
257
258 /****************
259  * Verify that all our secret keys are usable and put them into the utk_list.
260  */
261 static void
262 verify_own_keys(void)
263 {
264   TRUSTREC rec;
265   ulong recnum;
266   int rc;
267   struct key_item *k;
268
269   if (utk_list)
270     return;
271
272   /* scan the trustdb to find all ultimately trusted keys */
273   for (recnum=1; !tdbio_read_record (recnum, &rec, 0); recnum++ )
274     {
275       if ( rec.rectype == RECTYPE_TRUST
276            && (rec.r.trust.ownertrust & TRUST_MASK) == TRUST_ULTIMATE)
277         {
278             byte *fpr = rec.r.trust.fingerprint;
279             int fprlen;
280             u32 kid[2];
281
282             /* Problem: We do only use fingerprints in the trustdb but
283              * we need the keyID here to indetify the key; we can only
284              * use that ugly hack to distinguish between 16 and 20
285              * butes fpr - it does not work always so we better change
286              * the whole validation code to only work with
287              * fingerprints */
288             fprlen = (!fpr[16] && !fpr[17] && !fpr[18] && !fpr[19])? 16:20;
289             keyid_from_fingerprint (fpr, fprlen, kid);
290             if (!add_utk (kid))
291               log_info(_("key %s occurs more than once in the trustdb\n"),
292                        keystr(kid));
293         }
294     }
295
296   /* Put any --trusted-key keys into the trustdb */
297   for (k = user_utk_list; k; k = k->next)
298     {
299       if ( add_utk (k->kid) )
300         { /* not yet in trustDB as ultimately trusted */
301           PKT_public_key pk;
302
303           memset (&pk, 0, sizeof pk);
304           rc = get_pubkey (&pk, k->kid);
305           if (rc)
306             log_info(_("key %s: no public key for trusted key - skipped\n"),
307                      keystr(k->kid));
308           else
309             {
310               update_ownertrust (&pk,
311                                  ((get_ownertrust (&pk) & ~TRUST_MASK)
312                                   | TRUST_ULTIMATE ));
313               release_public_key_parts (&pk);
314             }
315
316           log_info (_("key %s marked as ultimately trusted\n"),keystr(k->kid));
317         }
318     }
319
320   /* release the helper table table */
321   release_key_items (user_utk_list);
322   user_utk_list = NULL;
323   return;
324 }
325
326 \f
327 /*********************************************
328  *********** TrustDB stuff *******************
329  *********************************************/
330
331 /*
332  * Read a record but die if it does not exist
333  */
334 static void
335 read_record (ulong recno, TRUSTREC *rec, int rectype )
336 {
337   int rc = tdbio_read_record (recno, rec, rectype);
338   if (rc)
339     {
340       log_error(_("trust record %lu, req type %d: read failed: %s\n"),
341                 recno, rec->rectype, g10_errstr(rc) );
342       tdbio_invalid();
343     }
344   if (rectype != rec->rectype)
345     {
346       log_error(_("trust record %lu is not of requested type %d\n"),
347                 rec->recnum, rectype);
348       tdbio_invalid();
349     }
350 }
351
352 /*
353  * Write a record and die on error
354  */
355 static void
356 write_record (TRUSTREC *rec)
357 {
358   int rc = tdbio_write_record (rec);
359   if (rc)
360     {
361       log_error(_("trust record %lu, type %d: write failed: %s\n"),
362                             rec->recnum, rec->rectype, g10_errstr(rc) );
363       tdbio_invalid();
364     }
365 }
366
367 /*
368  * sync the TrustDb and die on error
369  */
370 static void
371 do_sync(void)
372 {
373     int rc = tdbio_sync ();
374     if(rc)
375       {
376         log_error (_("trustdb: sync failed: %s\n"), g10_errstr(rc) );
377         g10_exit(2);
378       }
379 }
380
381 static const char *
382 trust_model_string(void)
383 {
384   switch(opt.trust_model)
385     {
386     case TM_CLASSIC:  return "classic";
387     case TM_PGP:      return "PGP";
388     case TM_EXTERNAL: return "external";
389     case TM_ALWAYS:   return "always";
390     case TM_DIRECT:   return "direct";
391     default:          return "unknown";
392     }
393 }
394
395 /****************
396  * Perform some checks over the trustdb
397  *  level 0: only open the db
398  *        1: used for initial program startup
399  */
400 int
401 setup_trustdb( int level, const char *dbname )
402 {
403     /* just store the args */
404     if( trustdb_args.init )
405         return 0;
406     trustdb_args.level = level;
407     trustdb_args.dbname = dbname? xstrdup(dbname): NULL;
408     return 0;
409 }
410
411 void
412 how_to_fix_the_trustdb ()
413 {
414   const char *name = trustdb_args.dbname;
415
416   if (!name)
417     name = "trustdb.gpg";
418
419   log_info (_("You may try to re-create the trustdb using the commands:\n"));
420   log_info ("  cd %s\n", default_homedir ());
421   log_info ("  gpg2 --export-ownertrust > otrust.tmp\n");
422 #ifdef HAVE_W32_SYSTEM
423   log_info ("  del %s\n", name);
424 #else
425   log_info ("  rm %s\n", name);
426 #endif
427   log_info ("  gpg2 --import-ownertrust < otrust.tmp\n");
428   log_info (_("If that does not work, please consult the manual\n"));
429 }
430
431
432 void
433 init_trustdb()
434 {
435   int level = trustdb_args.level;
436   const char* dbname = trustdb_args.dbname;
437
438   if( trustdb_args.init )
439     return;
440
441   trustdb_args.init = 1;
442
443   if(level==0 || level==1)
444     {
445       int rc = tdbio_set_dbname (dbname, !!level, &trustdb_args.no_trustdb);
446       if( rc )
447         log_fatal("can't init trustdb: %s\n", g10_errstr(rc) );
448     }
449   else
450     BUG();
451
452   if(opt.trust_model==TM_AUTO)
453     {
454       /* Try and set the trust model off of whatever the trustdb says
455          it is. */
456       opt.trust_model=tdbio_read_model();
457
458       /* Sanity check this ;) */
459       if(opt.trust_model!=TM_CLASSIC
460          && opt.trust_model!=TM_PGP
461          && opt.trust_model!=TM_EXTERNAL)
462         {
463           log_info(_("unable to use unknown trust model (%d) - "
464                      "assuming %s trust model\n"),opt.trust_model,"PGP");
465           opt.trust_model=TM_PGP;
466         }
467
468       if(opt.verbose)
469         log_info(_("using %s trust model\n"),trust_model_string());
470     }
471
472   if(opt.trust_model==TM_PGP || opt.trust_model==TM_CLASSIC)
473     {
474       /* Verify the list of ultimately trusted keys and move the
475          --trusted-keys list there as well. */
476       if(level==1)
477         verify_own_keys();
478
479       if(!tdbio_db_matches_options())
480         pending_check_trustdb=1;
481     }
482 }
483
484
485 /***********************************************
486  *************  Print helpers   ****************
487  ***********************************************/
488
489 /****************
490  * This function returns a letter for a trustvalue  Trust flags
491  * are ignore.
492  */
493 static int
494 trust_letter (unsigned int value)
495 {
496   switch( (value & TRUST_MASK) )
497     {
498     case TRUST_UNKNOWN:   return '-';
499     case TRUST_EXPIRED:   return 'e';
500     case TRUST_UNDEFINED: return 'q';
501     case TRUST_NEVER:     return 'n';
502     case TRUST_MARGINAL:  return 'm';
503     case TRUST_FULLY:     return 'f';
504     case TRUST_ULTIMATE:  return 'u';
505     default:              return '?';
506     }
507 }
508
509 const char *
510 uid_trust_string_fixed(PKT_public_key *key,PKT_user_id *uid)
511 {
512   if(!key && !uid)
513 /* TRANSLATORS: these strings are similar to those in
514    trust_value_to_string(), but are a fixed length.  This is needed to
515    make attractive information listings where columns line up
516    properly.  The value "10" should be the length of the strings you
517    choose to translate to.  This is the length in printable columns.
518    It gets passed to atoi() so everything after the number is
519    essentially a comment and need not be translated.  Either key and
520    uid are both NULL, or neither are NULL. */
521     return _("10 translator see trustdb.c:uid_trust_string_fixed");
522   else if(uid->is_revoked || (key && key->is_revoked))
523     return                         _("[ revoked]");
524   else if(uid->is_expired)
525     return                         _("[ expired]");
526   else if(key)
527     switch(get_validity(key,uid)&TRUST_MASK)
528       {
529       case TRUST_UNKNOWN:   return _("[ unknown]");
530       case TRUST_EXPIRED:   return _("[ expired]");
531       case TRUST_UNDEFINED: return _("[  undef ]");
532       case TRUST_MARGINAL:  return _("[marginal]");
533       case TRUST_FULLY:     return _("[  full  ]");
534       case TRUST_ULTIMATE:  return _("[ultimate]");
535       }
536
537   return "err";
538 }
539
540 /* The strings here are similar to those in
541    pkclist.c:do_edit_ownertrust() */
542 const char *
543 trust_value_to_string (unsigned int value)
544 {
545   switch( (value & TRUST_MASK) )
546     {
547     case TRUST_UNKNOWN:   return _("unknown");
548     case TRUST_EXPIRED:   return _("expired");
549     case TRUST_UNDEFINED: return _("undefined");
550     case TRUST_NEVER:     return _("never");
551     case TRUST_MARGINAL:  return _("marginal");
552     case TRUST_FULLY:     return _("full");
553     case TRUST_ULTIMATE:  return _("ultimate");
554     default:              return "err";
555     }
556 }
557
558 int
559 string_to_trust_value (const char *str)
560 {
561   if(ascii_strcasecmp(str,"undefined")==0)
562     return TRUST_UNDEFINED;
563   else if(ascii_strcasecmp(str,"never")==0)
564     return TRUST_NEVER;
565   else if(ascii_strcasecmp(str,"marginal")==0)
566     return TRUST_MARGINAL;
567   else if(ascii_strcasecmp(str,"full")==0)
568     return TRUST_FULLY;
569   else if(ascii_strcasecmp(str,"ultimate")==0)
570     return TRUST_ULTIMATE;
571   else
572     return -1;
573 }
574
575 /****************
576  * Recreate the WoT but do not ask for new ownertrusts.  Special
577  * feature: In batch mode and without a forced yes, this is only done
578  * when a check is due.  This can be used to run the check from a crontab
579  */
580 void
581 check_trustdb ()
582 {
583   init_trustdb();
584   if(opt.trust_model==TM_PGP || opt.trust_model==TM_CLASSIC)
585     {
586       if (opt.batch && !opt.answer_yes)
587         {
588           ulong scheduled;
589
590           scheduled = tdbio_read_nextcheck ();
591           if (!scheduled)
592             {
593               log_info (_("no need for a trustdb check\n"));
594               return;
595             }
596
597           if (scheduled > make_timestamp ())
598             {
599               log_info (_("next trustdb check due at %s\n"),
600                         strtimestamp (scheduled));
601               return;
602             }
603         }
604
605       validate_keys (0);
606     }
607   else
608     log_info (_("no need for a trustdb check with `%s' trust model\n"),
609               trust_model_string());
610 }
611
612
613 /*
614  * Recreate the WoT.
615  */
616 void
617 update_trustdb()
618 {
619   init_trustdb();
620   if(opt.trust_model==TM_PGP || opt.trust_model==TM_CLASSIC)
621     validate_keys (1);
622   else
623     log_info (_("no need for a trustdb update with `%s' trust model\n"),
624               trust_model_string());
625 }
626
627 void
628 revalidation_mark (void)
629 {
630   init_trustdb();
631   if (trustdb_args.no_trustdb && opt.trust_model == TM_ALWAYS)
632     return;
633
634   /* we simply set the time for the next check to 1 (far back in 1970)
635    * so that a --update-trustdb will be scheduled */
636   if (tdbio_write_nextcheck (1))
637       do_sync ();
638   pending_check_trustdb = 1;
639 }
640
641 int
642 trustdb_pending_check(void)
643 {
644   return pending_check_trustdb;
645 }
646
647 /* If the trustdb is dirty, and we're interactive, update it.
648    Otherwise, check it unless no-auto-check-trustdb is set. */
649 void
650 trustdb_check_or_update(void)
651 {
652   if(trustdb_pending_check())
653     {
654       if(opt.interactive)
655         update_trustdb();
656       else if(!opt.no_auto_check_trustdb)
657         check_trustdb();
658     }
659 }
660
661 void
662 read_trust_options(byte *trust_model,ulong *created,ulong *nextcheck,
663                    byte *marginals,byte *completes,byte *cert_depth,
664                    byte *min_cert_level)
665 {
666   TRUSTREC opts;
667
668   init_trustdb();
669   if (trustdb_args.no_trustdb && opt.trust_model == TM_ALWAYS)
670     memset (&opts, 0, sizeof opts);
671   else
672     read_record(0,&opts,RECTYPE_VER);
673
674   if(trust_model)
675     *trust_model=opts.r.ver.trust_model;
676   if(created)
677     *created=opts.r.ver.created;
678   if(nextcheck)
679     *nextcheck=opts.r.ver.nextcheck;
680   if(marginals)
681     *marginals=opts.r.ver.marginals;
682   if(completes)
683     *completes=opts.r.ver.completes;
684   if(cert_depth)
685     *cert_depth=opts.r.ver.cert_depth;
686   if(min_cert_level)
687     *min_cert_level=opts.r.ver.min_cert_level;
688 }
689
690 /***********************************************
691  ***********  Ownertrust et al. ****************
692  ***********************************************/
693
694 static int
695 read_trust_record (PKT_public_key *pk, TRUSTREC *rec)
696 {
697   int rc;
698
699   init_trustdb();
700   rc = tdbio_search_trust_bypk (pk, rec);
701   if (rc == -1)
702     return -1; /* no record yet */
703   if (rc)
704     {
705       log_error ("trustdb: searching trust record failed: %s\n",
706                  g10_errstr (rc));
707       return rc;
708     }
709
710   if (rec->rectype != RECTYPE_TRUST)
711     {
712       log_error ("trustdb: record %lu is not a trust record\n",
713                  rec->recnum);
714       return G10ERR_TRUSTDB;
715     }
716
717   return 0;
718 }
719
720 /****************
721  * Return the assigned ownertrust value for the given public key.
722  * The key should be the primary key.
723  */
724 unsigned int
725 get_ownertrust ( PKT_public_key *pk)
726 {
727   TRUSTREC rec;
728   int rc;
729
730   if (trustdb_args.no_trustdb && opt.trust_model == TM_ALWAYS)
731     return TRUST_UNKNOWN;
732
733   rc = read_trust_record (pk, &rec);
734   if (rc == -1)
735     return TRUST_UNKNOWN; /* no record yet */
736   if (rc)
737     {
738       tdbio_invalid ();
739       return rc; /* actually never reached */
740     }
741
742   return rec.r.trust.ownertrust;
743 }
744
745 unsigned int
746 get_min_ownertrust (PKT_public_key *pk)
747 {
748   TRUSTREC rec;
749   int rc;
750
751   if (trustdb_args.no_trustdb && opt.trust_model == TM_ALWAYS)
752     return TRUST_UNKNOWN;
753
754   rc = read_trust_record (pk, &rec);
755   if (rc == -1)
756     return TRUST_UNKNOWN; /* no record yet */
757   if (rc)
758     {
759       tdbio_invalid ();
760       return rc; /* actually never reached */
761     }
762
763   return rec.r.trust.min_ownertrust;
764 }
765
766 /*
767  * Same as get_ownertrust but this takes the minimum ownertrust value
768  * into into account, and will bump up the value as needed.
769  */
770 static int
771 get_ownertrust_with_min (PKT_public_key *pk)
772 {
773   unsigned int otrust,otrust_min;
774
775   otrust = (get_ownertrust (pk) & TRUST_MASK);
776   otrust_min = get_min_ownertrust (pk);
777   if(otrust<otrust_min)
778     {
779       /* If the trust that the user has set is less than the trust
780          that was calculated from a trust signature chain, use the
781          higher of the two.  We do this here and not in
782          get_ownertrust since the underlying ownertrust should not
783          really be set - just the appearance of the ownertrust. */
784
785       otrust=otrust_min;
786     }
787
788   return otrust;
789 }
790
791 /*
792  * Same as get_ownertrust but return a trust letter instead of an
793  * value.  This takes the minimum ownertrust value into account.
794  */
795 int
796 get_ownertrust_info (PKT_public_key *pk)
797 {
798   return trust_letter(get_ownertrust_with_min(pk));
799 }
800
801 /*
802  * Same as get_ownertrust but return a trust string instead of an
803  * value.  This takes the minimum ownertrust value into account.
804  */
805 const char *
806 get_ownertrust_string (PKT_public_key *pk)
807 {
808   return trust_value_to_string(get_ownertrust_with_min(pk));
809 }
810
811 /*
812  * Set the trust value of the given public key to the new value.
813  * The key should be a primary one.
814  */
815 void
816 update_ownertrust (PKT_public_key *pk, unsigned int new_trust )
817 {
818   TRUSTREC rec;
819   int rc;
820
821   if (trustdb_args.no_trustdb && opt.trust_model == TM_ALWAYS)
822     return;
823
824   rc = read_trust_record (pk, &rec);
825   if (!rc)
826     {
827       if (DBG_TRUST)
828         log_debug ("update ownertrust from %u to %u\n",
829                    (unsigned int)rec.r.trust.ownertrust, new_trust );
830       if (rec.r.trust.ownertrust != new_trust)
831         {
832           rec.r.trust.ownertrust = new_trust;
833           write_record( &rec );
834           revalidation_mark ();
835           do_sync ();
836         }
837     }
838   else if (rc == -1)
839     { /* no record yet - create a new one */
840       size_t dummy;
841
842       if (DBG_TRUST)
843         log_debug ("insert ownertrust %u\n", new_trust );
844
845       memset (&rec, 0, sizeof rec);
846       rec.recnum = tdbio_new_recnum ();
847       rec.rectype = RECTYPE_TRUST;
848       fingerprint_from_pk (pk, rec.r.trust.fingerprint, &dummy);
849       rec.r.trust.ownertrust = new_trust;
850       write_record (&rec);
851       revalidation_mark ();
852       do_sync ();
853       rc = 0;
854     }
855   else
856     {
857       tdbio_invalid ();
858     }
859 }
860
861 static void
862 update_min_ownertrust (u32 *kid, unsigned int new_trust )
863 {
864   PKT_public_key *pk;
865   TRUSTREC rec;
866   int rc;
867
868   if (trustdb_args.no_trustdb && opt.trust_model == TM_ALWAYS)
869     return;
870
871   pk = xmalloc_clear (sizeof *pk);
872   rc = get_pubkey (pk, kid);
873   if (rc)
874     {
875       log_error(_("public key %s not found: %s\n"),keystr(kid),g10_errstr(rc));
876       return;
877     }
878
879   rc = read_trust_record (pk, &rec);
880   if (!rc)
881     {
882       if (DBG_TRUST)
883         log_debug ("key %08lX%08lX: update min_ownertrust from %u to %u\n",
884                    (ulong)kid[0],(ulong)kid[1],
885                    (unsigned int)rec.r.trust.min_ownertrust,
886                    new_trust );
887       if (rec.r.trust.min_ownertrust != new_trust)
888         {
889           rec.r.trust.min_ownertrust = new_trust;
890           write_record( &rec );
891           revalidation_mark ();
892           do_sync ();
893         }
894     }
895   else if (rc == -1)
896     { /* no record yet - create a new one */
897       size_t dummy;
898
899       if (DBG_TRUST)
900         log_debug ("insert min_ownertrust %u\n", new_trust );
901
902       memset (&rec, 0, sizeof rec);
903       rec.recnum = tdbio_new_recnum ();
904       rec.rectype = RECTYPE_TRUST;
905       fingerprint_from_pk (pk, rec.r.trust.fingerprint, &dummy);
906       rec.r.trust.min_ownertrust = new_trust;
907       write_record (&rec);
908       revalidation_mark ();
909       do_sync ();
910       rc = 0;
911     }
912   else
913     {
914       tdbio_invalid ();
915     }
916 }
917
918 /* Clear the ownertrust and min_ownertrust values.  Return true if a
919    change actually happened. */
920 int
921 clear_ownertrusts (PKT_public_key *pk)
922 {
923   TRUSTREC rec;
924   int rc;
925
926   init_trustdb();
927
928   if (trustdb_args.no_trustdb && opt.trust_model == TM_ALWAYS)
929     return 0;
930
931   rc = read_trust_record (pk, &rec);
932   if (!rc)
933     {
934       if (DBG_TRUST)
935         {
936           log_debug ("clearing ownertrust (old value %u)\n",
937                      (unsigned int)rec.r.trust.ownertrust);
938           log_debug ("clearing min_ownertrust (old value %u)\n",
939                      (unsigned int)rec.r.trust.min_ownertrust);
940         }
941       if (rec.r.trust.ownertrust || rec.r.trust.min_ownertrust)
942         {
943           rec.r.trust.ownertrust = 0;
944           rec.r.trust.min_ownertrust = 0;
945           write_record( &rec );
946           revalidation_mark ();
947           do_sync ();
948           return 1;
949         }
950     }
951   else if (rc != -1)
952     {
953       tdbio_invalid ();
954     }
955   return 0;
956 }
957
958 /*
959  * Note: Caller has to do a sync
960  */
961 static void
962 update_validity (PKT_public_key *pk, PKT_user_id *uid,
963                  int depth, int validity)
964 {
965   TRUSTREC trec, vrec;
966   int rc;
967   ulong recno;
968
969   namehash_from_uid(uid);
970
971   rc = read_trust_record (pk, &trec);
972   if (rc && rc != -1)
973     {
974       tdbio_invalid ();
975       return;
976     }
977   if (rc == -1) /* no record yet - create a new one */
978     {
979       size_t dummy;
980
981       rc = 0;
982       memset (&trec, 0, sizeof trec);
983       trec.recnum = tdbio_new_recnum ();
984       trec.rectype = RECTYPE_TRUST;
985       fingerprint_from_pk (pk, trec.r.trust.fingerprint, &dummy);
986       trec.r.trust.ownertrust = 0;
987       }
988
989   /* locate an existing one */
990   recno = trec.r.trust.validlist;
991   while (recno)
992     {
993       read_record (recno, &vrec, RECTYPE_VALID);
994       if ( !memcmp (vrec.r.valid.namehash, uid->namehash, 20) )
995         break;
996       recno = vrec.r.valid.next;
997     }
998
999   if (!recno) /* insert a new validity record */
1000     {
1001       memset (&vrec, 0, sizeof vrec);
1002       vrec.recnum = tdbio_new_recnum ();
1003       vrec.rectype = RECTYPE_VALID;
1004       memcpy (vrec.r.valid.namehash, uid->namehash, 20);
1005       vrec.r.valid.next = trec.r.trust.validlist;
1006       trec.r.trust.validlist = vrec.recnum;
1007     }
1008   vrec.r.valid.validity = validity;
1009   vrec.r.valid.full_count = uid->help_full_count;
1010   vrec.r.valid.marginal_count = uid->help_marginal_count;
1011   write_record (&vrec);
1012   trec.r.trust.depth = depth;
1013   write_record (&trec);
1014 }
1015
1016
1017 /***********************************************
1018  *********  Query trustdb values  **************
1019  ***********************************************/
1020
1021 /* Return true if key is disabled */
1022 int
1023 cache_disabled_value(PKT_public_key *pk)
1024 {
1025   int rc;
1026   TRUSTREC trec;
1027   int disabled=0;
1028
1029   if(pk->is_disabled)
1030     return (pk->is_disabled==2);
1031
1032   init_trustdb();
1033   if (trustdb_args.no_trustdb)
1034     return 0;  /* No trustdb => not disabled.  */
1035
1036   rc = read_trust_record (pk, &trec);
1037   if (rc && rc != -1)
1038     {
1039       tdbio_invalid ();
1040       goto leave;
1041     }
1042   if (rc == -1) /* no record found, so assume not disabled */
1043     goto leave;
1044
1045   if(trec.r.trust.ownertrust & TRUST_FLAG_DISABLED)
1046     disabled=1;
1047
1048   /* Cache it for later so we don't need to look at the trustdb every
1049      time */
1050   if(disabled)
1051     pk->is_disabled=2;
1052   else
1053     pk->is_disabled=1;
1054
1055  leave:
1056    return disabled;
1057 }
1058
1059 void
1060 check_trustdb_stale(void)
1061 {
1062   static int did_nextcheck=0;
1063
1064   init_trustdb ();
1065   if (trustdb_args.no_trustdb)
1066     return;  /* No trustdb => can't be stale.  */
1067
1068   if (!did_nextcheck
1069       && (opt.trust_model==TM_PGP || opt.trust_model==TM_CLASSIC))
1070     {
1071       ulong scheduled;
1072
1073       did_nextcheck = 1;
1074       scheduled = tdbio_read_nextcheck ();
1075       if ((scheduled && scheduled <= make_timestamp ())
1076           || pending_check_trustdb)
1077         {
1078           if (opt.no_auto_check_trustdb)
1079             {
1080               pending_check_trustdb = 1;
1081               log_info (_("please do a --check-trustdb\n"));
1082             }
1083           else
1084             {
1085               log_info (_("checking the trustdb\n"));
1086               validate_keys (0);
1087             }
1088         }
1089     }
1090 }
1091
1092 /*
1093  * Return the validity information for PK.  If the namehash is not
1094  * NULL, the validity of the corresponsing user ID is returned,
1095  * otherwise, a reasonable value for the entire key is returned.
1096  */
1097 unsigned int
1098 get_validity (PKT_public_key *pk, PKT_user_id *uid)
1099 {
1100   TRUSTREC trec, vrec;
1101   int rc;
1102   ulong recno;
1103   unsigned int validity;
1104   u32 kid[2];
1105   PKT_public_key *main_pk;
1106
1107   if(uid)
1108     namehash_from_uid(uid);
1109
1110   init_trustdb ();
1111
1112   /* If we have no trustdb (which also means it has not been created)
1113      and the trust-model is always, we don't know the validity -
1114      return immediately.  If we won't do that the tdbio code would try
1115      to open the trustdb and run into a fatal error.  */
1116   if (trustdb_args.no_trustdb && opt.trust_model == TM_ALWAYS)
1117     return TRUST_UNKNOWN;
1118
1119   check_trustdb_stale();
1120
1121   keyid_from_pk (pk, kid);
1122   if (pk->main_keyid[0] != kid[0] || pk->main_keyid[1] != kid[1])
1123     { /* this is a subkey - get the mainkey */
1124       main_pk = xmalloc_clear (sizeof *main_pk);
1125       rc = get_pubkey (main_pk, pk->main_keyid);
1126       if (rc)
1127         {
1128           char *tempkeystr=xstrdup(keystr(pk->main_keyid));
1129           log_error ("error getting main key %s of subkey %s: %s\n",
1130                      tempkeystr, keystr(kid), g10_errstr(rc));
1131           xfree(tempkeystr);
1132           validity = TRUST_UNKNOWN;
1133           goto leave;
1134         }
1135     }
1136   else
1137     main_pk = pk;
1138
1139   if(opt.trust_model==TM_DIRECT)
1140     {
1141       /* Note that this happens BEFORE any user ID stuff is checked.
1142          The direct trust model applies to keys as a whole. */
1143       validity=get_ownertrust(main_pk);
1144       goto leave;
1145     }
1146
1147   rc = read_trust_record (main_pk, &trec);
1148   if (rc && rc != -1)
1149     {
1150       tdbio_invalid ();
1151       return 0;
1152     }
1153   if (rc == -1) /* no record found */
1154     {
1155       validity = TRUST_UNKNOWN;
1156       goto leave;
1157     }
1158
1159   /* loop over all user IDs */
1160   recno = trec.r.trust.validlist;
1161   validity = 0;
1162   while (recno)
1163     {
1164       read_record (recno, &vrec, RECTYPE_VALID);
1165
1166       if(uid)
1167         {
1168           /* If a user ID is given we return the validity for that
1169              user ID ONLY.  If the namehash is not found, then there
1170              is no validity at all (i.e. the user ID wasn't
1171              signed). */
1172           if(memcmp(vrec.r.valid.namehash,uid->namehash,20)==0)
1173             {
1174               validity=(vrec.r.valid.validity & TRUST_MASK);
1175               break;
1176             }
1177         }
1178       else
1179         {
1180           /* If no namehash is given, we take the maximum validity
1181              over all user IDs */
1182           if ( validity < (vrec.r.valid.validity & TRUST_MASK) )
1183             validity = (vrec.r.valid.validity & TRUST_MASK);
1184         }
1185
1186       recno = vrec.r.valid.next;
1187     }
1188
1189   if ( (trec.r.trust.ownertrust & TRUST_FLAG_DISABLED) )
1190     {
1191       validity |= TRUST_FLAG_DISABLED;
1192       pk->is_disabled=2;
1193     }
1194   else
1195     pk->is_disabled=1;
1196
1197  leave:
1198   /* set some flags direct from the key */
1199   if (main_pk->is_revoked)
1200     validity |= TRUST_FLAG_REVOKED;
1201   if (main_pk != pk && pk->is_revoked)
1202     validity |= TRUST_FLAG_SUB_REVOKED;
1203   /* Note: expiration is a trust value and not a flag - don't know why
1204    * I initially designed it that way */
1205   if (main_pk->has_expired || pk->has_expired)
1206     validity = (validity & ~TRUST_MASK) | TRUST_EXPIRED;
1207
1208   if (pending_check_trustdb)
1209     validity |= TRUST_FLAG_PENDING_CHECK;
1210
1211   if (main_pk != pk)
1212     free_public_key (main_pk);
1213   return validity;
1214 }
1215
1216 int
1217 get_validity_info (PKT_public_key *pk, PKT_user_id *uid)
1218 {
1219   int trustlevel;
1220
1221   if (!pk)
1222     return '?';  /* Just in case a NULL PK is passed.  */
1223
1224   trustlevel = get_validity (pk, uid);
1225   if ( (trustlevel & TRUST_FLAG_REVOKED) )
1226     return 'r';
1227   return trust_letter (trustlevel);
1228 }
1229
1230 const char *
1231 get_validity_string (PKT_public_key *pk, PKT_user_id *uid)
1232 {
1233   int trustlevel;
1234
1235   if (!pk)
1236     return "err";  /* Just in case a NULL PK is passed.  */
1237
1238   trustlevel = get_validity (pk, uid);
1239   if( trustlevel & TRUST_FLAG_REVOKED )
1240     return _("revoked");
1241   return trust_value_to_string(trustlevel);
1242 }
1243
1244 static void
1245 get_validity_counts (PKT_public_key *pk, PKT_user_id *uid)
1246 {
1247   TRUSTREC trec, vrec;
1248   ulong recno;
1249
1250   if(pk==NULL || uid==NULL)
1251     BUG();
1252
1253   namehash_from_uid(uid);
1254
1255   uid->help_marginal_count=uid->help_full_count=0;
1256
1257   init_trustdb ();
1258
1259   if(read_trust_record (pk, &trec)!=0)
1260     return;
1261
1262   /* loop over all user IDs */
1263   recno = trec.r.trust.validlist;
1264   while (recno)
1265     {
1266       read_record (recno, &vrec, RECTYPE_VALID);
1267
1268       if(memcmp(vrec.r.valid.namehash,uid->namehash,20)==0)
1269         {
1270           uid->help_marginal_count=vrec.r.valid.marginal_count;
1271           uid->help_full_count=vrec.r.valid.full_count;
1272           /*  printf("Fetched marginal %d, full %d\n",uid->help_marginal_count,uid->help_full_count); */
1273           break;
1274         }
1275
1276       recno = vrec.r.valid.next;
1277     }
1278 }
1279
1280 void
1281 list_trust_path( const char *username )
1282 {
1283   (void)username;
1284 }
1285
1286 /****************
1287  * Enumerate all keys, which are needed to build all trust paths for
1288  * the given key.  This function does not return the key itself or
1289  * the ultimate key (the last point in cerificate chain).  Only
1290  * certificate chains which ends up at an ultimately trusted key
1291  * are listed.  If ownertrust or validity is not NULL, the corresponding
1292  * value for the returned LID is also returned in these variable(s).
1293  *
1294  *  1) create a void pointer and initialize it to NULL
1295  *  2) pass this void pointer by reference to this function.
1296  *     Set lid to the key you want to enumerate and pass it by reference.
1297  *  3) call this function as long as it does not return -1
1298  *     to indicate EOF. LID does contain the next key used to build the web
1299  *  4) Always call this function a last time with LID set to NULL,
1300  *     so that it can free its context.
1301  *
1302  * Returns: -1 on EOF or the level of the returned LID
1303  */
1304 int
1305 enum_cert_paths( void **context, ulong *lid,
1306                  unsigned *ownertrust, unsigned *validity )
1307 {
1308   (void)context;
1309   (void)lid;
1310   (void)ownertrust;
1311   (void)validity;
1312   return -1;
1313 }
1314
1315
1316 /****************
1317  * Print the current path
1318  */
1319 void
1320 enum_cert_paths_print (void **context, FILE *fp,
1321                        int refresh, ulong selected_lid)
1322 {
1323   (void)context;
1324   (void)fp;
1325   (void)refresh;
1326   (void)selected_lid;
1327 }
1328
1329
1330 \f
1331 /****************************************
1332  *********** NEW NEW NEW ****************
1333  ****************************************/
1334
1335 static int
1336 ask_ownertrust (u32 *kid,int minimum)
1337 {
1338   PKT_public_key *pk;
1339   int rc;
1340   int ot;
1341
1342   pk = xmalloc_clear (sizeof *pk);
1343   rc = get_pubkey (pk, kid);
1344   if (rc)
1345     {
1346       log_error (_("public key %s not found: %s\n"),
1347                  keystr(kid), g10_errstr(rc) );
1348       return TRUST_UNKNOWN;
1349     }
1350
1351   if(opt.force_ownertrust)
1352     {
1353       log_info("force trust for key %s to %s\n",
1354                keystr(kid),trust_value_to_string(opt.force_ownertrust));
1355       update_ownertrust(pk,opt.force_ownertrust);
1356       ot=opt.force_ownertrust;
1357     }
1358   else
1359     {
1360       ot=edit_ownertrust(pk,0);
1361       if(ot>0)
1362         ot = get_ownertrust (pk);
1363       else if(ot==0)
1364         ot = minimum?minimum:TRUST_UNDEFINED;
1365       else
1366         ot = -1; /* quit */
1367     }
1368
1369   free_public_key( pk );
1370
1371   return ot;
1372 }
1373
1374
1375 static void
1376 mark_keyblock_seen (KeyHashTable tbl, KBNODE node)
1377 {
1378   for ( ;node; node = node->next )
1379     if (node->pkt->pkttype == PKT_PUBLIC_KEY
1380         || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1381       {
1382         u32 aki[2];
1383
1384         keyid_from_pk (node->pkt->pkt.public_key, aki);
1385         add_key_hash_table (tbl, aki);
1386       }
1387 }
1388
1389
1390 static void
1391 dump_key_array (int depth, struct key_array *keys)
1392 {
1393   struct key_array *kar;
1394
1395   for (kar=keys; kar->keyblock; kar++)
1396     {
1397       KBNODE node = kar->keyblock;
1398       u32 kid[2];
1399
1400       keyid_from_pk(node->pkt->pkt.public_key, kid);
1401       printf ("%d:%08lX%08lX:K::%c::::\n",
1402               depth, (ulong)kid[0], (ulong)kid[1], '?');
1403
1404       for (; node; node = node->next)
1405         {
1406           if (node->pkt->pkttype == PKT_USER_ID)
1407             {
1408               int len = node->pkt->pkt.user_id->len;
1409
1410               if (len > 30)
1411                 len = 30;
1412               printf ("%d:%08lX%08lX:U:::%c:::",
1413                       depth, (ulong)kid[0], (ulong)kid[1],
1414                       (node->flag & 4)? 'f':
1415                       (node->flag & 2)? 'm':
1416                       (node->flag & 1)? 'q':'-');
1417               print_string (stdout,  node->pkt->pkt.user_id->name, len, ':');
1418               putchar (':');
1419               putchar ('\n');
1420             }
1421         }
1422     }
1423 }
1424
1425
1426 static void
1427 store_validation_status (int depth, KBNODE keyblock, KeyHashTable stored)
1428 {
1429   KBNODE node;
1430   int status;
1431   int any = 0;
1432
1433   for (node=keyblock; node; node = node->next)
1434     {
1435       if (node->pkt->pkttype == PKT_USER_ID)
1436         {
1437           PKT_user_id *uid = node->pkt->pkt.user_id;
1438           if (node->flag & 4)
1439             status = TRUST_FULLY;
1440           else if (node->flag & 2)
1441             status = TRUST_MARGINAL;
1442           else if (node->flag & 1)
1443             status = TRUST_UNDEFINED;
1444           else
1445             status = 0;
1446
1447           if (status)
1448             {
1449               update_validity (keyblock->pkt->pkt.public_key,
1450                                uid, depth, status);
1451
1452               mark_keyblock_seen(stored,keyblock);
1453
1454               any = 1;
1455             }
1456         }
1457     }
1458
1459   if (any)
1460     do_sync ();
1461 }
1462
1463 /*
1464  * check whether the signature sig is in the klist k
1465  */
1466 static struct key_item *
1467 is_in_klist (struct key_item *k, PKT_signature *sig)
1468 {
1469   for (; k; k = k->next)
1470     {
1471       if (k->kid[0] == sig->keyid[0] && k->kid[1] == sig->keyid[1])
1472         return k;
1473     }
1474   return NULL;
1475 }
1476
1477 /*
1478  * Mark the signature of the given UID which are used to certify it.
1479  * To do this, we first revmove all signatures which are not valid and
1480  * from the remain ones we look for the latest one.  If this is not a
1481  * certification revocation signature we mark the signature by setting
1482  * node flag bit 8.  Revocations are marked with flag 11, and sigs
1483  * from unavailable keys are marked with flag 12.  Note that flag bits
1484  * 9 and 10 are used for internal purposes.
1485  */
1486 static void
1487 mark_usable_uid_certs (KBNODE keyblock, KBNODE uidnode,
1488                        u32 *main_kid, struct key_item *klist,
1489                        u32 curtime, u32 *next_expire)
1490 {
1491   KBNODE node;
1492   PKT_signature *sig;
1493
1494   /* first check all signatures */
1495   for (node=uidnode->next; node; node = node->next)
1496     {
1497       int rc;
1498
1499       node->flag &= ~(1<<8 | 1<<9 | 1<<10 | 1<<11 | 1<<12);
1500       if (node->pkt->pkttype == PKT_USER_ID
1501           || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1502         break; /* ready */
1503       if (node->pkt->pkttype != PKT_SIGNATURE)
1504         continue;
1505       sig = node->pkt->pkt.signature;
1506       if (main_kid
1507           && sig->keyid[0] == main_kid[0] && sig->keyid[1] == main_kid[1])
1508         continue; /* ignore self-signatures if we pass in a main_kid */
1509       if (!IS_UID_SIG(sig) && !IS_UID_REV(sig))
1510         continue; /* we only look at these signature classes */
1511       if(sig->sig_class>=0x11 && sig->sig_class<=0x13 &&
1512          sig->sig_class-0x10<opt.min_cert_level)
1513         continue; /* treat anything under our min_cert_level as an
1514                      invalid signature */
1515       if (klist && !is_in_klist (klist, sig))
1516         continue;  /* no need to check it then */
1517       if ((rc=check_key_signature (keyblock, node, NULL)))
1518         {
1519           /* we ignore anything that won't verify, but tag the
1520              no_pubkey case */
1521           if(rc==G10ERR_NO_PUBKEY)
1522             node->flag |= 1<<12;
1523           continue;
1524         }
1525       node->flag |= 1<<9;
1526     }
1527   /* reset the remaining flags */
1528   for (; node; node = node->next)
1529       node->flag &= ~(1<<8 | 1<<9 | 1<<10 | 1<<11 | 1<<12);
1530
1531   /* kbnode flag usage: bit 9 is here set for signatures to consider,
1532    * bit 10 will be set by the loop to keep track of keyIDs already
1533    * processed, bit 8 will be set for the usable signatures, and bit
1534    * 11 will be set for usable revocations. */
1535
1536   /* for each cert figure out the latest valid one */
1537   for (node=uidnode->next; node; node = node->next)
1538     {
1539       KBNODE n, signode;
1540       u32 kid[2];
1541       u32 sigdate;
1542
1543       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1544         break;
1545       if ( !(node->flag & (1<<9)) )
1546         continue; /* not a node to look at */
1547       if ( (node->flag & (1<<10)) )
1548         continue; /* signature with a keyID already processed */
1549       node->flag |= (1<<10); /* mark this node as processed */
1550       sig = node->pkt->pkt.signature;
1551       signode = node;
1552       sigdate = sig->timestamp;
1553       kid[0] = sig->keyid[0]; kid[1] = sig->keyid[1];
1554
1555       /* Now find the latest and greatest signature */
1556       for (n=uidnode->next; n; n = n->next)
1557         {
1558           if (n->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1559             break;
1560           if ( !(n->flag & (1<<9)) )
1561             continue;
1562           if ( (n->flag & (1<<10)) )
1563             continue; /* shortcut already processed signatures */
1564           sig = n->pkt->pkt.signature;
1565           if (kid[0] != sig->keyid[0] || kid[1] != sig->keyid[1])
1566             continue;
1567           n->flag |= (1<<10); /* mark this node as processed */
1568
1569           /* If signode is nonrevocable and unexpired and n isn't,
1570              then take signode (skip).  It doesn't matter which is
1571              older: if signode was older then we don't want to take n
1572              as signode is nonrevocable.  If n was older then we're
1573              automatically fine. */
1574
1575           if(((IS_UID_SIG(signode->pkt->pkt.signature) &&
1576                !signode->pkt->pkt.signature->flags.revocable &&
1577                (signode->pkt->pkt.signature->expiredate==0 ||
1578                 signode->pkt->pkt.signature->expiredate>curtime))) &&
1579              (!(IS_UID_SIG(n->pkt->pkt.signature) &&
1580                 !n->pkt->pkt.signature->flags.revocable &&
1581                 (n->pkt->pkt.signature->expiredate==0 ||
1582                  n->pkt->pkt.signature->expiredate>curtime))))
1583             continue;
1584
1585           /* If n is nonrevocable and unexpired and signode isn't,
1586              then take n.  Again, it doesn't matter which is older: if
1587              n was older then we don't want to take signode as n is
1588              nonrevocable.  If signode was older then we're
1589              automatically fine. */
1590
1591           if((!(IS_UID_SIG(signode->pkt->pkt.signature) &&
1592                 !signode->pkt->pkt.signature->flags.revocable &&
1593                 (signode->pkt->pkt.signature->expiredate==0 ||
1594                  signode->pkt->pkt.signature->expiredate>curtime))) &&
1595              ((IS_UID_SIG(n->pkt->pkt.signature) &&
1596                !n->pkt->pkt.signature->flags.revocable &&
1597                (n->pkt->pkt.signature->expiredate==0 ||
1598                 n->pkt->pkt.signature->expiredate>curtime))))
1599             {
1600               signode = n;
1601               sigdate = sig->timestamp;
1602               continue;
1603             }
1604
1605           /* At this point, if it's newer, it goes in as the only
1606              remaining possibilities are signode and n are both either
1607              revocable or expired or both nonrevocable and unexpired.
1608              If the timestamps are equal take the later ordered
1609              packet, presuming that the key packets are hopefully in
1610              their original order. */
1611
1612           if (sig->timestamp >= sigdate)
1613             {
1614               signode = n;
1615               sigdate = sig->timestamp;
1616             }
1617         }
1618
1619       sig = signode->pkt->pkt.signature;
1620       if (IS_UID_SIG (sig))
1621         { /* this seems to be a usable one which is not revoked.
1622            * Just need to check whether there is an expiration time,
1623            * We do the expired certification after finding a suitable
1624            * certification, the assumption is that a signator does not
1625            * want that after the expiration of his certificate the
1626            * system falls back to an older certification which has a
1627            * different expiration time */
1628           const byte *p;
1629           u32 expire;
1630
1631           p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_SIG_EXPIRE, NULL );
1632           expire = p? sig->timestamp + buf32_to_u32 (p) : 0;
1633
1634           if (expire==0 || expire > curtime )
1635             {
1636               signode->flag |= (1<<8); /* yeah, found a good cert */
1637               if (next_expire && expire && expire < *next_expire)
1638                 *next_expire = expire;
1639             }
1640         }
1641       else
1642         signode->flag |= (1<<11);
1643     }
1644 }
1645
1646 static int
1647 clean_sigs_from_uid(KBNODE keyblock,KBNODE uidnode,int noisy,int self_only)
1648 {
1649   int deleted=0;
1650   KBNODE node;
1651   u32 keyid[2];
1652
1653   assert(keyblock->pkt->pkttype==PKT_PUBLIC_KEY);
1654
1655   keyid_from_pk(keyblock->pkt->pkt.public_key,keyid);
1656
1657   /* Passing in a 0 for current time here means that we'll never weed
1658      out an expired sig.  This is correct behavior since we want to
1659      keep the most recent expired sig in a series. */
1660   mark_usable_uid_certs(keyblock,uidnode,NULL,NULL,0,NULL);
1661
1662   /* What we want to do here is remove signatures that are not
1663      considered as part of the trust calculations.  Thus, all invalid
1664      signatures are out, as are any signatures that aren't the last of
1665      a series of uid sigs or revocations It breaks down like this:
1666      coming out of mark_usable_uid_certs, if a sig is unflagged, it is
1667      not even a candidate.  If a sig has flag 9 or 10, that means it
1668      was selected as a candidate and vetted.  If a sig has flag 8 it
1669      is a usable signature.  If a sig has flag 11 it is a usable
1670      revocation.  If a sig has flag 12 it was issued by an unavailable
1671      key.  "Usable" here means the most recent valid
1672      signature/revocation in a series from a particular signer.
1673
1674      Delete everything that isn't a usable uid sig (which might be
1675      expired), a usable revocation, or a sig from an unavailable
1676      key. */
1677
1678   for(node=uidnode->next;
1679       node && node->pkt->pkttype==PKT_SIGNATURE;
1680       node=node->next)
1681     {
1682       int keep=self_only?(node->pkt->pkt.signature->keyid[0]==keyid[0]
1683                           && node->pkt->pkt.signature->keyid[1]==keyid[1]):1;
1684
1685       /* Keep usable uid sigs ... */
1686       if((node->flag & (1<<8)) && keep)
1687         continue;
1688
1689       /* ... and usable revocations... */
1690       if((node->flag & (1<<11)) && keep)
1691         continue;
1692
1693       /* ... and sigs from unavailable keys. */
1694       /* disabled for now since more people seem to want sigs from
1695          unavailable keys removed altogether.  */
1696       /*
1697         if(node->flag & (1<<12))
1698         continue;
1699       */
1700
1701       /* Everything else we delete */
1702
1703       /* At this point, if 12 is set, the signing key was unavailable.
1704          If 9 or 10 is set, it's superseded.  Otherwise, it's
1705          invalid. */
1706
1707       if(noisy)
1708         log_info("removing signature from key %s on user ID \"%s\": %s\n",
1709                  keystr(node->pkt->pkt.signature->keyid),
1710                  uidnode->pkt->pkt.user_id->name,
1711                  node->flag&(1<<12)?"key unavailable":
1712                  node->flag&(1<<9)?"signature superseded":"invalid signature");
1713
1714       delete_kbnode(node);
1715       deleted++;
1716     }
1717
1718   return deleted;
1719 }
1720
1721 /* This is substantially easier than clean_sigs_from_uid since we just
1722    have to establish if the uid has a valid self-sig, is not revoked,
1723    and is not expired.  Note that this does not take into account
1724    whether the uid has a trust path to it - just whether the keyholder
1725    themselves has certified the uid.  Returns true if the uid was
1726    compacted.  To "compact" a user ID, we simply remove ALL signatures
1727    except the self-sig that caused the user ID to be remove-worthy.
1728    We don't actually remove the user ID packet itself since it might
1729    be ressurected in a later merge.  Note that this function requires
1730    that the caller has already done a merge_keys_and_selfsig().
1731
1732    TODO: change the import code to allow importing a uid with only a
1733    revocation if the uid already exists on the keyring. */
1734
1735 static int
1736 clean_uid_from_key(KBNODE keyblock,KBNODE uidnode,int noisy)
1737 {
1738   KBNODE node;
1739   PKT_user_id *uid=uidnode->pkt->pkt.user_id;
1740   int deleted=0;
1741
1742   assert(keyblock->pkt->pkttype==PKT_PUBLIC_KEY);
1743   assert(uidnode->pkt->pkttype==PKT_USER_ID);
1744
1745   /* Skip valid user IDs, compacted user IDs, and non-self-signed user
1746      IDs if --allow-non-selfsigned-uid is set. */
1747   if(uid->created || uid->flags.compacted
1748      || (!uid->is_expired && !uid->is_revoked
1749          && opt.allow_non_selfsigned_uid))
1750     return 0;
1751
1752   for(node=uidnode->next;
1753       node && node->pkt->pkttype==PKT_SIGNATURE;
1754       node=node->next)
1755     if(!node->pkt->pkt.signature->flags.chosen_selfsig)
1756       {
1757         delete_kbnode(node);
1758         deleted=1;
1759         uidnode->pkt->pkt.user_id->flags.compacted=1;
1760       }
1761
1762   if(noisy)
1763     {
1764       const char *reason;
1765       char *user=utf8_to_native(uid->name,uid->len,0);
1766
1767       if(uid->is_revoked)
1768         reason=_("revoked");
1769       else if(uid->is_expired)
1770         reason=_("expired");
1771       else
1772         reason=_("invalid");
1773
1774       log_info("compacting user ID \"%s\" on key %s: %s\n",
1775                user,keystr_from_pk(keyblock->pkt->pkt.public_key),
1776                reason);
1777
1778       xfree(user);
1779     }
1780
1781   return deleted;
1782 }
1783
1784 /* Needs to be called after a merge_keys_and_selfsig() */
1785 void
1786 clean_one_uid(KBNODE keyblock,KBNODE uidnode,int noisy,int self_only,
1787               int *uids_cleaned,int *sigs_cleaned)
1788 {
1789   int dummy;
1790
1791   assert(keyblock->pkt->pkttype==PKT_PUBLIC_KEY);
1792   assert(uidnode->pkt->pkttype==PKT_USER_ID);
1793
1794   if(!uids_cleaned)
1795     uids_cleaned=&dummy;
1796
1797   if(!sigs_cleaned)
1798     sigs_cleaned=&dummy;
1799
1800   /* Do clean_uid_from_key first since if it fires off, we don't
1801      have to bother with the other */
1802   *uids_cleaned+=clean_uid_from_key(keyblock,uidnode,noisy);
1803   if(!uidnode->pkt->pkt.user_id->flags.compacted)
1804     *sigs_cleaned+=clean_sigs_from_uid(keyblock,uidnode,noisy,self_only);
1805 }
1806
1807 void
1808 clean_key(KBNODE keyblock,int noisy,int self_only,
1809           int *uids_cleaned,int *sigs_cleaned)
1810 {
1811   KBNODE uidnode;
1812
1813   merge_keys_and_selfsig(keyblock);
1814
1815   for(uidnode=keyblock->next;
1816       uidnode && uidnode->pkt->pkttype!=PKT_PUBLIC_SUBKEY;
1817       uidnode=uidnode->next)
1818     if(uidnode->pkt->pkttype==PKT_USER_ID)
1819       clean_one_uid(keyblock,uidnode,noisy,self_only,
1820                     uids_cleaned,sigs_cleaned);
1821 }
1822
1823 /* Returns a sanitized copy of the regexp (which might be "", but not
1824    NULL). */
1825 #ifndef DISABLE_REGEX
1826 static char *
1827 sanitize_regexp(const char *old)
1828 {
1829   size_t start=0,len=strlen(old),idx=0;
1830   int escaped=0,standard_bracket=0;
1831   char *new=xmalloc((len*2)+1); /* enough to \-escape everything if we
1832                                    have to */
1833
1834   /* There are basically two commonly-used regexps here.  GPG and most
1835      versions of PGP use "<[^>]+[@.]example\.com>$" and PGP (9)
1836      command line uses "example.com" (i.e. whatever the user specfies,
1837      and we can't expect users know to use "\." instead of ".").  So
1838      here are the rules: we're allowed to start with "<[^>]+[@.]" and
1839      end with ">$" or start and end with nothing.  In between, the
1840      only legal regex character is ".", and everything else gets
1841      escaped.  Part of the gotcha here is that some regex packages
1842      allow more than RFC-4880 requires.  For example, 4880 has no "{}"
1843      operator, but GNU regex does.  Commenting removes these operators
1844      from consideration.  A possible future enhancement is to use
1845      commenting to effectively back off a given regex to the Henry
1846      Spencer syntax in 4880. -dshaw */
1847
1848   /* Are we bracketed between "<[^>]+[@.]" and ">$" ? */
1849   if(len>=12 && strncmp(old,"<[^>]+[@.]",10)==0
1850      && old[len-2]=='>' && old[len-1]=='$')
1851     {
1852       strcpy(new,"<[^>]+[@.]");
1853       idx=strlen(new);
1854       standard_bracket=1;
1855       start+=10;
1856       len-=2;
1857     }
1858
1859   /* Walk the remaining characters and ensure that everything that is
1860      left is not an operational regex character. */
1861   for(;start<len;start++)
1862     {
1863       if(!escaped && old[start]=='\\')
1864         escaped=1;
1865       else if(!escaped && old[start]!='.')
1866         new[idx++]='\\';
1867       else
1868         escaped=0;
1869
1870       new[idx++]=old[start];
1871     }
1872
1873   new[idx]='\0';
1874
1875   /* Note that the (sub)string we look at might end with a bare "\".
1876      If it does, leave it that way.  If the regexp actually ended with
1877      ">$", then it was escaping the ">" and is fine.  If the regexp
1878      actually ended with the bare "\", then it's an illegal regexp and
1879      regcomp should kick it out. */
1880
1881   if(standard_bracket)
1882     strcat(new,">$");
1883
1884   return new;
1885 }
1886 #endif /*!DISABLE_REGEX*/
1887
1888 /* Used by validate_one_keyblock to confirm a regexp within a trust
1889    signature.  Returns 1 for match, and 0 for no match or regex
1890    error. */
1891 static int
1892 check_regexp(const char *expr,const char *string)
1893 {
1894 #ifdef DISABLE_REGEX
1895   /* When DISABLE_REGEX is defined, assume all regexps do not
1896      match. */
1897   return 0;
1898 #else
1899   int ret;
1900   char *regexp;
1901
1902   regexp=sanitize_regexp(expr);
1903
1904 #ifdef __riscos__
1905   ret=riscos_check_regexp(expr, string, DBG_TRUST);
1906 #else
1907   {
1908     regex_t pat;
1909
1910     ret=regcomp(&pat,regexp,REG_ICASE|REG_NOSUB|REG_EXTENDED);
1911     if(ret==0)
1912       {
1913         ret=regexec(&pat,string,0,NULL,0);
1914         regfree(&pat);
1915         ret=(ret==0);
1916       }
1917   }
1918 #endif
1919
1920   if(DBG_TRUST)
1921     log_debug("regexp `%s' (`%s') on `%s': %s\n",
1922               regexp,expr,string,ret==0?"YES":"NO");
1923
1924   xfree(regexp);
1925
1926   return ret;
1927 #endif
1928 }
1929
1930 /*
1931  * Return true if the key is signed by one of the keys in the given
1932  * key ID list.  User IDs with a valid signature are marked by node
1933  * flags as follows:
1934  *  flag bit 0: There is at least one signature
1935  *           1: There is marginal confidence that this is a legitimate uid
1936  *           2: There is full confidence that this is a legitimate uid.
1937  *           8: Used for internal purposes.
1938  *           9: Ditto (in mark_usable_uid_certs())
1939  *          10: Ditto (ditto)
1940  * This function assumes that all kbnode flags are cleared on entry.
1941  */
1942 static int
1943 validate_one_keyblock (KBNODE kb, struct key_item *klist,
1944                        u32 curtime, u32 *next_expire)
1945 {
1946   struct key_item *kr;
1947   KBNODE node, uidnode=NULL;
1948   PKT_user_id *uid=NULL;
1949   PKT_public_key *pk = kb->pkt->pkt.public_key;
1950   u32 main_kid[2];
1951   int issigned=0, any_signed = 0;
1952
1953   keyid_from_pk(pk, main_kid);
1954   for (node=kb; node; node = node->next)
1955     {
1956       /* A bit of discussion here: is it better for the web of trust
1957          to be built among only self-signed uids?  On the one hand, a
1958          self-signed uid is a statement that the key owner definitely
1959          intended that uid to be there, but on the other hand, a
1960          signed (but not self-signed) uid does carry trust, of a sort,
1961          even if it is a statement being made by people other than the
1962          key owner "through" the uids on the key owner's key.  I'm
1963          going with the latter.  However, if the user ID was
1964          explicitly revoked, or passively allowed to expire, that
1965          should stop validity through the user ID until it is
1966          resigned.  -dshaw */
1967
1968       if (node->pkt->pkttype == PKT_USER_ID
1969           && !node->pkt->pkt.user_id->is_revoked
1970           && !node->pkt->pkt.user_id->is_expired)
1971         {
1972           if (uidnode && issigned)
1973             {
1974               if (uid->help_full_count >= opt.completes_needed
1975                   || uid->help_marginal_count >= opt.marginals_needed )
1976                 uidnode->flag |= 4;
1977               else if (uid->help_full_count || uid->help_marginal_count)
1978                 uidnode->flag |= 2;
1979               uidnode->flag |= 1;
1980               any_signed = 1;
1981             }
1982           uidnode = node;
1983           uid=uidnode->pkt->pkt.user_id;
1984
1985           /* If the selfsig is going to expire... */
1986           if(uid->expiredate && uid->expiredate<*next_expire)
1987             *next_expire = uid->expiredate;
1988
1989           issigned = 0;
1990           get_validity_counts(pk,uid);
1991           mark_usable_uid_certs (kb, uidnode, main_kid, klist,
1992                                  curtime, next_expire);
1993         }
1994       else if (node->pkt->pkttype == PKT_SIGNATURE
1995                && (node->flag & (1<<8)) && uid)
1996         {
1997           /* Note that we are only seeing unrevoked sigs here */
1998           PKT_signature *sig = node->pkt->pkt.signature;
1999
2000           kr = is_in_klist (klist, sig);
2001           /* If the trust_regexp does not match, it's as if the sig
2002              did not exist.  This is safe for non-trust sigs as well
2003              since we don't accept a regexp on the sig unless it's a
2004              trust sig. */
2005           if (kr && (!kr->trust_regexp
2006                      || opt.trust_model != TM_PGP
2007                      || (uidnode
2008                          && check_regexp(kr->trust_regexp,
2009                                          uidnode->pkt->pkt.user_id->name))))
2010             {
2011               /* Are we part of a trust sig chain?  We always favor
2012                  the latest trust sig, rather than the greater or
2013                  lesser trust sig or value.  I could make a decent
2014                  argument for any of these cases, but this seems to be
2015                  what PGP does, and I'd like to be compatible. -dms */
2016               if (opt.trust_model == TM_PGP
2017                   && sig->trust_depth
2018                   && pk->trust_timestamp <= sig->timestamp)
2019                 {
2020                   unsigned char depth;
2021
2022                   /* If the depth on the signature is less than the
2023                      chain currently has, then use the signature depth
2024                      so we don't increase the depth beyond what the
2025                      signer wanted.  If the depth on the signature is
2026                      more than the chain currently has, then use the
2027                      chain depth so we use as much of the signature
2028                      depth as the chain will permit.  An ultimately
2029                      trusted signature can restart the depth to
2030                      whatever level it likes. */
2031
2032                   if (sig->trust_depth < kr->trust_depth
2033                       || kr->ownertrust == TRUST_ULTIMATE)
2034                     depth = sig->trust_depth;
2035                   else
2036                     depth = kr->trust_depth;
2037
2038                   if (depth)
2039                     {
2040                       if(DBG_TRUST)
2041                         log_debug ("trust sig on %s, sig depth is %d,"
2042                                    " kr depth is %d\n",
2043                                    uidnode->pkt->pkt.user_id->name,
2044                                    sig->trust_depth,
2045                                    kr->trust_depth);
2046
2047                       /* If we got here, we know that:
2048
2049                          this is a trust sig.
2050
2051                          it's a newer trust sig than any previous trust
2052                          sig on this key (not uid).
2053
2054                          it is legal in that it was either generated by an
2055                          ultimate key, or a key that was part of a trust
2056                          chain, and the depth does not violate the
2057                          original trust sig.
2058
2059                          if there is a regexp attached, it matched
2060                          successfully.
2061                       */
2062
2063                       if (DBG_TRUST)
2064                         log_debug ("replacing trust value %d with %d and "
2065                                    "depth %d with %d\n",
2066                                    pk->trust_value,sig->trust_value,
2067                                    pk->trust_depth,depth);
2068
2069                       pk->trust_value = sig->trust_value;
2070                       pk->trust_depth = depth-1;
2071
2072                       /* If the trust sig contains a regexp, record it
2073                          on the pk for the next round. */
2074                       if (sig->trust_regexp)
2075                         pk->trust_regexp = sig->trust_regexp;
2076                     }
2077                 }
2078
2079               if (kr->ownertrust == TRUST_ULTIMATE)
2080                 uid->help_full_count = opt.completes_needed;
2081               else if (kr->ownertrust == TRUST_FULLY)
2082                 uid->help_full_count++;
2083               else if (kr->ownertrust == TRUST_MARGINAL)
2084                 uid->help_marginal_count++;
2085               issigned = 1;
2086             }
2087         }
2088     }
2089
2090   if (uidnode && issigned)
2091     {
2092       if (uid->help_full_count >= opt.completes_needed
2093           || uid->help_marginal_count >= opt.marginals_needed )
2094         uidnode->flag |= 4;
2095       else if (uid->help_full_count || uid->help_marginal_count)
2096         uidnode->flag |= 2;
2097       uidnode->flag |= 1;
2098       any_signed = 1;
2099     }
2100
2101   return any_signed;
2102 }
2103
2104
2105 static int
2106 search_skipfnc (void *opaque, u32 *kid, PKT_user_id *dummy)
2107 {
2108   (void)dummy;
2109   return test_key_hash_table ((KeyHashTable)opaque, kid);
2110 }
2111
2112
2113 /*
2114  * Scan all keys and return a key_array of all suitable keys from
2115  * kllist.  The caller has to pass keydb handle so that we don't use
2116  * to create our own.  Returns either a key_array or NULL in case of
2117  * an error.  No results found are indicated by an empty array.
2118  * Caller hast to release the returned array.
2119  */
2120 static struct key_array *
2121 validate_key_list (KEYDB_HANDLE hd, KeyHashTable full_trust,
2122                    struct key_item *klist, u32 curtime, u32 *next_expire)
2123 {
2124   KBNODE keyblock = NULL;
2125   struct key_array *keys = NULL;
2126   size_t nkeys, maxkeys;
2127   int rc;
2128   KEYDB_SEARCH_DESC desc;
2129
2130   maxkeys = 1000;
2131   keys = xmalloc ((maxkeys+1) * sizeof *keys);
2132   nkeys = 0;
2133
2134   rc = keydb_search_reset (hd);
2135   if (rc)
2136     {
2137       log_error ("keydb_search_reset failed: %s\n", g10_errstr(rc));
2138       xfree (keys);
2139       return NULL;
2140     }
2141
2142   memset (&desc, 0, sizeof desc);
2143   desc.mode = KEYDB_SEARCH_MODE_FIRST;
2144   desc.skipfnc = search_skipfnc;
2145   desc.skipfncvalue = full_trust;
2146   rc = keydb_search (hd, &desc, 1);
2147   if (rc == -1)
2148     {
2149       keys[nkeys].keyblock = NULL;
2150       return keys;
2151     }
2152   if (rc)
2153     {
2154       log_error ("keydb_search_first failed: %s\n", g10_errstr(rc));
2155       xfree (keys);
2156       return NULL;
2157     }
2158
2159   desc.mode = KEYDB_SEARCH_MODE_NEXT; /* change mode */
2160   do
2161     {
2162       PKT_public_key *pk;
2163
2164       rc = keydb_get_keyblock (hd, &keyblock);
2165       if (rc)
2166         {
2167           log_error ("keydb_get_keyblock failed: %s\n", g10_errstr(rc));
2168           xfree (keys);
2169           return NULL;
2170         }
2171
2172       if ( keyblock->pkt->pkttype != PKT_PUBLIC_KEY)
2173         {
2174           log_debug ("ooops: invalid pkttype %d encountered\n",
2175                      keyblock->pkt->pkttype);
2176           dump_kbnode (keyblock);
2177           release_kbnode(keyblock);
2178           continue;
2179         }
2180
2181       /* prepare the keyblock for further processing */
2182       merge_keys_and_selfsig (keyblock);
2183       clear_kbnode_flags (keyblock);
2184       pk = keyblock->pkt->pkt.public_key;
2185       if (pk->has_expired || pk->is_revoked)
2186         {
2187           /* it does not make sense to look further at those keys */
2188           mark_keyblock_seen (full_trust, keyblock);
2189         }
2190       else if (validate_one_keyblock (keyblock, klist, curtime, next_expire))
2191         {
2192           KBNODE node;
2193
2194           if (pk->expiredate && pk->expiredate >= curtime
2195               && pk->expiredate < *next_expire)
2196             *next_expire = pk->expiredate;
2197
2198           if (nkeys == maxkeys) {
2199             maxkeys += 1000;
2200             keys = xrealloc (keys, (maxkeys+1) * sizeof *keys);
2201           }
2202           keys[nkeys++].keyblock = keyblock;
2203
2204           /* Optimization - if all uids are fully trusted, then we
2205              never need to consider this key as a candidate again. */
2206
2207           for (node=keyblock; node; node = node->next)
2208             if (node->pkt->pkttype == PKT_USER_ID && !(node->flag & 4))
2209               break;
2210
2211           if(node==NULL)
2212             mark_keyblock_seen (full_trust, keyblock);
2213
2214           keyblock = NULL;
2215         }
2216
2217       release_kbnode (keyblock);
2218       keyblock = NULL;
2219     }
2220   while ( !(rc = keydb_search (hd, &desc, 1)) );
2221   if (rc && rc != -1)
2222     {
2223       log_error ("keydb_search_next failed: %s\n", g10_errstr(rc));
2224       xfree (keys);
2225       return NULL;
2226     }
2227
2228   keys[nkeys].keyblock = NULL;
2229   return keys;
2230 }
2231
2232 /* Caller must sync */
2233 static void
2234 reset_trust_records(void)
2235 {
2236   TRUSTREC rec;
2237   ulong recnum;
2238   int count = 0, nreset = 0;
2239
2240   for (recnum=1; !tdbio_read_record (recnum, &rec, 0); recnum++ )
2241     {
2242       if(rec.rectype==RECTYPE_TRUST)
2243         {
2244           count++;
2245           if(rec.r.trust.min_ownertrust)
2246             {
2247               rec.r.trust.min_ownertrust=0;
2248               write_record(&rec);
2249             }
2250
2251         }
2252       else if(rec.rectype==RECTYPE_VALID
2253               && ((rec.r.valid.validity&TRUST_MASK)
2254                   || rec.r.valid.marginal_count
2255                   || rec.r.valid.full_count))
2256         {
2257           rec.r.valid.validity &= ~TRUST_MASK;
2258           rec.r.valid.marginal_count=rec.r.valid.full_count=0;
2259           nreset++;
2260           write_record(&rec);
2261         }
2262
2263     }
2264
2265   if (opt.verbose)
2266     log_info (_("%d keys processed (%d validity counts cleared)\n"),
2267               count, nreset);
2268 }
2269
2270 /*
2271  * Run the key validation procedure.
2272  *
2273  * This works this way:
2274  * Step 1: Find all ultimately trusted keys (UTK).
2275  *         mark them all as seen and put them into klist.
2276  * Step 2: loop max_cert_times
2277  * Step 3:   if OWNERTRUST of any key in klist is undefined
2278  *             ask user to assign ownertrust
2279  * Step 4:   Loop over all keys in the keyDB which are not marked seen
2280  * Step 5:     if key is revoked or expired
2281  *                mark key as seen
2282  *                continue loop at Step 4
2283  * Step 6:     For each user ID of that key signed by a key in klist
2284  *                Calculate validity by counting trusted signatures.
2285  *                Set validity of user ID
2286  * Step 7:     If any signed user ID was found
2287  *                mark key as seen
2288  *             End Loop
2289  * Step 8:   Build a new klist from all fully trusted keys from step 6
2290  *           End Loop
2291  *         Ready
2292  *
2293  */
2294 static int
2295 validate_keys (int interactive)
2296 {
2297   int rc = 0;
2298   int quit=0;
2299   struct key_item *klist = NULL;
2300   struct key_item *k;
2301   struct key_array *keys = NULL;
2302   struct key_array *kar;
2303   KEYDB_HANDLE kdb = NULL;
2304   KBNODE node;
2305   int depth;
2306   int ot_unknown, ot_undefined, ot_never, ot_marginal, ot_full, ot_ultimate;
2307   KeyHashTable stored,used,full_trust;
2308   u32 start_time, next_expire;
2309
2310   /* Make sure we have all sigs cached.  TODO: This is going to
2311      require some architectual re-thinking, as it is agonizingly slow.
2312      Perhaps combine this with reset_trust_records(), or only check
2313      the caches on keys that are actually involved in the web of
2314      trust. */
2315   keydb_rebuild_caches(0);
2316
2317   start_time = make_timestamp ();
2318   next_expire = 0xffffffff; /* set next expire to the year 2106 */
2319   stored = new_key_hash_table ();
2320   used = new_key_hash_table ();
2321   full_trust = new_key_hash_table ();
2322
2323   kdb = keydb_new (0);
2324   reset_trust_records();
2325
2326   /* Fixme: Instead of always building a UTK list, we could just build it
2327    * here when needed */
2328   if (!utk_list)
2329     {
2330       if (!opt.quiet)
2331         log_info (_("no ultimately trusted keys found\n"));
2332       goto leave;
2333     }
2334
2335   /* mark all UTKs as used and fully_trusted and set validity to
2336      ultimate */
2337   for (k=utk_list; k; k = k->next)
2338     {
2339       KBNODE keyblock;
2340       PKT_public_key *pk;
2341
2342       keyblock = get_pubkeyblock (k->kid);
2343       if (!keyblock)
2344         {
2345           log_error (_("public key of ultimately"
2346                        " trusted key %s not found\n"), keystr(k->kid));
2347           continue;
2348         }
2349       mark_keyblock_seen (used, keyblock);
2350       mark_keyblock_seen (stored, keyblock);
2351       mark_keyblock_seen (full_trust, keyblock);
2352       pk = keyblock->pkt->pkt.public_key;
2353       for (node=keyblock; node; node = node->next)
2354         {
2355           if (node->pkt->pkttype == PKT_USER_ID)
2356             update_validity (pk, node->pkt->pkt.user_id, 0, TRUST_ULTIMATE);
2357         }
2358       if ( pk->expiredate && pk->expiredate >= start_time
2359            && pk->expiredate < next_expire)
2360         next_expire = pk->expiredate;
2361
2362       release_kbnode (keyblock);
2363       do_sync ();
2364     }
2365
2366   klist = utk_list;
2367
2368   log_info(_("%d marginal(s) needed, %d complete(s) needed, %s trust model\n"),
2369            opt.marginals_needed,opt.completes_needed,trust_model_string());
2370
2371   for (depth=0; depth < opt.max_cert_depth; depth++)
2372     {
2373       int valids=0,key_count;
2374       /* See whether we should assign ownertrust values to the keys in
2375          klist.  */
2376       ot_unknown = ot_undefined = ot_never = 0;
2377       ot_marginal = ot_full = ot_ultimate = 0;
2378       for (k=klist; k; k = k->next)
2379         {
2380           int min=0;
2381
2382           /* 120 and 60 are as per RFC2440 */
2383           if(k->trust_value>=120)
2384             min=TRUST_FULLY;
2385           else if(k->trust_value>=60)
2386             min=TRUST_MARGINAL;
2387
2388           if(min!=k->min_ownertrust)
2389             update_min_ownertrust(k->kid,min);
2390
2391           if (interactive && k->ownertrust == TRUST_UNKNOWN)
2392             {
2393               k->ownertrust = ask_ownertrust (k->kid,min);
2394
2395               if (k->ownertrust == -1)
2396                 {
2397                   quit=1;
2398                   goto leave;
2399                 }
2400             }
2401
2402           /* This can happen during transition from an old trustdb
2403              before trust sigs.  It can also happen if a user uses two
2404              different versions of GnuPG or changes the --trust-model
2405              setting. */
2406           if(k->ownertrust<min)
2407             {
2408               if(DBG_TRUST)
2409                 log_debug("key %08lX%08lX:"
2410                           " overriding ownertrust `%s' with `%s'\n",
2411                           (ulong)k->kid[0],(ulong)k->kid[1],
2412                           trust_value_to_string(k->ownertrust),
2413                           trust_value_to_string(min));
2414
2415               k->ownertrust=min;
2416             }
2417
2418           if (k->ownertrust == TRUST_UNKNOWN)
2419             ot_unknown++;
2420           else if (k->ownertrust == TRUST_UNDEFINED)
2421             ot_undefined++;
2422           else if (k->ownertrust == TRUST_NEVER)
2423             ot_never++;
2424           else if (k->ownertrust == TRUST_MARGINAL)
2425             ot_marginal++;
2426           else if (k->ownertrust == TRUST_FULLY)
2427             ot_full++;
2428           else if (k->ownertrust == TRUST_ULTIMATE)
2429             ot_ultimate++;
2430
2431           valids++;
2432         }
2433
2434       /* Find all keys which are signed by a key in kdlist */
2435       keys = validate_key_list (kdb, full_trust, klist,
2436                                 start_time, &next_expire);
2437       if (!keys)
2438         {
2439           log_error ("validate_key_list failed\n");
2440           rc = G10ERR_GENERAL;
2441           goto leave;
2442         }
2443
2444       for (key_count=0, kar=keys; kar->keyblock; kar++, key_count++)
2445         ;
2446
2447       /* Store the calculated valididation status somewhere */
2448       if (opt.verbose > 1 && DBG_TRUST)
2449         dump_key_array (depth, keys);
2450
2451       for (kar=keys; kar->keyblock; kar++)
2452           store_validation_status (depth, kar->keyblock, stored);
2453
2454       log_info (_("depth: %d  valid: %3d  signed: %3d"
2455                   "  trust: %d-, %dq, %dn, %dm, %df, %du\n"),
2456                 depth, valids, key_count, ot_unknown, ot_undefined,
2457                 ot_never, ot_marginal, ot_full, ot_ultimate );
2458
2459       /* Build a new kdlist from all fully valid keys in KEYS */
2460       if (klist != utk_list)
2461         release_key_items (klist);
2462       klist = NULL;
2463       for (kar=keys; kar->keyblock; kar++)
2464         {
2465           for (node=kar->keyblock; node; node = node->next)
2466             {
2467               if (node->pkt->pkttype == PKT_USER_ID && (node->flag & 4))
2468                 {
2469                   u32 kid[2];
2470
2471                   /* have we used this key already? */
2472                   keyid_from_pk (kar->keyblock->pkt->pkt.public_key, kid);
2473                   if(test_key_hash_table(used,kid)==0)
2474                     {
2475                       /* Normally we add both the primary and subkey
2476                          ids to the hash via mark_keyblock_seen, but
2477                          since we aren't using this hash as a skipfnc,
2478                          that doesn't matter here. */
2479                       add_key_hash_table (used,kid);
2480                       k = new_key_item ();
2481                       k->kid[0]=kid[0];
2482                       k->kid[1]=kid[1];
2483                       k->ownertrust =
2484                         (get_ownertrust (kar->keyblock->pkt->pkt.public_key)
2485                          & TRUST_MASK);
2486                       k->min_ownertrust =
2487                         get_min_ownertrust(kar->keyblock->pkt->pkt.public_key);
2488                       k->trust_depth=
2489                         kar->keyblock->pkt->pkt.public_key->trust_depth;
2490                       k->trust_value=
2491                         kar->keyblock->pkt->pkt.public_key->trust_value;
2492                       if(kar->keyblock->pkt->pkt.public_key->trust_regexp)
2493                         k->trust_regexp=
2494                           xstrdup(kar->keyblock->pkt->
2495                                    pkt.public_key->trust_regexp);
2496                       k->next = klist;
2497                       klist = k;
2498                       break;
2499                     }
2500                 }
2501             }
2502         }
2503       release_key_array (keys);
2504       keys = NULL;
2505       if (!klist)
2506         break; /* no need to dive in deeper */
2507     }
2508
2509  leave:
2510   keydb_release (kdb);
2511   release_key_array (keys);
2512   release_key_items (klist);
2513   release_key_hash_table (full_trust);
2514   release_key_hash_table (used);
2515   release_key_hash_table (stored);
2516   if (!rc && !quit) /* mark trustDB as checked */
2517     {
2518       if (next_expire == 0xffffffff || next_expire < start_time )
2519         tdbio_write_nextcheck (0);
2520       else
2521         {
2522           tdbio_write_nextcheck (next_expire);
2523           log_info (_("next trustdb check due at %s\n"),
2524                     strtimestamp (next_expire));
2525         }
2526
2527       if(tdbio_update_version_record()!=0)
2528         {
2529           log_error(_("unable to update trustdb version record: "
2530                       "write failed: %s\n"), g10_errstr(rc));
2531           tdbio_invalid();
2532         }
2533
2534       do_sync ();
2535       pending_check_trustdb = 0;
2536     }
2537
2538   return rc;
2539 }