g10: Fix regexp sanitization.
[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 /* Operator charactors except '.' and backslash.
1827    See regex(7) on BSD.  */
1828 #define REGEXP_OPERATOR_CHARS "^[$()|*+?{"
1829
1830 static char *
1831 sanitize_regexp(const char *old)
1832 {
1833   size_t start=0,len=strlen(old),idx=0;
1834   int escaped=0,standard_bracket=0;
1835   char *new=xmalloc((len*2)+1); /* enough to \-escape everything if we
1836                                    have to */
1837
1838   /* There are basically two commonly-used regexps here.  GPG and most
1839      versions of PGP use "<[^>]+[@.]example\.com>$" and PGP (9)
1840      command line uses "example.com" (i.e. whatever the user specfies,
1841      and we can't expect users know to use "\." instead of ".").  So
1842      here are the rules: we're allowed to start with "<[^>]+[@.]" and
1843      end with ">$" or start and end with nothing.  In between, the
1844      only legal regex character is ".", and everything else gets
1845      escaped.  Part of the gotcha here is that some regex packages
1846      allow more than RFC-4880 requires.  For example, 4880 has no "{}"
1847      operator, but GNU regex does.  Commenting removes these operators
1848      from consideration.  A possible future enhancement is to use
1849      commenting to effectively back off a given regex to the Henry
1850      Spencer syntax in 4880. -dshaw */
1851
1852   /* Are we bracketed between "<[^>]+[@.]" and ">$" ? */
1853   if(len>=12 && strncmp(old,"<[^>]+[@.]",10)==0
1854      && old[len-2]=='>' && old[len-1]=='$')
1855     {
1856       strcpy(new,"<[^>]+[@.]");
1857       idx=strlen(new);
1858       standard_bracket=1;
1859       start+=10;
1860       len-=2;
1861     }
1862
1863   /* Walk the remaining characters and ensure that everything that is
1864      left is not an operational regex character. */
1865   for(;start<len;start++)
1866     {
1867       if(!escaped && old[start]=='\\')
1868         escaped=1;
1869       else if (!escaped && strchr (REGEXP_OPERATOR_CHARS, old[start]))
1870         new[idx++]='\\';
1871       else
1872         escaped=0;
1873
1874       new[idx++]=old[start];
1875     }
1876
1877   new[idx]='\0';
1878
1879   /* Note that the (sub)string we look at might end with a bare "\".
1880      If it does, leave it that way.  If the regexp actually ended with
1881      ">$", then it was escaping the ">" and is fine.  If the regexp
1882      actually ended with the bare "\", then it's an illegal regexp and
1883      regcomp should kick it out. */
1884
1885   if(standard_bracket)
1886     strcat(new,">$");
1887
1888   return new;
1889 }
1890 #endif /*!DISABLE_REGEX*/
1891
1892 /* Used by validate_one_keyblock to confirm a regexp within a trust
1893    signature.  Returns 1 for match, and 0 for no match or regex
1894    error. */
1895 static int
1896 check_regexp(const char *expr,const char *string)
1897 {
1898 #ifdef DISABLE_REGEX
1899   /* When DISABLE_REGEX is defined, assume all regexps do not
1900      match. */
1901   return 0;
1902 #else
1903   int ret;
1904   char *regexp;
1905
1906   regexp=sanitize_regexp(expr);
1907
1908 #ifdef __riscos__
1909   ret=riscos_check_regexp(expr, string, DBG_TRUST);
1910 #else
1911   {
1912     regex_t pat;
1913
1914     ret=regcomp(&pat,regexp,REG_ICASE|REG_NOSUB|REG_EXTENDED);
1915     if(ret==0)
1916       {
1917         ret=regexec(&pat,string,0,NULL,0);
1918         regfree(&pat);
1919         ret=(ret==0);
1920       }
1921   }
1922 #endif
1923
1924   if(DBG_TRUST)
1925     log_debug("regexp `%s' (`%s') on `%s': %s\n",
1926               regexp,expr,string,ret==0?"YES":"NO");
1927
1928   xfree(regexp);
1929
1930   return ret;
1931 #endif
1932 }
1933
1934 /*
1935  * Return true if the key is signed by one of the keys in the given
1936  * key ID list.  User IDs with a valid signature are marked by node
1937  * flags as follows:
1938  *  flag bit 0: There is at least one signature
1939  *           1: There is marginal confidence that this is a legitimate uid
1940  *           2: There is full confidence that this is a legitimate uid.
1941  *           8: Used for internal purposes.
1942  *           9: Ditto (in mark_usable_uid_certs())
1943  *          10: Ditto (ditto)
1944  * This function assumes that all kbnode flags are cleared on entry.
1945  */
1946 static int
1947 validate_one_keyblock (KBNODE kb, struct key_item *klist,
1948                        u32 curtime, u32 *next_expire)
1949 {
1950   struct key_item *kr;
1951   KBNODE node, uidnode=NULL;
1952   PKT_user_id *uid=NULL;
1953   PKT_public_key *pk = kb->pkt->pkt.public_key;
1954   u32 main_kid[2];
1955   int issigned=0, any_signed = 0;
1956
1957   keyid_from_pk(pk, main_kid);
1958   for (node=kb; node; node = node->next)
1959     {
1960       /* A bit of discussion here: is it better for the web of trust
1961          to be built among only self-signed uids?  On the one hand, a
1962          self-signed uid is a statement that the key owner definitely
1963          intended that uid to be there, but on the other hand, a
1964          signed (but not self-signed) uid does carry trust, of a sort,
1965          even if it is a statement being made by people other than the
1966          key owner "through" the uids on the key owner's key.  I'm
1967          going with the latter.  However, if the user ID was
1968          explicitly revoked, or passively allowed to expire, that
1969          should stop validity through the user ID until it is
1970          resigned.  -dshaw */
1971
1972       if (node->pkt->pkttype == PKT_USER_ID
1973           && !node->pkt->pkt.user_id->is_revoked
1974           && !node->pkt->pkt.user_id->is_expired)
1975         {
1976           if (uidnode && issigned)
1977             {
1978               if (uid->help_full_count >= opt.completes_needed
1979                   || uid->help_marginal_count >= opt.marginals_needed )
1980                 uidnode->flag |= 4;
1981               else if (uid->help_full_count || uid->help_marginal_count)
1982                 uidnode->flag |= 2;
1983               uidnode->flag |= 1;
1984               any_signed = 1;
1985             }
1986           uidnode = node;
1987           uid=uidnode->pkt->pkt.user_id;
1988
1989           /* If the selfsig is going to expire... */
1990           if(uid->expiredate && uid->expiredate<*next_expire)
1991             *next_expire = uid->expiredate;
1992
1993           issigned = 0;
1994           get_validity_counts(pk,uid);
1995           mark_usable_uid_certs (kb, uidnode, main_kid, klist,
1996                                  curtime, next_expire);
1997         }
1998       else if (node->pkt->pkttype == PKT_SIGNATURE
1999                && (node->flag & (1<<8)) && uid)
2000         {
2001           /* Note that we are only seeing unrevoked sigs here */
2002           PKT_signature *sig = node->pkt->pkt.signature;
2003
2004           kr = is_in_klist (klist, sig);
2005           /* If the trust_regexp does not match, it's as if the sig
2006              did not exist.  This is safe for non-trust sigs as well
2007              since we don't accept a regexp on the sig unless it's a
2008              trust sig. */
2009           if (kr && (!kr->trust_regexp
2010                      || opt.trust_model != TM_PGP
2011                      || (uidnode
2012                          && check_regexp(kr->trust_regexp,
2013                                          uidnode->pkt->pkt.user_id->name))))
2014             {
2015               /* Are we part of a trust sig chain?  We always favor
2016                  the latest trust sig, rather than the greater or
2017                  lesser trust sig or value.  I could make a decent
2018                  argument for any of these cases, but this seems to be
2019                  what PGP does, and I'd like to be compatible. -dms */
2020               if (opt.trust_model == TM_PGP
2021                   && sig->trust_depth
2022                   && pk->trust_timestamp <= sig->timestamp)
2023                 {
2024                   unsigned char depth;
2025
2026                   /* If the depth on the signature is less than the
2027                      chain currently has, then use the signature depth
2028                      so we don't increase the depth beyond what the
2029                      signer wanted.  If the depth on the signature is
2030                      more than the chain currently has, then use the
2031                      chain depth so we use as much of the signature
2032                      depth as the chain will permit.  An ultimately
2033                      trusted signature can restart the depth to
2034                      whatever level it likes. */
2035
2036                   if (sig->trust_depth < kr->trust_depth
2037                       || kr->ownertrust == TRUST_ULTIMATE)
2038                     depth = sig->trust_depth;
2039                   else
2040                     depth = kr->trust_depth;
2041
2042                   if (depth)
2043                     {
2044                       if(DBG_TRUST)
2045                         log_debug ("trust sig on %s, sig depth is %d,"
2046                                    " kr depth is %d\n",
2047                                    uidnode->pkt->pkt.user_id->name,
2048                                    sig->trust_depth,
2049                                    kr->trust_depth);
2050
2051                       /* If we got here, we know that:
2052
2053                          this is a trust sig.
2054
2055                          it's a newer trust sig than any previous trust
2056                          sig on this key (not uid).
2057
2058                          it is legal in that it was either generated by an
2059                          ultimate key, or a key that was part of a trust
2060                          chain, and the depth does not violate the
2061                          original trust sig.
2062
2063                          if there is a regexp attached, it matched
2064                          successfully.
2065                       */
2066
2067                       if (DBG_TRUST)
2068                         log_debug ("replacing trust value %d with %d and "
2069                                    "depth %d with %d\n",
2070                                    pk->trust_value,sig->trust_value,
2071                                    pk->trust_depth,depth);
2072
2073                       pk->trust_value = sig->trust_value;
2074                       pk->trust_depth = depth-1;
2075
2076                       /* If the trust sig contains a regexp, record it
2077                          on the pk for the next round. */
2078                       if (sig->trust_regexp)
2079                         pk->trust_regexp = sig->trust_regexp;
2080                     }
2081                 }
2082
2083               if (kr->ownertrust == TRUST_ULTIMATE)
2084                 uid->help_full_count = opt.completes_needed;
2085               else if (kr->ownertrust == TRUST_FULLY)
2086                 uid->help_full_count++;
2087               else if (kr->ownertrust == TRUST_MARGINAL)
2088                 uid->help_marginal_count++;
2089               issigned = 1;
2090             }
2091         }
2092     }
2093
2094   if (uidnode && issigned)
2095     {
2096       if (uid->help_full_count >= opt.completes_needed
2097           || uid->help_marginal_count >= opt.marginals_needed )
2098         uidnode->flag |= 4;
2099       else if (uid->help_full_count || uid->help_marginal_count)
2100         uidnode->flag |= 2;
2101       uidnode->flag |= 1;
2102       any_signed = 1;
2103     }
2104
2105   return any_signed;
2106 }
2107
2108
2109 static int
2110 search_skipfnc (void *opaque, u32 *kid, PKT_user_id *dummy)
2111 {
2112   (void)dummy;
2113   return test_key_hash_table ((KeyHashTable)opaque, kid);
2114 }
2115
2116
2117 /*
2118  * Scan all keys and return a key_array of all suitable keys from
2119  * kllist.  The caller has to pass keydb handle so that we don't use
2120  * to create our own.  Returns either a key_array or NULL in case of
2121  * an error.  No results found are indicated by an empty array.
2122  * Caller hast to release the returned array.
2123  */
2124 static struct key_array *
2125 validate_key_list (KEYDB_HANDLE hd, KeyHashTable full_trust,
2126                    struct key_item *klist, u32 curtime, u32 *next_expire)
2127 {
2128   KBNODE keyblock = NULL;
2129   struct key_array *keys = NULL;
2130   size_t nkeys, maxkeys;
2131   int rc;
2132   KEYDB_SEARCH_DESC desc;
2133
2134   maxkeys = 1000;
2135   keys = xmalloc ((maxkeys+1) * sizeof *keys);
2136   nkeys = 0;
2137
2138   rc = keydb_search_reset (hd);
2139   if (rc)
2140     {
2141       log_error ("keydb_search_reset failed: %s\n", g10_errstr(rc));
2142       xfree (keys);
2143       return NULL;
2144     }
2145
2146   memset (&desc, 0, sizeof desc);
2147   desc.mode = KEYDB_SEARCH_MODE_FIRST;
2148   desc.skipfnc = search_skipfnc;
2149   desc.skipfncvalue = full_trust;
2150   rc = keydb_search (hd, &desc, 1);
2151   if (rc == -1)
2152     {
2153       keys[nkeys].keyblock = NULL;
2154       return keys;
2155     }
2156   if (rc)
2157     {
2158       log_error ("keydb_search_first failed: %s\n", g10_errstr(rc));
2159       xfree (keys);
2160       return NULL;
2161     }
2162
2163   desc.mode = KEYDB_SEARCH_MODE_NEXT; /* change mode */
2164   do
2165     {
2166       PKT_public_key *pk;
2167
2168       rc = keydb_get_keyblock (hd, &keyblock);
2169       if (rc)
2170         {
2171           log_error ("keydb_get_keyblock failed: %s\n", g10_errstr(rc));
2172           xfree (keys);
2173           return NULL;
2174         }
2175
2176       if ( keyblock->pkt->pkttype != PKT_PUBLIC_KEY)
2177         {
2178           log_debug ("ooops: invalid pkttype %d encountered\n",
2179                      keyblock->pkt->pkttype);
2180           dump_kbnode (keyblock);
2181           release_kbnode(keyblock);
2182           continue;
2183         }
2184
2185       /* prepare the keyblock for further processing */
2186       merge_keys_and_selfsig (keyblock);
2187       clear_kbnode_flags (keyblock);
2188       pk = keyblock->pkt->pkt.public_key;
2189       if (pk->has_expired || pk->is_revoked)
2190         {
2191           /* it does not make sense to look further at those keys */
2192           mark_keyblock_seen (full_trust, keyblock);
2193         }
2194       else if (validate_one_keyblock (keyblock, klist, curtime, next_expire))
2195         {
2196           KBNODE node;
2197
2198           if (pk->expiredate && pk->expiredate >= curtime
2199               && pk->expiredate < *next_expire)
2200             *next_expire = pk->expiredate;
2201
2202           if (nkeys == maxkeys) {
2203             maxkeys += 1000;
2204             keys = xrealloc (keys, (maxkeys+1) * sizeof *keys);
2205           }
2206           keys[nkeys++].keyblock = keyblock;
2207
2208           /* Optimization - if all uids are fully trusted, then we
2209              never need to consider this key as a candidate again. */
2210
2211           for (node=keyblock; node; node = node->next)
2212             if (node->pkt->pkttype == PKT_USER_ID && !(node->flag & 4))
2213               break;
2214
2215           if(node==NULL)
2216             mark_keyblock_seen (full_trust, keyblock);
2217
2218           keyblock = NULL;
2219         }
2220
2221       release_kbnode (keyblock);
2222       keyblock = NULL;
2223     }
2224   while ( !(rc = keydb_search (hd, &desc, 1)) );
2225   if (rc && rc != -1)
2226     {
2227       log_error ("keydb_search_next failed: %s\n", g10_errstr(rc));
2228       xfree (keys);
2229       return NULL;
2230     }
2231
2232   keys[nkeys].keyblock = NULL;
2233   return keys;
2234 }
2235
2236 /* Caller must sync */
2237 static void
2238 reset_trust_records(void)
2239 {
2240   TRUSTREC rec;
2241   ulong recnum;
2242   int count = 0, nreset = 0;
2243
2244   for (recnum=1; !tdbio_read_record (recnum, &rec, 0); recnum++ )
2245     {
2246       if(rec.rectype==RECTYPE_TRUST)
2247         {
2248           count++;
2249           if(rec.r.trust.min_ownertrust)
2250             {
2251               rec.r.trust.min_ownertrust=0;
2252               write_record(&rec);
2253             }
2254
2255         }
2256       else if(rec.rectype==RECTYPE_VALID
2257               && ((rec.r.valid.validity&TRUST_MASK)
2258                   || rec.r.valid.marginal_count
2259                   || rec.r.valid.full_count))
2260         {
2261           rec.r.valid.validity &= ~TRUST_MASK;
2262           rec.r.valid.marginal_count=rec.r.valid.full_count=0;
2263           nreset++;
2264           write_record(&rec);
2265         }
2266
2267     }
2268
2269   if (opt.verbose)
2270     log_info (_("%d keys processed (%d validity counts cleared)\n"),
2271               count, nreset);
2272 }
2273
2274 /*
2275  * Run the key validation procedure.
2276  *
2277  * This works this way:
2278  * Step 1: Find all ultimately trusted keys (UTK).
2279  *         mark them all as seen and put them into klist.
2280  * Step 2: loop max_cert_times
2281  * Step 3:   if OWNERTRUST of any key in klist is undefined
2282  *             ask user to assign ownertrust
2283  * Step 4:   Loop over all keys in the keyDB which are not marked seen
2284  * Step 5:     if key is revoked or expired
2285  *                mark key as seen
2286  *                continue loop at Step 4
2287  * Step 6:     For each user ID of that key signed by a key in klist
2288  *                Calculate validity by counting trusted signatures.
2289  *                Set validity of user ID
2290  * Step 7:     If any signed user ID was found
2291  *                mark key as seen
2292  *             End Loop
2293  * Step 8:   Build a new klist from all fully trusted keys from step 6
2294  *           End Loop
2295  *         Ready
2296  *
2297  */
2298 static int
2299 validate_keys (int interactive)
2300 {
2301   int rc = 0;
2302   int quit=0;
2303   struct key_item *klist = NULL;
2304   struct key_item *k;
2305   struct key_array *keys = NULL;
2306   struct key_array *kar;
2307   KEYDB_HANDLE kdb = NULL;
2308   KBNODE node;
2309   int depth;
2310   int ot_unknown, ot_undefined, ot_never, ot_marginal, ot_full, ot_ultimate;
2311   KeyHashTable stored,used,full_trust;
2312   u32 start_time, next_expire;
2313
2314   /* Make sure we have all sigs cached.  TODO: This is going to
2315      require some architectual re-thinking, as it is agonizingly slow.
2316      Perhaps combine this with reset_trust_records(), or only check
2317      the caches on keys that are actually involved in the web of
2318      trust. */
2319   keydb_rebuild_caches(0);
2320
2321   start_time = make_timestamp ();
2322   next_expire = 0xffffffff; /* set next expire to the year 2106 */
2323   stored = new_key_hash_table ();
2324   used = new_key_hash_table ();
2325   full_trust = new_key_hash_table ();
2326
2327   kdb = keydb_new (0);
2328   reset_trust_records();
2329
2330   /* Fixme: Instead of always building a UTK list, we could just build it
2331    * here when needed */
2332   if (!utk_list)
2333     {
2334       if (!opt.quiet)
2335         log_info (_("no ultimately trusted keys found\n"));
2336       goto leave;
2337     }
2338
2339   /* mark all UTKs as used and fully_trusted and set validity to
2340      ultimate */
2341   for (k=utk_list; k; k = k->next)
2342     {
2343       KBNODE keyblock;
2344       PKT_public_key *pk;
2345
2346       keyblock = get_pubkeyblock (k->kid);
2347       if (!keyblock)
2348         {
2349           log_error (_("public key of ultimately"
2350                        " trusted key %s not found\n"), keystr(k->kid));
2351           continue;
2352         }
2353       mark_keyblock_seen (used, keyblock);
2354       mark_keyblock_seen (stored, keyblock);
2355       mark_keyblock_seen (full_trust, keyblock);
2356       pk = keyblock->pkt->pkt.public_key;
2357       for (node=keyblock; node; node = node->next)
2358         {
2359           if (node->pkt->pkttype == PKT_USER_ID)
2360             update_validity (pk, node->pkt->pkt.user_id, 0, TRUST_ULTIMATE);
2361         }
2362       if ( pk->expiredate && pk->expiredate >= start_time
2363            && pk->expiredate < next_expire)
2364         next_expire = pk->expiredate;
2365
2366       release_kbnode (keyblock);
2367       do_sync ();
2368     }
2369
2370   klist = utk_list;
2371
2372   log_info(_("%d marginal(s) needed, %d complete(s) needed, %s trust model\n"),
2373            opt.marginals_needed,opt.completes_needed,trust_model_string());
2374
2375   for (depth=0; depth < opt.max_cert_depth; depth++)
2376     {
2377       int valids=0,key_count;
2378       /* See whether we should assign ownertrust values to the keys in
2379          klist.  */
2380       ot_unknown = ot_undefined = ot_never = 0;
2381       ot_marginal = ot_full = ot_ultimate = 0;
2382       for (k=klist; k; k = k->next)
2383         {
2384           int min=0;
2385
2386           /* 120 and 60 are as per RFC2440 */
2387           if(k->trust_value>=120)
2388             min=TRUST_FULLY;
2389           else if(k->trust_value>=60)
2390             min=TRUST_MARGINAL;
2391
2392           if(min!=k->min_ownertrust)
2393             update_min_ownertrust(k->kid,min);
2394
2395           if (interactive && k->ownertrust == TRUST_UNKNOWN)
2396             {
2397               k->ownertrust = ask_ownertrust (k->kid,min);
2398
2399               if (k->ownertrust == -1)
2400                 {
2401                   quit=1;
2402                   goto leave;
2403                 }
2404             }
2405
2406           /* This can happen during transition from an old trustdb
2407              before trust sigs.  It can also happen if a user uses two
2408              different versions of GnuPG or changes the --trust-model
2409              setting. */
2410           if(k->ownertrust<min)
2411             {
2412               if(DBG_TRUST)
2413                 log_debug("key %08lX%08lX:"
2414                           " overriding ownertrust `%s' with `%s'\n",
2415                           (ulong)k->kid[0],(ulong)k->kid[1],
2416                           trust_value_to_string(k->ownertrust),
2417                           trust_value_to_string(min));
2418
2419               k->ownertrust=min;
2420             }
2421
2422           if (k->ownertrust == TRUST_UNKNOWN)
2423             ot_unknown++;
2424           else if (k->ownertrust == TRUST_UNDEFINED)
2425             ot_undefined++;
2426           else if (k->ownertrust == TRUST_NEVER)
2427             ot_never++;
2428           else if (k->ownertrust == TRUST_MARGINAL)
2429             ot_marginal++;
2430           else if (k->ownertrust == TRUST_FULLY)
2431             ot_full++;
2432           else if (k->ownertrust == TRUST_ULTIMATE)
2433             ot_ultimate++;
2434
2435           valids++;
2436         }
2437
2438       /* Find all keys which are signed by a key in kdlist */
2439       keys = validate_key_list (kdb, full_trust, klist,
2440                                 start_time, &next_expire);
2441       if (!keys)
2442         {
2443           log_error ("validate_key_list failed\n");
2444           rc = G10ERR_GENERAL;
2445           goto leave;
2446         }
2447
2448       for (key_count=0, kar=keys; kar->keyblock; kar++, key_count++)
2449         ;
2450
2451       /* Store the calculated valididation status somewhere */
2452       if (opt.verbose > 1 && DBG_TRUST)
2453         dump_key_array (depth, keys);
2454
2455       for (kar=keys; kar->keyblock; kar++)
2456           store_validation_status (depth, kar->keyblock, stored);
2457
2458       if (!opt.quiet)
2459         log_info (_("depth: %d  valid: %3d  signed: %3d"
2460                     "  trust: %d-, %dq, %dn, %dm, %df, %du\n"),
2461                   depth, valids, key_count, ot_unknown, ot_undefined,
2462                   ot_never, ot_marginal, ot_full, ot_ultimate );
2463
2464       /* Build a new kdlist from all fully valid keys in KEYS */
2465       if (klist != utk_list)
2466         release_key_items (klist);
2467       klist = NULL;
2468       for (kar=keys; kar->keyblock; kar++)
2469         {
2470           for (node=kar->keyblock; node; node = node->next)
2471             {
2472               if (node->pkt->pkttype == PKT_USER_ID && (node->flag & 4))
2473                 {
2474                   u32 kid[2];
2475
2476                   /* have we used this key already? */
2477                   keyid_from_pk (kar->keyblock->pkt->pkt.public_key, kid);
2478                   if(test_key_hash_table(used,kid)==0)
2479                     {
2480                       /* Normally we add both the primary and subkey
2481                          ids to the hash via mark_keyblock_seen, but
2482                          since we aren't using this hash as a skipfnc,
2483                          that doesn't matter here. */
2484                       add_key_hash_table (used,kid);
2485                       k = new_key_item ();
2486                       k->kid[0]=kid[0];
2487                       k->kid[1]=kid[1];
2488                       k->ownertrust =
2489                         (get_ownertrust (kar->keyblock->pkt->pkt.public_key)
2490                          & TRUST_MASK);
2491                       k->min_ownertrust =
2492                         get_min_ownertrust(kar->keyblock->pkt->pkt.public_key);
2493                       k->trust_depth=
2494                         kar->keyblock->pkt->pkt.public_key->trust_depth;
2495                       k->trust_value=
2496                         kar->keyblock->pkt->pkt.public_key->trust_value;
2497                       if(kar->keyblock->pkt->pkt.public_key->trust_regexp)
2498                         k->trust_regexp=
2499                           xstrdup(kar->keyblock->pkt->
2500                                    pkt.public_key->trust_regexp);
2501                       k->next = klist;
2502                       klist = k;
2503                       break;
2504                     }
2505                 }
2506             }
2507         }
2508       release_key_array (keys);
2509       keys = NULL;
2510       if (!klist)
2511         break; /* no need to dive in deeper */
2512     }
2513
2514  leave:
2515   keydb_release (kdb);
2516   release_key_array (keys);
2517   release_key_items (klist);
2518   release_key_hash_table (full_trust);
2519   release_key_hash_table (used);
2520   release_key_hash_table (stored);
2521   if (!rc && !quit) /* mark trustDB as checked */
2522     {
2523       if (next_expire == 0xffffffff || next_expire < start_time )
2524         tdbio_write_nextcheck (0);
2525       else
2526         {
2527           tdbio_write_nextcheck (next_expire);
2528           if (!opt.quiet)
2529             log_info (_("next trustdb check due at %s\n"),
2530                       strtimestamp (next_expire));
2531         }
2532
2533       if(tdbio_update_version_record()!=0)
2534         {
2535           log_error(_("unable to update trustdb version record: "
2536                       "write failed: %s\n"), g10_errstr(rc));
2537           tdbio_invalid();
2538         }
2539
2540       do_sync ();
2541       pending_check_trustdb = 0;
2542     }
2543
2544   return rc;
2545 }