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