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