gpg: In search-keys return "Not found" instead of "No Data".
[gnupg.git] / g10 / tdbio.c
1 /* tdbio.c - trust database I/O operations
2  * Copyright (C) 1998-2002, 2012 Free Software Foundation, Inc.
3  * Copyright (C) 1998-2015 Werner Koch
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 <https://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26 #include <sys/types.h>
27 #include <sys/stat.h>
28 #include <fcntl.h>
29 #include <unistd.h>
30
31 #include "gpg.h"
32 #include "../common/status.h"
33 #include "../common/iobuf.h"
34 #include "../common/util.h"
35 #include "options.h"
36 #include "main.h"
37 #include "../common/i18n.h"
38 #include "trustdb.h"
39 #include "tdbio.h"
40
41 #if defined(HAVE_DOSISH_SYSTEM) && !defined(ftruncate)
42 #define ftruncate chsize
43 #endif
44
45 #if defined(HAVE_DOSISH_SYSTEM) || defined(__CYGWIN__)
46 #define MY_O_BINARY  O_BINARY
47 #else
48 #define MY_O_BINARY  0
49 #endif
50
51 /* We use ERRNO despite that the cegcc provided open/read/write
52    functions don't set ERRNO - at least show that ERRNO does not make
53    sense.  */
54 #ifdef HAVE_W32CE_SYSTEM
55 #undef strerror
56 #define strerror(a) ("[errno not available]")
57 #endif
58
59 /*
60  * Yes, this is a very simple implementation. We should really
61  * use a page aligned buffer and read complete pages.
62  * To implement a simple trannsaction system, this is sufficient.
63  */
64 typedef struct cache_ctrl_struct *CACHE_CTRL;
65 struct cache_ctrl_struct
66 {
67   CACHE_CTRL next;
68   struct {
69     unsigned used:1;
70     unsigned dirty:1;
71   } flags;
72   ulong recno;
73   char data[TRUST_RECORD_LEN];
74 };
75
76 /* Size of the cache.  The SOFT value is the general one.  While in a
77    transaction this may not be sufficient and thus we may increase it
78    then up to the HARD limit.  */
79 #define MAX_CACHE_ENTRIES_SOFT  200
80 #define MAX_CACHE_ENTRIES_HARD  10000
81
82
83 /* The cache is controlled by these variables.  */
84 static CACHE_CTRL cache_list;
85 static int cache_entries;
86 static int cache_is_dirty;
87
88
89 /* An object to pass information to cmp_krec_fpr. */
90 struct cmp_krec_fpr_struct
91 {
92   int pubkey_algo;
93   const char *fpr;
94   int fprlen;
95 };
96
97 /* An object used to pass information to cmp_[s]dir. */
98 struct cmp_xdir_struct
99 {
100   int pubkey_algo;
101   u32 keyid[2];
102 };
103
104
105 /* The name of the trustdb file.  */
106 static char *db_name;
107
108 /* The handle for locking the trustdb file and a counter to record how
109  * often this lock has been taken.  That counter is required because
110  * dotlock does not implemen recursive locks.  */
111 static dotlock_t lockhandle;
112 static unsigned int is_locked;
113
114 /* The file descriptor of the trustdb.  */
115 static int  db_fd = -1;
116
117 /* A flag indicating that a transaction is active.  */
118 /* static int in_transaction;   Not yet used. */
119
120
121 \f
122 static void open_db (void);
123 static void create_hashtable (ctrl_t ctrl, TRUSTREC *vr, int type);
124
125
126 \f
127 /*
128  * Take a lock on the trustdb file name.  I a lock file can't be
129  * created the function terminates the process.  Except for a
130  * different return code the function does nothing if the lock has
131  * already been taken.
132  *
133  * Returns: True if lock already exists, False if the lock has
134  *          actually been taken.
135  */
136 static int
137 take_write_lock (void)
138 {
139   int rc;
140
141   if (!lockhandle)
142     lockhandle = dotlock_create (db_name, 0);
143   if (!lockhandle)
144     log_fatal ( _("can't create lock for '%s'\n"), db_name );
145
146   if (!is_locked)
147     {
148       if (dotlock_take (lockhandle, -1) )
149         log_fatal ( _("can't lock '%s'\n"), db_name );
150       rc = 0;
151     }
152   else
153     rc = 1;
154
155   if (opt.lock_once)
156     is_locked = 1;
157   else
158     is_locked++;
159   return rc;
160 }
161
162
163 /*
164  * Release a lock from the trustdb file unless the global option
165  * --lock-once has been used.
166  */
167 static void
168 release_write_lock (void)
169 {
170   if (opt.lock_once)
171     return;  /* Don't care; here IS_LOCKED is fixed to 1.  */
172
173   if (!is_locked)
174     {
175       log_error ("Ooops, tdbio:release_write_lock with no lock held\n");
176       return;
177     }
178   if (--is_locked)
179     return;
180
181   if (dotlock_release (lockhandle))
182     log_error ("Oops, tdbio:release_write_locked failed\n");
183 }
184
185
186 \f
187 /*************************************
188  ************* record cache **********
189  *************************************/
190
191 /*
192  * Get the data from the record cache and return a pointer into that
193  * cache.  Caller should copy the returned data.  NULL is returned on
194  * a cache miss.
195  */
196 static const char *
197 get_record_from_cache (ulong recno)
198 {
199   CACHE_CTRL r;
200
201   for (r = cache_list; r; r = r->next)
202     {
203       if (r->flags.used && r->recno == recno)
204         return r->data;
205     }
206   return NULL;
207 }
208
209
210 /*
211  * Write a cached item back to the trustdb file.
212  *
213  * Returns: 0 on success or an error code.
214  */
215 static int
216 write_cache_item (CACHE_CTRL r)
217 {
218   gpg_error_t err;
219   int n;
220
221   if (lseek (db_fd, r->recno * TRUST_RECORD_LEN, SEEK_SET) == -1)
222     {
223       err = gpg_error_from_syserror ();
224       log_error (_("trustdb rec %lu: lseek failed: %s\n"),
225                  r->recno, strerror (errno));
226       return err;
227     }
228   n = write (db_fd, r->data, TRUST_RECORD_LEN);
229   if (n != TRUST_RECORD_LEN)
230     {
231       err = gpg_error_from_syserror ();
232       log_error (_("trustdb rec %lu: write failed (n=%d): %s\n"),
233                  r->recno, n, strerror (errno) );
234       return err;
235     }
236   r->flags.dirty = 0;
237   return 0;
238 }
239
240
241 /*
242  * Put data into the cache.  This function may flush
243  * some cache entries if the cache is filled up.
244  *
245  * Returns: 0 on success or an error code.
246  */
247 static int
248 put_record_into_cache (ulong recno, const char *data)
249 {
250   CACHE_CTRL r, unused;
251   int dirty_count = 0;
252   int clean_count = 0;
253
254   /* See whether we already cached this one.  */
255   for (unused = NULL, r = cache_list; r; r = r->next)
256     {
257       if (!r->flags.used)
258         {
259           if (!unused)
260             unused = r;
261         }
262       else if (r->recno == recno)
263         {
264           if (!r->flags.dirty)
265             {
266               /* Hmmm: should we use a copy and compare? */
267               if (memcmp (r->data, data, TRUST_RECORD_LEN))
268                 {
269                   r->flags.dirty = 1;
270                   cache_is_dirty = 1;
271                 }
272             }
273           memcpy (r->data, data, TRUST_RECORD_LEN);
274           return 0;
275         }
276       if (r->flags.used)
277         {
278           if (r->flags.dirty)
279             dirty_count++;
280           else
281             clean_count++;
282         }
283     }
284
285   /* Not in the cache: add a new entry. */
286   if (unused)
287     {
288       /* Reuse this entry. */
289       r = unused;
290       r->flags.used = 1;
291       r->recno = recno;
292       memcpy (r->data, data, TRUST_RECORD_LEN);
293       r->flags.dirty = 1;
294       cache_is_dirty = 1;
295       cache_entries++;
296       return 0;
297     }
298
299   /* See whether we reached the limit. */
300   if (cache_entries < MAX_CACHE_ENTRIES_SOFT)
301     {
302       /* No: Put into cache.  */
303       r = xmalloc (sizeof *r);
304       r->flags.used = 1;
305       r->recno = recno;
306       memcpy (r->data, data, TRUST_RECORD_LEN);
307       r->flags.dirty = 1;
308       r->next = cache_list;
309       cache_list = r;
310       cache_is_dirty = 1;
311       cache_entries++;
312       return 0;
313     }
314
315   /* Cache is full: discard some clean entries.  */
316   if (clean_count)
317     {
318       int n;
319
320       /* We discard a third of the clean entries.  */
321       n = clean_count / 3;
322       if (!n)
323         n = 1;
324
325       for (unused = NULL, r = cache_list; r; r = r->next)
326         {
327           if (r->flags.used && !r->flags.dirty)
328             {
329               if (!unused)
330                 unused = r;
331               r->flags.used = 0;
332               cache_entries--;
333               if (!--n)
334                 break;
335             }
336         }
337
338       /* Now put into the cache.  */
339       log_assert (unused);
340       r = unused;
341       r->flags.used = 1;
342       r->recno = recno;
343       memcpy (r->data, data, TRUST_RECORD_LEN);
344       r->flags.dirty = 1;
345       cache_is_dirty = 1;
346       cache_entries++;
347       return 0;
348     }
349
350   /* No clean entries: We have to flush some dirty entries.  */
351 #if 0 /* Transactions are not yet used.  */
352   if (in_transaction)
353     {
354       /* But we can't do this while in a transaction.  Thus we
355        * increase the cache size instead.  */
356       if (cache_entries < MAX_CACHE_ENTRIES_HARD)
357         {
358           if (opt.debug && !(cache_entries % 100))
359             log_debug ("increasing tdbio cache size\n");
360           r = xmalloc (sizeof *r);
361           r->flags.used = 1;
362           r->recno = recno;
363           memcpy (r->data, data, TRUST_RECORD_LEN);
364           r->flags.dirty = 1;
365           r->next = cache_list;
366           cache_list = r;
367           cache_is_dirty = 1;
368           cache_entries++;
369           return 0;
370         }
371       /* Hard limit for the cache size reached.  */
372       log_info (_("trustdb transaction too large\n"));
373       return GPG_ERR_RESOURCE_LIMIT;
374     }
375 #endif
376
377   if (dirty_count)
378     {
379       int n;
380
381       /* Discard some dirty entries. */
382       n = dirty_count / 5;
383       if (!n)
384         n = 1;
385
386       take_write_lock ();
387       for (unused = NULL, r = cache_list; r; r = r->next)
388         {
389           if (r->flags.used && r->flags.dirty)
390             {
391               int rc;
392
393               rc = write_cache_item (r);
394               if (rc)
395                 return rc;
396               if (!unused)
397                 unused = r;
398               r->flags.used = 0;
399               cache_entries--;
400               if (!--n)
401                 break;
402             }
403         }
404       release_write_lock ();
405
406       /* Now put into the cache.  */
407       log_assert (unused);
408       r = unused;
409       r->flags.used = 1;
410       r->recno = recno;
411       memcpy (r->data, data, TRUST_RECORD_LEN);
412       r->flags.dirty = 1;
413       cache_is_dirty = 1;
414       cache_entries++;
415       return 0;
416     }
417
418   /* We should never reach this.  */
419   BUG();
420 }
421
422
423 /* Return true if the cache is dirty.  */
424 int
425 tdbio_is_dirty()
426 {
427   return cache_is_dirty;
428 }
429
430
431 /*
432  * Flush the cache.  This cannot be used while in a transaction.
433  */
434 int
435 tdbio_sync()
436 {
437     CACHE_CTRL r;
438     int did_lock = 0;
439
440     if( db_fd == -1 )
441         open_db();
442 #if 0 /* Transactions are not yet used.  */
443     if( in_transaction )
444         log_bug("tdbio: syncing while in transaction\n");
445 #endif
446
447     if( !cache_is_dirty )
448         return 0;
449
450     if (!take_write_lock ())
451         did_lock = 1;
452
453     for( r = cache_list; r; r = r->next ) {
454         if( r->flags.used && r->flags.dirty ) {
455             int rc = write_cache_item( r );
456             if( rc )
457                 return rc;
458         }
459     }
460     cache_is_dirty = 0;
461     if (did_lock)
462         release_write_lock ();
463
464     return 0;
465 }
466
467
468 #if 0  /* Not yet used.  */
469 /*
470  * Simple transactions system:
471  * Everything between begin_transaction and end/cancel_transaction
472  * is not immediately written but at the time of end_transaction.
473  *
474  * NOTE: The transaction code is disabled in the 1.2 branch, as it is
475  * not yet used.
476  */
477 int
478 tdbio_begin_transaction ()  /* Not yet used.  */
479 {
480   int rc;
481
482   if (in_transaction)
483     log_bug ("tdbio: nested transactions\n");
484   /* Flush everything out. */
485   rc = tdbio_sync();
486   if (rc)
487     return rc;
488   in_transaction = 1;
489   return 0;
490 }
491
492 int
493 tdbio_end_transaction ()  /* Not yet used.  */
494 {
495   int rc;
496
497   if (!in_transaction)
498     log_bug ("tdbio: no active transaction\n");
499   take_write_lock ();
500   gnupg_block_all_signals ();
501   in_transaction = 0;
502   rc = tdbio_sync();
503   gnupg_unblock_all_signals();
504   release_write_lock ();
505   return rc;
506 }
507
508 int
509 tdbio_cancel_transaction () /* Not yet used.  */
510 {
511   CACHE_CTRL r;
512
513   if (!in_transaction)
514     log_bug ("tdbio: no active transaction\n");
515
516   /* Remove all dirty marked entries, so that the original ones are
517    * read back the next time.  */
518   if (cache_is_dirty)
519     {
520       for (r = cache_list; r; r = r->next)
521         {
522           if (r->flags.used && r->flags.dirty)
523             {
524               r->flags.used = 0;
525               cache_entries--;
526             }
527         }
528       cache_is_dirty = 0;
529     }
530
531   in_transaction = 0;
532   return 0;
533 }
534 #endif  /* Not yet used.  */
535
536
537 \f
538 /********************************************************
539  **************** cached I/O functions ******************
540  ********************************************************/
541
542 /* The cleanup handler for this module.  */
543 static void
544 cleanup (void)
545 {
546   if (is_locked)
547     {
548       if (!dotlock_release (lockhandle))
549         is_locked = 0;
550     }
551 }
552
553
554 /*
555  * Update an existing trustdb record.  The caller must call
556  * tdbio_sync.
557  *
558  * Returns: 0 on success or an error code.
559  */
560 int
561 tdbio_update_version_record (ctrl_t ctrl)
562 {
563   TRUSTREC rec;
564   int rc;
565   int opt_tm;
566
567   /* Never store a TOFU trust model in the trustdb.  Use PGP instead.  */
568   opt_tm = opt.trust_model;
569   if (opt_tm == TM_TOFU || opt_tm == TM_TOFU_PGP)
570     opt_tm = TM_PGP;
571
572   memset (&rec, 0, sizeof rec);
573
574   rc = tdbio_read_record (0, &rec, RECTYPE_VER);
575   if (!rc)
576     {
577       rec.r.ver.created     = make_timestamp();
578       rec.r.ver.marginals   = opt.marginals_needed;
579       rec.r.ver.completes   = opt.completes_needed;
580       rec.r.ver.cert_depth  = opt.max_cert_depth;
581       rec.r.ver.trust_model = opt_tm;
582       rec.r.ver.min_cert_level = opt.min_cert_level;
583       rc = tdbio_write_record (ctrl, &rec);
584     }
585
586   return rc;
587 }
588
589
590 /*
591  * Create and write the trustdb version record.
592  * This is called with the writelock active.
593  * Returns: 0 on success or an error code.
594  */
595 static int
596 create_version_record (ctrl_t ctrl)
597 {
598   TRUSTREC rec;
599   int rc;
600   int opt_tm;
601
602   /* Never store a TOFU trust model in the trustdb.  Use PGP instead.  */
603   opt_tm = opt.trust_model;
604   if (opt_tm == TM_TOFU || opt_tm == TM_TOFU_PGP)
605     opt_tm = TM_PGP;
606
607   memset (&rec, 0, sizeof rec);
608   rec.r.ver.version     = 3;
609   rec.r.ver.created     = make_timestamp ();
610   rec.r.ver.marginals   = opt.marginals_needed;
611   rec.r.ver.completes   = opt.completes_needed;
612   rec.r.ver.cert_depth  = opt.max_cert_depth;
613   if (opt_tm == TM_PGP || opt_tm == TM_CLASSIC)
614     rec.r.ver.trust_model = opt_tm;
615   else
616     rec.r.ver.trust_model = TM_PGP;
617   rec.r.ver.min_cert_level = opt.min_cert_level;
618   rec.rectype = RECTYPE_VER;
619   rec.recnum = 0;
620   rc = tdbio_write_record (ctrl, &rec);
621
622   if (!rc)
623     tdbio_sync ();
624
625   if (!rc)
626     create_hashtable (ctrl, &rec, 0);
627
628   return rc;
629 }
630
631
632 /*
633  * Set the file name for the trustdb to NEW_DBNAME and if CREATE is
634  * true create that file.  If NEW_DBNAME is NULL a default name is
635  * used, if the it does not contain a path component separator ('/')
636  * the global GnuPG home directory is used.
637  *
638  * Returns: 0 on success or an error code.
639  *
640  * On the first call this function registers an atexit handler.
641  *
642  */
643 int
644 tdbio_set_dbname (ctrl_t ctrl, const char *new_dbname,
645                   int create, int *r_nofile)
646 {
647   char *fname, *p;
648   struct stat statbuf;
649   static int initialized = 0;
650   int save_slash;
651
652   if (!initialized)
653     {
654       atexit (cleanup);
655       initialized = 1;
656     }
657
658   *r_nofile = 0;
659
660   if (!new_dbname)
661     {
662       fname = make_filename (gnupg_homedir (),
663                              "trustdb" EXTSEP_S GPGEXT_GPG, NULL);
664     }
665   else if (*new_dbname != DIRSEP_C )
666     {
667       if (strchr (new_dbname, DIRSEP_C))
668         fname = make_filename (new_dbname, NULL);
669       else
670         fname = make_filename (gnupg_homedir (), new_dbname, NULL);
671     }
672   else
673     {
674       fname = xstrdup (new_dbname);
675     }
676
677   xfree (db_name);
678   db_name = fname;
679
680   /* Quick check for (likely) case where there already is a
681    * trustdb.gpg.  This check is not required in theory, but it helps
682    * in practice avoiding costly operations of preparing and taking
683    * the lock.  */
684   if (!stat (fname, &statbuf) && statbuf.st_size > 0)
685     {
686       /* OK, we have the valid trustdb.gpg already.  */
687       return 0;
688     }
689   else if (!create)
690     {
691       *r_nofile = 1;
692       return 0;
693     }
694
695   /* Here comes: No valid trustdb.gpg AND CREATE==1 */
696
697   /*
698    * Make sure the directory exists.  This should be done before
699    * acquiring the lock, which assumes the existence of the directory.
700    */
701   p = strrchr (fname, DIRSEP_C);
702 #if HAVE_W32_SYSTEM
703   {
704     /* Windows may either have a slash or a backslash.  Take
705        care of it.  */
706     char *pp = strrchr (fname, '/');
707     if (!p || pp > p)
708       p = pp;
709   }
710 #endif /*HAVE_W32_SYSTEM*/
711   log_assert (p);
712   save_slash = *p;
713   *p = 0;
714   if (access (fname, F_OK))
715     {
716       try_make_homedir (fname);
717       if (access (fname, F_OK))
718         log_fatal (_("%s: directory does not exist!\n"), fname);
719     }
720   *p = save_slash;
721
722   take_write_lock ();
723
724   if (access (fname, R_OK) || stat (fname, &statbuf) || statbuf.st_size == 0)
725     {
726       FILE *fp;
727       TRUSTREC rec;
728       int rc;
729       mode_t oldmask;
730
731 #ifdef HAVE_W32CE_SYSTEM
732       /* We know how the cegcc implementation of access works ;-). */
733       if (GetLastError () == ERROR_FILE_NOT_FOUND)
734         gpg_err_set_errno (ENOENT);
735       else
736         gpg_err_set_errno (EIO);
737 #endif /*HAVE_W32CE_SYSTEM*/
738       if (errno && errno != ENOENT)
739         log_fatal ( _("can't access '%s': %s\n"), fname, strerror (errno));
740
741       oldmask = umask (077);
742       if (is_secured_filename (fname))
743         {
744           fp = NULL;
745           gpg_err_set_errno (EPERM);
746         }
747       else
748         fp = fopen (fname, "wb");
749       umask(oldmask);
750       if (!fp)
751         log_fatal (_("can't create '%s': %s\n"), fname, strerror (errno));
752       fclose (fp);
753
754       db_fd = open (db_name, O_RDWR | MY_O_BINARY);
755       if (db_fd == -1)
756         log_fatal (_("can't open '%s': %s\n"), db_name, strerror (errno));
757
758       rc = create_version_record (ctrl);
759       if (rc)
760         log_fatal (_("%s: failed to create version record: %s"),
761                    fname, gpg_strerror (rc));
762
763       /* Read again to check that we are okay. */
764       if (tdbio_read_record (0, &rec, RECTYPE_VER))
765         log_fatal (_("%s: invalid trustdb created\n"), db_name);
766
767       if (!opt.quiet)
768         log_info (_("%s: trustdb created\n"), db_name);
769     }
770
771   release_write_lock ();
772   return 0;
773 }
774
775
776 /*
777  * Return the full name of the trustdb.
778  */
779 const char *
780 tdbio_get_dbname ()
781 {
782   return db_name;
783 }
784
785
786 /*
787  * Open the trustdb.  This may only be called if it has not yet been
788  * opened and after a successful call to tdbio_set_dbname.  On return
789  * the trustdb handle (DB_FD) is guaranteed to be open.
790  */
791 static void
792 open_db ()
793 {
794   TRUSTREC rec;
795
796   log_assert( db_fd == -1 );
797
798 #ifdef HAVE_W32CE_SYSTEM
799   {
800     DWORD prevrc = 0;
801     wchar_t *wname = utf8_to_wchar (db_name);
802     if (wname)
803       {
804         db_fd = (int)CreateFile (wname, GENERIC_READ|GENERIC_WRITE,
805                                  FILE_SHARE_READ|FILE_SHARE_WRITE, NULL,
806                                  OPEN_EXISTING, 0, NULL);
807         xfree (wname);
808       }
809     if (db_fd == -1)
810       log_fatal ("can't open '%s': %d, %d\n", db_name,
811                  (int)prevrc, (int)GetLastError ());
812   }
813 #else /*!HAVE_W32CE_SYSTEM*/
814   db_fd = open (db_name, O_RDWR | MY_O_BINARY );
815   if (db_fd == -1 && (errno == EACCES
816 #ifdef EROFS
817                       || errno == EROFS
818 #endif
819                       )
820       ) {
821       /* Take care of read-only trustdbs.  */
822       db_fd = open (db_name, O_RDONLY | MY_O_BINARY );
823       if (db_fd != -1 && !opt.quiet)
824           log_info (_("Note: trustdb not writable\n"));
825   }
826   if ( db_fd == -1 )
827     log_fatal( _("can't open '%s': %s\n"), db_name, strerror(errno) );
828 #endif /*!HAVE_W32CE_SYSTEM*/
829   register_secured_file (db_name);
830
831   /* Read the version record. */
832   if (tdbio_read_record (0, &rec, RECTYPE_VER ) )
833     log_fatal( _("%s: invalid trustdb\n"), db_name );
834 }
835
836
837 /*
838  * Append a new empty hashtable to the trustdb.  TYPE gives the type
839  * of the hash table.  The only defined type is 0 for a trust hash.
840  * On return the hashtable has been created, written, the version
841  * record update, and the data flushed to the disk.  On a fatal error
842  * the function terminates the process.
843  */
844 static void
845 create_hashtable (ctrl_t ctrl, TRUSTREC *vr, int type)
846 {
847   TRUSTREC rec;
848   off_t offset;
849   ulong recnum;
850   int i, n, rc;
851
852   offset = lseek (db_fd, 0, SEEK_END);
853   if (offset == -1)
854     log_fatal ("trustdb: lseek to end failed: %s\n", strerror(errno));
855   recnum = offset / TRUST_RECORD_LEN;
856   log_assert (recnum); /* This is will never be the first record. */
857
858   if (!type)
859     vr->r.ver.trusthashtbl = recnum;
860
861   /* Now write the records making up the hash table. */
862   n = (256+ITEMS_PER_HTBL_RECORD-1) / ITEMS_PER_HTBL_RECORD;
863   for (i=0; i < n; i++, recnum++)
864     {
865       memset (&rec, 0, sizeof rec);
866       rec.rectype = RECTYPE_HTBL;
867       rec.recnum = recnum;
868       rc = tdbio_write_record (ctrl, &rec);
869       if (rc)
870         log_fatal (_("%s: failed to create hashtable: %s\n"),
871                    db_name, gpg_strerror (rc));
872     }
873   /* Update the version record and flush. */
874   rc = tdbio_write_record (ctrl, vr);
875   if (!rc)
876     rc = tdbio_sync ();
877   if (rc)
878     log_fatal (_("%s: error updating version record: %s\n"),
879                db_name, gpg_strerror (rc));
880 }
881
882
883 /*
884  * Check whether open trustdb matches the global trust options given
885  * for this process.  On a read problem the process is terminated.
886  *
887  * Return: 1 for yes, 0 for no.
888  */
889 int
890 tdbio_db_matches_options()
891 {
892   static int yes_no = -1;
893
894   if (yes_no == -1)
895     {
896       TRUSTREC vr;
897       int rc;
898       int opt_tm, tm;
899
900       rc = tdbio_read_record (0, &vr, RECTYPE_VER);
901       if( rc )
902         log_fatal( _("%s: error reading version record: %s\n"),
903                    db_name, gpg_strerror (rc) );
904
905       /* Consider tofu and pgp the same.  */
906       tm = vr.r.ver.trust_model;
907       if (tm == TM_TOFU || tm == TM_TOFU_PGP)
908         tm = TM_PGP;
909       opt_tm  = opt.trust_model;
910       if (opt_tm == TM_TOFU || opt_tm == TM_TOFU_PGP)
911         opt_tm = TM_PGP;
912
913       yes_no = vr.r.ver.marginals == opt.marginals_needed
914         && vr.r.ver.completes == opt.completes_needed
915         && vr.r.ver.cert_depth == opt.max_cert_depth
916         && tm == opt_tm
917         && vr.r.ver.min_cert_level == opt.min_cert_level;
918     }
919
920   return yes_no;
921 }
922
923
924 /*
925  * Read and return the trust model identifier from the trustdb.  On a
926  * read problem the process is terminated.
927  */
928 byte
929 tdbio_read_model (void)
930 {
931   TRUSTREC vr;
932   int rc;
933
934   rc = tdbio_read_record (0, &vr, RECTYPE_VER );
935   if (rc)
936     log_fatal (_("%s: error reading version record: %s\n"),
937                db_name, gpg_strerror (rc) );
938   return vr.r.ver.trust_model;
939 }
940
941
942 /*
943  * Read and return the nextstamp value from the trustdb.  On a read
944  * problem the process is terminated.
945  */
946 ulong
947 tdbio_read_nextcheck ()
948 {
949   TRUSTREC vr;
950   int rc;
951
952   rc = tdbio_read_record (0, &vr, RECTYPE_VER);
953   if (rc)
954     log_fatal (_("%s: error reading version record: %s\n"),
955                db_name, gpg_strerror (rc));
956   return vr.r.ver.nextcheck;
957 }
958
959
960 /*
961  * Write the STAMP nextstamp timestamp to the trustdb.  On a read or
962  * write problem the process is terminated.
963  *
964  * Return: True if the stamp actually changed.
965  */
966 int
967 tdbio_write_nextcheck (ctrl_t ctrl, ulong stamp)
968 {
969   TRUSTREC vr;
970   int rc;
971
972   rc = tdbio_read_record (0, &vr, RECTYPE_VER);
973   if (rc)
974     log_fatal (_("%s: error reading version record: %s\n"),
975                db_name, gpg_strerror (rc));
976
977   if (vr.r.ver.nextcheck == stamp)
978     return 0;
979
980   vr.r.ver.nextcheck = stamp;
981   rc = tdbio_write_record (ctrl, &vr);
982   if (rc)
983     log_fatal (_("%s: error writing version record: %s\n"),
984                db_name, gpg_strerror (rc));
985   return 1;
986 }
987
988
989
990 /*
991  * Return the record number of the trusthash table or create one if it
992  * does not yet exist.  On a read or write problem the process is
993  * terminated.
994  *
995  * Return: record number
996  */
997 static ulong
998 get_trusthashrec (ctrl_t ctrl)
999 {
1000   static ulong trusthashtbl; /* Record number of the trust hashtable.  */
1001
1002   (void)ctrl;
1003
1004   if (!trusthashtbl)
1005     {
1006       TRUSTREC vr;
1007       int rc;
1008
1009       rc = tdbio_read_record (0, &vr, RECTYPE_VER );
1010       if (rc)
1011         log_fatal (_("%s: error reading version record: %s\n"),
1012                    db_name, gpg_strerror (rc) );
1013
1014       if (!vr.r.ver.trusthashtbl)
1015         {
1016           /* Oops: the trustdb is corrupt because the hashtable is
1017            * always created along with the version record.  However,
1018            * if something went initially wrong it may happen that
1019            * there is just the version record.  We try to fix it here.
1020            * If we can't do that we return 0 - this is the version
1021            * record and thus the actual read will detect the mismatch
1022            * and bail out.  Note that create_hashtable updates VR.  */
1023           take_write_lock ();
1024           if (lseek (db_fd, 0, SEEK_END) == TRUST_RECORD_LEN)
1025             create_hashtable (ctrl, &vr, 0);
1026           release_write_lock ();
1027         }
1028       trusthashtbl = vr.r.ver.trusthashtbl;
1029     }
1030
1031   return trusthashtbl;
1032 }
1033
1034
1035
1036 /*
1037  * Update a hashtable in the trustdb.  TABLE gives the start of the
1038  * table, KEY and KEYLEN are the key, NEWRECNUM is the record number
1039  * to insert into the table.
1040  *
1041  * Return: 0 on success or an error code.
1042  */
1043 static int
1044 upd_hashtable (ctrl_t ctrl, ulong table, byte *key, int keylen, ulong newrecnum)
1045 {
1046   TRUSTREC lastrec, rec;
1047   ulong hashrec, item;
1048   int msb;
1049   int level = 0;
1050   int rc, i;
1051
1052   hashrec = table;
1053  next_level:
1054   msb = key[level];
1055   hashrec += msb / ITEMS_PER_HTBL_RECORD;
1056   rc = tdbio_read_record (hashrec, &rec, RECTYPE_HTBL);
1057   if (rc)
1058     {
1059       log_error ("upd_hashtable: read failed: %s\n", gpg_strerror (rc));
1060       return rc;
1061     }
1062
1063   item = rec.r.htbl.item[msb % ITEMS_PER_HTBL_RECORD];
1064   if (!item)  /* Insert a new item into the hash table.  */
1065     {
1066       rec.r.htbl.item[msb % ITEMS_PER_HTBL_RECORD] = newrecnum;
1067       rc = tdbio_write_record (ctrl, &rec);
1068       if (rc)
1069         {
1070           log_error ("upd_hashtable: write htbl failed: %s\n",
1071                      gpg_strerror (rc));
1072           return rc;
1073         }
1074     }
1075   else if (item != newrecnum) /* Must do an update.  */
1076     {
1077       lastrec = rec;
1078       rc = tdbio_read_record (item, &rec, 0);
1079       if (rc)
1080         {
1081           log_error ("upd_hashtable: read item failed: %s\n",
1082                      gpg_strerror (rc));
1083           return rc;
1084         }
1085
1086       if (rec.rectype == RECTYPE_HTBL)
1087         {
1088           hashrec = item;
1089           level++;
1090           if (level >= keylen)
1091             {
1092               log_error ("hashtable has invalid indirections.\n");
1093               return GPG_ERR_TRUSTDB;
1094             }
1095           goto next_level;
1096         }
1097       else if (rec.rectype == RECTYPE_HLST) /* Extend the list.  */
1098         {
1099           /* Check whether the key is already in this list. */
1100           for (;;)
1101             {
1102               for (i=0; i < ITEMS_PER_HLST_RECORD; i++)
1103                 {
1104                   if (rec.r.hlst.rnum[i] == newrecnum)
1105                     {
1106                       return 0; /* Okay, already in the list.  */
1107                     }
1108                 }
1109               if (rec.r.hlst.next)
1110                 {
1111                   rc = tdbio_read_record (rec.r.hlst.next, &rec, RECTYPE_HLST);
1112                   if (rc)
1113                     {
1114                       log_error ("upd_hashtable: read hlst failed: %s\n",
1115                                  gpg_strerror (rc) );
1116                       return rc;
1117                     }
1118                 }
1119               else
1120                 break; /* key is not in the list */
1121             }
1122
1123           /* Find the next free entry and put it in.  */
1124           for (;;)
1125             {
1126               for (i=0; i < ITEMS_PER_HLST_RECORD; i++)
1127                 {
1128                   if (!rec.r.hlst.rnum[i])
1129                     {
1130                       /* Empty slot found.  */
1131                       rec.r.hlst.rnum[i] = newrecnum;
1132                       rc = tdbio_write_record (ctrl, &rec);
1133                       if (rc)
1134                         log_error ("upd_hashtable: write hlst failed: %s\n",
1135                                    gpg_strerror (rc));
1136                       return rc; /* Done.  */
1137                     }
1138                 }
1139
1140               if (rec.r.hlst.next)
1141                 {
1142                   /* read the next record of the list.  */
1143                   rc = tdbio_read_record (rec.r.hlst.next, &rec, RECTYPE_HLST);
1144                   if (rc)
1145                     {
1146                       log_error ("upd_hashtable: read hlst failed: %s\n",
1147                                  gpg_strerror (rc));
1148                       return rc;
1149                     }
1150                 }
1151               else
1152                 {
1153                   /* Append a new record to the list.  */
1154                   rec.r.hlst.next = item = tdbio_new_recnum (ctrl);
1155                   rc = tdbio_write_record (ctrl, &rec);
1156                   if (rc)
1157                     {
1158                       log_error ("upd_hashtable: write hlst failed: %s\n",
1159                                  gpg_strerror (rc));
1160                       return rc;
1161                     }
1162                   memset (&rec, 0, sizeof rec);
1163                   rec.rectype = RECTYPE_HLST;
1164                   rec.recnum = item;
1165                   rec.r.hlst.rnum[0] = newrecnum;
1166                   rc = tdbio_write_record (ctrl, &rec);
1167                   if (rc)
1168                     log_error ("upd_hashtable: write ext hlst failed: %s\n",
1169                                gpg_strerror (rc));
1170                   return rc; /* Done.  */
1171                 }
1172             } /* end loop over list slots */
1173
1174         }
1175       else if (rec.rectype == RECTYPE_TRUST) /* Insert a list record.  */
1176         {
1177           if (rec.recnum == newrecnum)
1178             {
1179               return 0;
1180             }
1181           item = rec.recnum; /* Save number of key record.  */
1182           memset (&rec, 0, sizeof rec);
1183           rec.rectype = RECTYPE_HLST;
1184           rec.recnum = tdbio_new_recnum (ctrl);
1185           rec.r.hlst.rnum[0] = item;        /* Old key record */
1186           rec.r.hlst.rnum[1] = newrecnum; /* and new key record */
1187           rc = tdbio_write_record (ctrl, &rec);
1188           if (rc)
1189             {
1190               log_error( "upd_hashtable: write new hlst failed: %s\n",
1191                            gpg_strerror (rc) );
1192               return rc;
1193             }
1194           /* Update the hashtable record.  */
1195           lastrec.r.htbl.item[msb % ITEMS_PER_HTBL_RECORD] = rec.recnum;
1196           rc = tdbio_write_record (ctrl, &lastrec);
1197           if (rc)
1198             log_error ("upd_hashtable: update htbl failed: %s\n",
1199                        gpg_strerror (rc));
1200           return rc; /* Ready.  */
1201         }
1202       else
1203         {
1204           log_error ("hashtbl %lu: %lu/%d points to an invalid record %lu\n",
1205                      table, hashrec, (msb % ITEMS_PER_HTBL_RECORD), item);
1206           if (opt.verbose > 1)
1207             list_trustdb (ctrl, es_stderr, NULL);
1208           return GPG_ERR_TRUSTDB;
1209         }
1210     }
1211
1212   return 0;
1213 }
1214
1215
1216 /*
1217  * Drop an entry from a hashtable.  TABLE gives the start of the
1218  * table, KEY and KEYLEN are the key.
1219  *
1220  * Return: 0 on success or an error code.
1221  */
1222 static int
1223 drop_from_hashtable (ctrl_t ctrl, ulong table,
1224                      byte *key, int keylen, ulong recnum)
1225 {
1226   TRUSTREC rec;
1227   ulong hashrec, item;
1228   int msb;
1229   int level = 0;
1230   int rc, i;
1231
1232   hashrec = table;
1233  next_level:
1234   msb = key[level];
1235   hashrec += msb / ITEMS_PER_HTBL_RECORD;
1236   rc = tdbio_read_record (hashrec, &rec, RECTYPE_HTBL );
1237   if (rc)
1238     {
1239       log_error ("drop_from_hashtable: read failed: %s\n", gpg_strerror (rc));
1240       return rc;
1241     }
1242
1243   item = rec.r.htbl.item[msb % ITEMS_PER_HTBL_RECORD];
1244   if (!item)
1245     return 0;   /* Not found - forget about it.  */
1246
1247   if (item == recnum) /* Table points direct to the record.  */
1248     {
1249       rec.r.htbl.item[msb % ITEMS_PER_HTBL_RECORD] = 0;
1250       rc = tdbio_write_record (ctrl, &rec);
1251       if (rc)
1252         log_error ("drop_from_hashtable: write htbl failed: %s\n",
1253                    gpg_strerror (rc));
1254       return rc;
1255     }
1256
1257   rc = tdbio_read_record (item, &rec, 0);
1258   if (rc)
1259     {
1260       log_error ("drop_from_hashtable: read item failed: %s\n",
1261                  gpg_strerror (rc));
1262       return rc;
1263     }
1264
1265   if (rec.rectype == RECTYPE_HTBL)
1266     {
1267       hashrec = item;
1268       level++;
1269       if (level >= keylen)
1270         {
1271           log_error ("hashtable has invalid indirections.\n");
1272           return GPG_ERR_TRUSTDB;
1273         }
1274       goto next_level;
1275     }
1276
1277   if (rec.rectype == RECTYPE_HLST)
1278     {
1279       for (;;)
1280         {
1281           for (i=0; i < ITEMS_PER_HLST_RECORD; i++)
1282             {
1283               if (rec.r.hlst.rnum[i] == recnum)
1284                 {
1285                   rec.r.hlst.rnum[i] = 0; /* Mark as free.  */
1286                   rc = tdbio_write_record (ctrl, &rec);
1287                   if (rc)
1288                     log_error("drop_from_hashtable: write htbl failed: %s\n",
1289                               gpg_strerror (rc));
1290                   return rc;
1291                 }
1292             }
1293           if (rec.r.hlst.next)
1294             {
1295               rc = tdbio_read_record (rec.r.hlst.next, &rec, RECTYPE_HLST);
1296               if (rc)
1297                 {
1298                   log_error ("drop_from_hashtable: read hlst failed: %s\n",
1299                              gpg_strerror (rc));
1300                   return rc;
1301                 }
1302             }
1303           else
1304             return 0; /* Key not in table.  */
1305         }
1306     }
1307
1308   log_error ("hashtbl %lu: %lu/%d points to wrong record %lu\n",
1309              table, hashrec, (msb % ITEMS_PER_HTBL_RECORD), item);
1310   return GPG_ERR_TRUSTDB;
1311 }
1312
1313
1314
1315 /*
1316  * Lookup a record via the hashtable TABLE by (KEY,KEYLEN) and return
1317  * the result in REC.  The return value of CMP() should be True if the
1318  * record is the desired one.
1319  *
1320  * Return: 0 if found, GPG_ERR_NOT_FOUND, or another error code.
1321  */
1322 static gpg_error_t
1323 lookup_hashtable (ulong table, const byte *key, size_t keylen,
1324                   int (*cmpfnc)(const void*, const TRUSTREC *),
1325                   const void *cmpdata, TRUSTREC *rec )
1326 {
1327   int rc;
1328   ulong hashrec, item;
1329   int msb;
1330   int level = 0;
1331
1332   if (!table)
1333     {
1334       rc = gpg_error (GPG_ERR_INV_RECORD);
1335       log_error("lookup_hashtable failed: %s\n", "request for record 0");
1336       return rc;
1337     }
1338
1339   hashrec = table;
1340  next_level:
1341   msb = key[level];
1342   hashrec += msb / ITEMS_PER_HTBL_RECORD;
1343   rc = tdbio_read_record (hashrec, rec, RECTYPE_HTBL);
1344   if (rc)
1345     {
1346       log_error("lookup_hashtable failed: %s\n", gpg_strerror (rc) );
1347       return rc;
1348     }
1349
1350   item = rec->r.htbl.item[msb % ITEMS_PER_HTBL_RECORD];
1351   if (!item)
1352     return gpg_error (GPG_ERR_NOT_FOUND);
1353
1354   rc = tdbio_read_record (item, rec, 0);
1355   if (rc)
1356     {
1357       log_error( "hashtable read failed: %s\n", gpg_strerror (rc) );
1358       return rc;
1359     }
1360   if (rec->rectype == RECTYPE_HTBL)
1361     {
1362       hashrec = item;
1363       level++;
1364       if (level >= keylen)
1365         {
1366           log_error ("hashtable has invalid indirections\n");
1367           return GPG_ERR_TRUSTDB;
1368         }
1369       goto next_level;
1370     }
1371   else if (rec->rectype == RECTYPE_HLST)
1372     {
1373       for (;;)
1374         {
1375           int i;
1376
1377           for (i=0; i < ITEMS_PER_HLST_RECORD; i++)
1378             {
1379               if (rec->r.hlst.rnum[i])
1380                 {
1381                   TRUSTREC tmp;
1382
1383                   rc = tdbio_read_record (rec->r.hlst.rnum[i], &tmp, 0);
1384                   if (rc)
1385                     {
1386                       log_error ("lookup_hashtable: read item failed: %s\n",
1387                                  gpg_strerror (rc));
1388                       return rc;
1389                     }
1390                   if ((*cmpfnc)(cmpdata, &tmp))
1391                     {
1392                       *rec = tmp;
1393                       return 0;
1394                     }
1395                 }
1396             }
1397           if (rec->r.hlst.next)
1398             {
1399               rc = tdbio_read_record (rec->r.hlst.next, rec, RECTYPE_HLST);
1400               if (rc)
1401                 {
1402                   log_error ("lookup_hashtable: read hlst failed: %s\n",
1403                              gpg_strerror (rc) );
1404                   return rc;
1405                 }
1406             }
1407           else
1408             return gpg_error (GPG_ERR_NOT_FOUND);
1409         }
1410     }
1411
1412   if ((*cmpfnc)(cmpdata, rec))
1413     return 0; /* really found */
1414
1415   return gpg_error (GPG_ERR_NOT_FOUND); /* no: not found */
1416 }
1417
1418
1419 /*
1420  * Update the trust hash table TR or create the table if it does not
1421  * exist.
1422  *
1423  * Return: 0 on success or an error code.
1424  */
1425 static int
1426 update_trusthashtbl (ctrl_t ctrl, TRUSTREC *tr)
1427 {
1428   return upd_hashtable (ctrl, get_trusthashrec (ctrl),
1429                         tr->r.trust.fingerprint, 20, tr->recnum);
1430 }
1431
1432
1433 /*
1434  * Dump the trustdb record REC to stream FP.
1435  */
1436 void
1437 tdbio_dump_record (TRUSTREC *rec, estream_t fp)
1438 {
1439   int i;
1440   ulong rnum = rec->recnum;
1441
1442   es_fprintf (fp, "rec %5lu, ", rnum);
1443
1444   switch (rec->rectype)
1445     {
1446     case 0:
1447       es_fprintf (fp, "blank\n");
1448       break;
1449
1450     case RECTYPE_VER:
1451       es_fprintf (fp,
1452          "version, td=%lu, f=%lu, m/c/d=%d/%d/%d tm=%d mcl=%d nc=%lu (%s)\n",
1453                   rec->r.ver.trusthashtbl,
1454                   rec->r.ver.firstfree,
1455                   rec->r.ver.marginals,
1456                   rec->r.ver.completes,
1457                   rec->r.ver.cert_depth,
1458                   rec->r.ver.trust_model,
1459                   rec->r.ver.min_cert_level,
1460                   rec->r.ver.nextcheck,
1461                   strtimestamp(rec->r.ver.nextcheck)
1462                   );
1463       break;
1464
1465     case RECTYPE_FREE:
1466       es_fprintf (fp, "free, next=%lu\n", rec->r.free.next);
1467       break;
1468
1469     case RECTYPE_HTBL:
1470       es_fprintf (fp, "htbl,");
1471       for (i=0; i < ITEMS_PER_HTBL_RECORD; i++)
1472         es_fprintf (fp, " %lu", rec->r.htbl.item[i]);
1473       es_putc ('\n', fp);
1474       break;
1475
1476     case RECTYPE_HLST:
1477       es_fprintf (fp, "hlst, next=%lu,", rec->r.hlst.next);
1478       for (i=0; i < ITEMS_PER_HLST_RECORD; i++)
1479         es_fprintf (fp, " %lu", rec->r.hlst.rnum[i]);
1480       es_putc ('\n', fp);
1481       break;
1482
1483     case RECTYPE_TRUST:
1484       es_fprintf (fp, "trust ");
1485       for (i=0; i < 20; i++)
1486         es_fprintf (fp, "%02X", rec->r.trust.fingerprint[i]);
1487       es_fprintf (fp, ", ot=%d, d=%d, vl=%lu\n", rec->r.trust.ownertrust,
1488                   rec->r.trust.depth, rec->r.trust.validlist);
1489       break;
1490
1491     case RECTYPE_VALID:
1492       es_fprintf (fp, "valid ");
1493       for (i=0; i < 20; i++)
1494         es_fprintf(fp, "%02X", rec->r.valid.namehash[i]);
1495       es_fprintf (fp, ", v=%d, next=%lu\n", rec->r.valid.validity,
1496                   rec->r.valid.next);
1497       break;
1498
1499     default:
1500       es_fprintf (fp, "unknown type %d\n", rec->rectype );
1501       break;
1502     }
1503 }
1504
1505
1506 /*
1507  * Read the record with number RECNUM into the structure REC.  If
1508  * EXPECTED is not 0 reading any other record type will return an
1509  * error.
1510  *
1511  * Return: 0 on success or an error code.
1512  */
1513 int
1514 tdbio_read_record (ulong recnum, TRUSTREC *rec, int expected)
1515 {
1516   byte readbuf[TRUST_RECORD_LEN];
1517   const byte *buf, *p;
1518   gpg_error_t err = 0;
1519   int n, i;
1520
1521   if (db_fd == -1)
1522     open_db ();
1523
1524   buf = get_record_from_cache( recnum );
1525   if (!buf)
1526     {
1527       if (lseek (db_fd, recnum * TRUST_RECORD_LEN, SEEK_SET) == -1)
1528         {
1529           err = gpg_error_from_syserror ();
1530           log_error (_("trustdb: lseek failed: %s\n"), strerror (errno));
1531           return err;
1532         }
1533       n = read (db_fd, readbuf, TRUST_RECORD_LEN);
1534       if (!n)
1535         {
1536           return gpg_error (GPG_ERR_EOF);
1537         }
1538       else if (n != TRUST_RECORD_LEN)
1539         {
1540           err = gpg_error_from_syserror ();
1541           log_error (_("trustdb: read failed (n=%d): %s\n"),
1542                      n, strerror(errno));
1543           return err;
1544         }
1545       buf = readbuf;
1546     }
1547   rec->recnum = recnum;
1548   rec->dirty = 0;
1549   p = buf;
1550   rec->rectype = *p++;
1551   if (expected && rec->rectype != expected)
1552     {
1553       log_error ("%lu: read expected rec type %d, got %d\n",
1554                  recnum, expected, rec->rectype);
1555       return gpg_error (GPG_ERR_TRUSTDB);
1556     }
1557   p++;    /* Skip reserved byte.  */
1558   switch (rec->rectype)
1559     {
1560     case 0:  /* unused (free) record */
1561       break;
1562
1563     case RECTYPE_VER: /* version record */
1564       if (memcmp(buf+1, GPGEXT_GPG, 3))
1565         {
1566           log_error (_("%s: not a trustdb file\n"), db_name );
1567           err = gpg_error (GPG_ERR_TRUSTDB);
1568         }
1569       else
1570         {
1571           p += 2; /* skip "gpg" */
1572           rec->r.ver.version  = *p++;
1573           rec->r.ver.marginals = *p++;
1574           rec->r.ver.completes = *p++;
1575           rec->r.ver.cert_depth = *p++;
1576           rec->r.ver.trust_model = *p++;
1577           rec->r.ver.min_cert_level = *p++;
1578           p += 2;
1579           rec->r.ver.created  = buf32_to_ulong(p);
1580           p += 4;
1581           rec->r.ver.nextcheck = buf32_to_ulong(p);
1582           p += 4;
1583           p += 4;
1584           p += 4;
1585           rec->r.ver.firstfree = buf32_to_ulong(p);
1586           p += 4;
1587           p += 4;
1588           rec->r.ver.trusthashtbl = buf32_to_ulong(p);
1589           if (recnum)
1590             {
1591               log_error( _("%s: version record with recnum %lu\n"), db_name,
1592                          (ulong)recnum );
1593               err = gpg_error (GPG_ERR_TRUSTDB);
1594             }
1595           else if (rec->r.ver.version != 3)
1596             {
1597               log_error( _("%s: invalid file version %d\n"), db_name,
1598                          rec->r.ver.version );
1599               err = gpg_error (GPG_ERR_TRUSTDB);
1600             }
1601         }
1602       break;
1603
1604     case RECTYPE_FREE:
1605       rec->r.free.next  = buf32_to_ulong(p);
1606       break;
1607
1608     case RECTYPE_HTBL:
1609       for (i=0; i < ITEMS_PER_HTBL_RECORD; i++)
1610         {
1611           rec->r.htbl.item[i] = buf32_to_ulong(p);
1612           p += 4;
1613         }
1614       break;
1615
1616     case RECTYPE_HLST:
1617       rec->r.hlst.next = buf32_to_ulong(p);
1618       p += 4;
1619       for (i=0; i < ITEMS_PER_HLST_RECORD; i++)
1620         {
1621           rec->r.hlst.rnum[i] = buf32_to_ulong(p);
1622           p += 4;
1623         }
1624       break;
1625
1626     case RECTYPE_TRUST:
1627       memcpy (rec->r.trust.fingerprint, p, 20);
1628       p+=20;
1629       rec->r.trust.ownertrust = *p++;
1630       rec->r.trust.depth = *p++;
1631       rec->r.trust.min_ownertrust = *p++;
1632       p++;
1633       rec->r.trust.validlist = buf32_to_ulong(p);
1634       break;
1635
1636     case RECTYPE_VALID:
1637       memcpy (rec->r.valid.namehash, p, 20);
1638       p+=20;
1639       rec->r.valid.validity = *p++;
1640       rec->r.valid.next = buf32_to_ulong(p);
1641       p += 4;
1642       rec->r.valid.full_count = *p++;
1643       rec->r.valid.marginal_count = *p++;
1644       break;
1645
1646     default:
1647       log_error ("%s: invalid record type %d at recnum %lu\n",
1648                  db_name, rec->rectype, (ulong)recnum);
1649       err = gpg_error (GPG_ERR_TRUSTDB);
1650       break;
1651     }
1652
1653   return err;
1654 }
1655
1656
1657 /*
1658  * Write the record from the struct REC.
1659  *
1660  * Return: 0 on success or an error code.
1661  */
1662 int
1663 tdbio_write_record (ctrl_t ctrl, TRUSTREC *rec)
1664 {
1665   byte buf[TRUST_RECORD_LEN];
1666   byte *p;
1667   int rc = 0;
1668   int i;
1669   ulong recnum = rec->recnum;
1670
1671   if (db_fd == -1)
1672     open_db ();
1673
1674   memset (buf, 0, TRUST_RECORD_LEN);
1675   p = buf;
1676   *p++ = rec->rectype; p++;
1677
1678   switch (rec->rectype)
1679     {
1680     case 0:  /* unused record */
1681       break;
1682
1683     case RECTYPE_VER: /* version record */
1684       if (recnum)
1685         BUG ();
1686       memcpy(p-1, GPGEXT_GPG, 3 ); p += 2;
1687       *p++ = rec->r.ver.version;
1688       *p++ = rec->r.ver.marginals;
1689       *p++ = rec->r.ver.completes;
1690       *p++ = rec->r.ver.cert_depth;
1691       *p++ = rec->r.ver.trust_model;
1692       *p++ = rec->r.ver.min_cert_level;
1693       p += 2;
1694       ulongtobuf(p, rec->r.ver.created); p += 4;
1695       ulongtobuf(p, rec->r.ver.nextcheck); p += 4;
1696       p += 4;
1697       p += 4;
1698       ulongtobuf(p, rec->r.ver.firstfree ); p += 4;
1699       p += 4;
1700       ulongtobuf(p, rec->r.ver.trusthashtbl ); p += 4;
1701       break;
1702
1703     case RECTYPE_FREE:
1704       ulongtobuf(p, rec->r.free.next); p += 4;
1705       break;
1706
1707     case RECTYPE_HTBL:
1708       for (i=0; i < ITEMS_PER_HTBL_RECORD; i++)
1709         {
1710           ulongtobuf( p, rec->r.htbl.item[i]); p += 4;
1711         }
1712       break;
1713
1714     case RECTYPE_HLST:
1715       ulongtobuf( p, rec->r.hlst.next); p += 4;
1716       for (i=0; i < ITEMS_PER_HLST_RECORD; i++ )
1717         {
1718           ulongtobuf( p, rec->r.hlst.rnum[i]); p += 4;
1719         }
1720       break;
1721
1722     case RECTYPE_TRUST:
1723       memcpy (p, rec->r.trust.fingerprint, 20); p += 20;
1724       *p++ = rec->r.trust.ownertrust;
1725       *p++ = rec->r.trust.depth;
1726       *p++ = rec->r.trust.min_ownertrust;
1727       p++;
1728       ulongtobuf( p, rec->r.trust.validlist); p += 4;
1729       break;
1730
1731     case RECTYPE_VALID:
1732       memcpy (p, rec->r.valid.namehash, 20); p += 20;
1733       *p++ = rec->r.valid.validity;
1734       ulongtobuf( p, rec->r.valid.next); p += 4;
1735       *p++ = rec->r.valid.full_count;
1736       *p++ = rec->r.valid.marginal_count;
1737       break;
1738
1739     default:
1740       BUG();
1741     }
1742
1743   rc = put_record_into_cache (recnum, buf);
1744   if (rc)
1745     ;
1746   else if (rec->rectype == RECTYPE_TRUST)
1747     rc = update_trusthashtbl (ctrl, rec);
1748
1749   return rc;
1750 }
1751
1752
1753 /*
1754  * Delete the record at record number RECNUm from the trustdb.
1755  *
1756  * Return: 0 on success or an error code.
1757  */
1758 int
1759 tdbio_delete_record (ctrl_t ctrl, ulong recnum)
1760 {
1761   TRUSTREC vr, rec;
1762   int rc;
1763
1764   /* Must read the record fist, so we can drop it from the hash tables */
1765   rc = tdbio_read_record (recnum, &rec, 0);
1766   if (rc)
1767     ;
1768   else if (rec.rectype == RECTYPE_TRUST)
1769     {
1770       rc = drop_from_hashtable (ctrl, get_trusthashrec (ctrl),
1771                                 rec.r.trust.fingerprint, 20, rec.recnum);
1772     }
1773
1774   if (rc)
1775     return rc;
1776
1777   /* Now we can change it to a free record.  */
1778   rc = tdbio_read_record (0, &vr, RECTYPE_VER);
1779   if (rc)
1780     log_fatal (_("%s: error reading version record: %s\n"),
1781                db_name, gpg_strerror (rc));
1782
1783   rec.recnum = recnum;
1784   rec.rectype = RECTYPE_FREE;
1785   rec.r.free.next = vr.r.ver.firstfree;
1786   vr.r.ver.firstfree = recnum;
1787   rc = tdbio_write_record (ctrl, &rec);
1788   if (!rc)
1789     rc = tdbio_write_record (ctrl, &vr);
1790
1791   return rc;
1792 }
1793
1794
1795 /*
1796  * Create a new record and return its record number.
1797  */
1798 ulong
1799 tdbio_new_recnum (ctrl_t ctrl)
1800 {
1801   off_t offset;
1802   ulong recnum;
1803   TRUSTREC vr, rec;
1804   int rc;
1805
1806   /* Look for unused records.  */
1807   rc = tdbio_read_record (0, &vr, RECTYPE_VER);
1808   if (rc)
1809     log_fatal( _("%s: error reading version record: %s\n"),
1810                db_name, gpg_strerror (rc));
1811   if (vr.r.ver.firstfree)
1812     {
1813       recnum = vr.r.ver.firstfree;
1814       rc = tdbio_read_record (recnum, &rec, RECTYPE_FREE);
1815       if (rc)
1816         log_fatal (_("%s: error reading free record: %s\n"),
1817                    db_name, gpg_strerror (rc));
1818       /* Update dir record.  */
1819       vr.r.ver.firstfree = rec.r.free.next;
1820       rc = tdbio_write_record (ctrl, &vr);
1821       if (rc)
1822         log_fatal (_("%s: error writing dir record: %s\n"),
1823                    db_name, gpg_strerror (rc));
1824       /* Zero out the new record.  */
1825       memset (&rec, 0, sizeof rec);
1826       rec.rectype = 0; /* Mark as unused record (actually already done
1827                           my the memset).  */
1828       rec.recnum = recnum;
1829       rc = tdbio_write_record (ctrl, &rec);
1830       if (rc)
1831         log_fatal (_("%s: failed to zero a record: %s\n"),
1832                    db_name, gpg_strerror (rc));
1833     }
1834   else /* Not found - append a new record.  */
1835     {
1836       offset = lseek (db_fd, 0, SEEK_END);
1837       if (offset == (off_t)(-1))
1838         log_fatal ("trustdb: lseek to end failed: %s\n", strerror (errno));
1839       recnum = offset / TRUST_RECORD_LEN;
1840       log_assert (recnum); /* This will never be the first record */
1841       /* We must write a record, so that the next call to this
1842        * function returns another recnum.  */
1843       memset (&rec, 0, sizeof rec);
1844       rec.rectype = 0; /* unused record */
1845       rec.recnum = recnum;
1846       rc = 0;
1847       if (lseek( db_fd, recnum * TRUST_RECORD_LEN, SEEK_SET) == -1)
1848         {
1849           rc = gpg_error_from_syserror ();
1850           log_error (_("trustdb rec %lu: lseek failed: %s\n"),
1851                      recnum, strerror (errno));
1852         }
1853       else
1854         {
1855           int n;
1856
1857           n = write (db_fd, &rec, TRUST_RECORD_LEN);
1858           if (n != TRUST_RECORD_LEN)
1859             {
1860               rc = gpg_error_from_syserror ();
1861               log_error (_("trustdb rec %lu: write failed (n=%d): %s\n"),
1862                          recnum, n, gpg_strerror (rc));
1863             }
1864         }
1865
1866       if (rc)
1867         log_fatal (_("%s: failed to append a record: %s\n"),
1868                    db_name, gpg_strerror (rc));
1869     }
1870
1871   return recnum ;
1872 }
1873
1874
1875
1876 /* Helper function for tdbio_search_trust_byfpr.  */
1877 static int
1878 cmp_trec_fpr ( const void *fpr, const TRUSTREC *rec )
1879 {
1880   return (rec->rectype == RECTYPE_TRUST
1881           && !memcmp (rec->r.trust.fingerprint, fpr, 20));
1882 }
1883
1884
1885 /*
1886  * Given a 20 byte FINGERPRINT search its trust record and return
1887  * that at REC.
1888  *
1889  * Return: 0 if found, GPG_ERR_NOT_FOUND, or another error code.
1890  */
1891 gpg_error_t
1892 tdbio_search_trust_byfpr (ctrl_t ctrl, const byte *fingerprint, TRUSTREC *rec)
1893 {
1894   int rc;
1895
1896   /* Locate the trust record using the hash table */
1897   rc = lookup_hashtable (get_trusthashrec (ctrl), fingerprint, 20,
1898                          cmp_trec_fpr, fingerprint, rec );
1899   return rc;
1900 }
1901
1902
1903 /*
1904  * Given a primary public key object PK search its trust record and
1905  * return that at REC.
1906  *
1907  * Return: 0 if found, GPG_ERR_NOT_FOUND, or another error code.
1908  */
1909 gpg_error_t
1910 tdbio_search_trust_bypk (ctrl_t ctrl, PKT_public_key *pk, TRUSTREC *rec)
1911 {
1912   byte fingerprint[MAX_FINGERPRINT_LEN];
1913   size_t fingerlen;
1914
1915   fingerprint_from_pk( pk, fingerprint, &fingerlen );
1916   for (; fingerlen < 20; fingerlen++)
1917     fingerprint[fingerlen] = 0;
1918   return tdbio_search_trust_byfpr (ctrl, fingerprint, rec);
1919 }
1920
1921
1922 /*
1923  * Terminate the process with a message about a corrupted trustdb.
1924  */
1925 void
1926 tdbio_invalid (void)
1927 {
1928   log_error (_("Error: The trustdb is corrupted.\n"));
1929   how_to_fix_the_trustdb ();
1930   g10_exit (2);
1931 }