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