gpg: New option --key-origin.
[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;
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.  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 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 (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       log_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 immediately 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 (ctrl_t ctrl)
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 (ctrl, &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 (ctrl_t ctrl)
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 (ctrl, &rec);
586
587   if (!rc)
588     tdbio_sync ();
589
590   if (!rc)
591     create_hashtable (ctrl, &rec, 0);
592
593   return rc;
594 }
595
596
597 /*
598  * Set the file name for the trustdb to NEW_DBNAME and if CREATE is
599  * true create that file.  If NEW_DBNAME is NULL a default name is
600  * used, if the it does not contain a path component separator ('/')
601  * the global GnuPG home directory is used.
602  *
603  * Returns: 0 on success or an error code.
604  *
605  * On the first call this function registers an atexit handler.
606  *
607  */
608 int
609 tdbio_set_dbname (ctrl_t ctrl, const char *new_dbname,
610                   int create, int *r_nofile)
611 {
612   char *fname, *p;
613   struct stat statbuf;
614   static int initialized = 0;
615   int save_slash;
616
617   if (!initialized)
618     {
619       atexit (cleanup);
620       initialized = 1;
621     }
622
623   *r_nofile = 0;
624
625   if (!new_dbname)
626     {
627       fname = make_filename (gnupg_homedir (),
628                              "trustdb" EXTSEP_S GPGEXT_GPG, NULL);
629     }
630   else if (*new_dbname != DIRSEP_C )
631     {
632       if (strchr (new_dbname, DIRSEP_C))
633         fname = make_filename (new_dbname, NULL);
634       else
635         fname = make_filename (gnupg_homedir (), new_dbname, NULL);
636     }
637   else
638     {
639       fname = xstrdup (new_dbname);
640     }
641
642   xfree (db_name);
643   db_name = fname;
644
645   /* Quick check for (likely) case where there already is a
646    * trustdb.gpg.  This check is not required in theory, but it helps
647    * in practice avoiding costly operations of preparing and taking
648    * the lock.  */
649   if (!stat (fname, &statbuf) && statbuf.st_size > 0)
650     {
651       /* OK, we have the valid trustdb.gpg already.  */
652       return 0;
653     }
654   else if (!create)
655     {
656       *r_nofile = 1;
657       return 0;
658     }
659
660   /* Here comes: No valid trustdb.gpg AND CREATE==1 */
661
662   /*
663    * Make sure the directory exists.  This should be done before
664    * acquiring the lock, which assumes the existence of the directory.
665    */
666   p = strrchr (fname, DIRSEP_C);
667 #if HAVE_W32_SYSTEM
668   {
669     /* Windows may either have a slash or a backslash.  Take
670        care of it.  */
671     char *pp = strrchr (fname, '/');
672     if (!p || pp > p)
673       p = pp;
674   }
675 #endif /*HAVE_W32_SYSTEM*/
676   log_assert (p);
677   save_slash = *p;
678   *p = 0;
679   if (access (fname, F_OK))
680     {
681       try_make_homedir (fname);
682       if (access (fname, F_OK))
683         log_fatal (_("%s: directory does not exist!\n"), fname);
684     }
685   *p = save_slash;
686
687   take_write_lock ();
688
689   if (access (fname, R_OK) || stat (fname, &statbuf) || statbuf.st_size == 0)
690     {
691       FILE *fp;
692       TRUSTREC rec;
693       int rc;
694       mode_t oldmask;
695
696 #ifdef HAVE_W32CE_SYSTEM
697       /* We know how the cegcc implementation of access works ;-). */
698       if (GetLastError () == ERROR_FILE_NOT_FOUND)
699         gpg_err_set_errno (ENOENT);
700       else
701         gpg_err_set_errno (EIO);
702 #endif /*HAVE_W32CE_SYSTEM*/
703       if (errno && errno != ENOENT)
704         log_fatal ( _("can't access '%s': %s\n"), fname, strerror (errno));
705
706       oldmask = umask (077);
707       if (is_secured_filename (fname))
708         {
709           fp = NULL;
710           gpg_err_set_errno (EPERM);
711         }
712       else
713         fp = fopen (fname, "wb");
714       umask(oldmask);
715       if (!fp)
716         log_fatal (_("can't create '%s': %s\n"), fname, strerror (errno));
717       fclose (fp);
718
719       db_fd = open (db_name, O_RDWR | MY_O_BINARY);
720       if (db_fd == -1)
721         log_fatal (_("can't open '%s': %s\n"), db_name, strerror (errno));
722
723       rc = create_version_record (ctrl);
724       if (rc)
725         log_fatal (_("%s: failed to create version record: %s"),
726                    fname, gpg_strerror (rc));
727
728       /* Read again to check that we are okay. */
729       if (tdbio_read_record (0, &rec, RECTYPE_VER))
730         log_fatal (_("%s: invalid trustdb created\n"), db_name);
731
732       if (!opt.quiet)
733         log_info (_("%s: trustdb created\n"), db_name);
734     }
735
736   release_write_lock ();
737   return 0;
738 }
739
740
741 /*
742  * Return the full name of the trustdb.
743  */
744 const char *
745 tdbio_get_dbname ()
746 {
747   return db_name;
748 }
749
750
751 /*
752  * Open the trustdb.  This may only be called if it has not yet been
753  * opened and after a successful call to tdbio_set_dbname.  On return
754  * the trustdb handle (DB_FD) is guaranteed to be open.
755  */
756 static void
757 open_db ()
758 {
759   TRUSTREC rec;
760
761   log_assert( db_fd == -1 );
762
763 #ifdef HAVE_W32CE_SYSTEM
764   {
765     DWORD prevrc = 0;
766     wchar_t *wname = utf8_to_wchar (db_name);
767     if (wname)
768       {
769         db_fd = (int)CreateFile (wname, GENERIC_READ|GENERIC_WRITE,
770                                  FILE_SHARE_READ|FILE_SHARE_WRITE, NULL,
771                                  OPEN_EXISTING, 0, NULL);
772         xfree (wname);
773       }
774     if (db_fd == -1)
775       log_fatal ("can't open '%s': %d, %d\n", db_name,
776                  (int)prevrc, (int)GetLastError ());
777   }
778 #else /*!HAVE_W32CE_SYSTEM*/
779   db_fd = open (db_name, O_RDWR | MY_O_BINARY );
780   if (db_fd == -1 && (errno == EACCES
781 #ifdef EROFS
782                       || errno == EROFS
783 #endif
784                       )
785       ) {
786       /* Take care of read-only trustdbs.  */
787       db_fd = open (db_name, O_RDONLY | MY_O_BINARY );
788       if (db_fd != -1 && !opt.quiet)
789           log_info (_("Note: trustdb not writable\n"));
790   }
791   if ( db_fd == -1 )
792     log_fatal( _("can't open '%s': %s\n"), db_name, strerror(errno) );
793 #endif /*!HAVE_W32CE_SYSTEM*/
794   register_secured_file (db_name);
795
796   /* Read the version record. */
797   if (tdbio_read_record (0, &rec, RECTYPE_VER ) )
798     log_fatal( _("%s: invalid trustdb\n"), db_name );
799 }
800
801
802 /*
803  * Append a new empty hashtable to the trustdb.  TYPE gives the type
804  * of the hash table.  The only defined type is 0 for a trust hash.
805  * On return the hashtable has been created, written, the version
806  * record update, and the data flushed to the disk.  On a fatal error
807  * the function terminates the process.
808  */
809 static void
810 create_hashtable (ctrl_t ctrl, TRUSTREC *vr, int type)
811 {
812   TRUSTREC rec;
813   off_t offset;
814   ulong recnum;
815   int i, n, rc;
816
817   offset = lseek (db_fd, 0, SEEK_END);
818   if (offset == -1)
819     log_fatal ("trustdb: lseek to end failed: %s\n", strerror(errno));
820   recnum = offset / TRUST_RECORD_LEN;
821   log_assert (recnum); /* This is will never be the first record. */
822
823   if (!type)
824     vr->r.ver.trusthashtbl = recnum;
825
826   /* Now write the records making up the hash table. */
827   n = (256+ITEMS_PER_HTBL_RECORD-1) / ITEMS_PER_HTBL_RECORD;
828   for (i=0; i < n; i++, recnum++)
829     {
830       memset (&rec, 0, sizeof rec);
831       rec.rectype = RECTYPE_HTBL;
832       rec.recnum = recnum;
833       rc = tdbio_write_record (ctrl, &rec);
834       if (rc)
835         log_fatal (_("%s: failed to create hashtable: %s\n"),
836                    db_name, gpg_strerror (rc));
837     }
838   /* Update the version record and flush. */
839   rc = tdbio_write_record (ctrl, vr);
840   if (!rc)
841     rc = tdbio_sync ();
842   if (rc)
843     log_fatal (_("%s: error updating version record: %s\n"),
844                db_name, gpg_strerror (rc));
845 }
846
847
848 /*
849  * Check whether open trustdb matches the global trust options given
850  * for this process.  On a read problem the process is terminated.
851  *
852  * Return: 1 for yes, 0 for no.
853  */
854 int
855 tdbio_db_matches_options()
856 {
857   static int yes_no = -1;
858
859   if (yes_no == -1)
860     {
861       TRUSTREC vr;
862       int rc;
863
864       rc = tdbio_read_record (0, &vr, RECTYPE_VER);
865       if( rc )
866         log_fatal( _("%s: error reading version record: %s\n"),
867                    db_name, gpg_strerror (rc) );
868
869       yes_no = vr.r.ver.marginals == opt.marginals_needed
870         && vr.r.ver.completes == opt.completes_needed
871         && vr.r.ver.cert_depth == opt.max_cert_depth
872         && vr.r.ver.trust_model == opt.trust_model
873         && vr.r.ver.min_cert_level == opt.min_cert_level;
874     }
875
876   return yes_no;
877 }
878
879
880 /*
881  * Read and return the trust model identifier from the trustdb.  On a
882  * read problem the process is terminated.
883  */
884 byte
885 tdbio_read_model (void)
886 {
887   TRUSTREC vr;
888   int rc;
889
890   rc = tdbio_read_record (0, &vr, RECTYPE_VER );
891   if (rc)
892     log_fatal (_("%s: error reading version record: %s\n"),
893                db_name, gpg_strerror (rc) );
894   return vr.r.ver.trust_model;
895 }
896
897
898 /*
899  * Read and return the nextstamp value from the trustdb.  On a read
900  * problem the process is terminated.
901  */
902 ulong
903 tdbio_read_nextcheck ()
904 {
905   TRUSTREC vr;
906   int rc;
907
908   rc = tdbio_read_record (0, &vr, RECTYPE_VER);
909   if (rc)
910     log_fatal (_("%s: error reading version record: %s\n"),
911                db_name, gpg_strerror (rc));
912   return vr.r.ver.nextcheck;
913 }
914
915
916 /*
917  * Write the STAMP nextstamp timestamp to the trustdb.  On a read or
918  * write problem the process is terminated.
919  *
920  * Return: True if the stamp actually changed.
921  */
922 int
923 tdbio_write_nextcheck (ctrl_t ctrl, ulong stamp)
924 {
925   TRUSTREC vr;
926   int rc;
927
928   rc = tdbio_read_record (0, &vr, RECTYPE_VER);
929   if (rc)
930     log_fatal (_("%s: error reading version record: %s\n"),
931                db_name, gpg_strerror (rc));
932
933   if (vr.r.ver.nextcheck == stamp)
934     return 0;
935
936   vr.r.ver.nextcheck = stamp;
937   rc = tdbio_write_record (ctrl, &vr);
938   if (rc)
939     log_fatal (_("%s: error writing version record: %s\n"),
940                db_name, gpg_strerror (rc));
941   return 1;
942 }
943
944
945
946 /*
947  * Return the record number of the trusthash table or create one if it
948  * does not yet exist.  On a read or write problem the process is
949  * terminated.
950  *
951  * Return: record number
952  */
953 static ulong
954 get_trusthashrec(void)
955 {
956   static ulong trusthashtbl; /* Record number of the trust hashtable.  */
957
958   if (!trusthashtbl)
959     {
960       TRUSTREC vr;
961       int rc;
962
963       rc = tdbio_read_record (0, &vr, RECTYPE_VER );
964       if (rc)
965         log_fatal (_("%s: error reading version record: %s\n"),
966                    db_name, gpg_strerror (rc) );
967
968       trusthashtbl = vr.r.ver.trusthashtbl;
969     }
970
971   return trusthashtbl;
972 }
973
974
975
976 /*
977  * Update a hashtable in the trustdb.  TABLE gives the start of the
978  * table, KEY and KEYLEN are the key, NEWRECNUM is the record number
979  * to insert into the table.
980  *
981  * Return: 0 on success or an error code.
982  */
983 static int
984 upd_hashtable (ctrl_t ctrl, ulong table, byte *key, int keylen, ulong newrecnum)
985 {
986   TRUSTREC lastrec, rec;
987   ulong hashrec, item;
988   int msb;
989   int level = 0;
990   int rc, i;
991
992   hashrec = table;
993  next_level:
994   msb = key[level];
995   hashrec += msb / ITEMS_PER_HTBL_RECORD;
996   rc = tdbio_read_record (hashrec, &rec, RECTYPE_HTBL);
997   if (rc)
998     {
999       log_error ("upd_hashtable: read failed: %s\n", gpg_strerror (rc));
1000       return rc;
1001     }
1002
1003   item = rec.r.htbl.item[msb % ITEMS_PER_HTBL_RECORD];
1004   if (!item)  /* Insert a new item into the hash table.  */
1005     {
1006       rec.r.htbl.item[msb % ITEMS_PER_HTBL_RECORD] = newrecnum;
1007       rc = tdbio_write_record (ctrl, &rec);
1008       if (rc)
1009         {
1010           log_error ("upd_hashtable: write htbl failed: %s\n",
1011                      gpg_strerror (rc));
1012           return rc;
1013         }
1014     }
1015   else if (item != newrecnum) /* Must do an update.  */
1016     {
1017       lastrec = rec;
1018       rc = tdbio_read_record (item, &rec, 0);
1019       if (rc)
1020         {
1021           log_error ("upd_hashtable: read item failed: %s\n",
1022                      gpg_strerror (rc));
1023           return rc;
1024         }
1025
1026       if (rec.rectype == RECTYPE_HTBL)
1027         {
1028           hashrec = item;
1029           level++;
1030           if (level >= keylen)
1031             {
1032               log_error ("hashtable has invalid indirections.\n");
1033               return GPG_ERR_TRUSTDB;
1034             }
1035           goto next_level;
1036         }
1037       else if (rec.rectype == RECTYPE_HLST) /* Extend the list.  */
1038         {
1039           /* Check whether the key is already in this list. */
1040           for (;;)
1041             {
1042               for (i=0; i < ITEMS_PER_HLST_RECORD; i++)
1043                 {
1044                   if (rec.r.hlst.rnum[i] == newrecnum)
1045                     {
1046                       return 0; /* Okay, already in the list.  */
1047                     }
1048                 }
1049               if (rec.r.hlst.next)
1050                 {
1051                   rc = tdbio_read_record (rec.r.hlst.next, &rec, RECTYPE_HLST);
1052                   if (rc)
1053                     {
1054                       log_error ("upd_hashtable: read hlst failed: %s\n",
1055                                  gpg_strerror (rc) );
1056                       return rc;
1057                     }
1058                 }
1059               else
1060                 break; /* key is not in the list */
1061             }
1062
1063           /* Find the next free entry and put it in.  */
1064           for (;;)
1065             {
1066               for (i=0; i < ITEMS_PER_HLST_RECORD; i++)
1067                 {
1068                   if (!rec.r.hlst.rnum[i])
1069                     {
1070                       /* Empty slot found.  */
1071                       rec.r.hlst.rnum[i] = newrecnum;
1072                       rc = tdbio_write_record (ctrl, &rec);
1073                       if (rc)
1074                         log_error ("upd_hashtable: write hlst failed: %s\n",
1075                                    gpg_strerror (rc));
1076                       return rc; /* Done.  */
1077                     }
1078                 }
1079
1080               if (rec.r.hlst.next)
1081                 {
1082                   /* read the next reord of the list.  */
1083                   rc = tdbio_read_record (rec.r.hlst.next, &rec, RECTYPE_HLST);
1084                   if (rc)
1085                     {
1086                       log_error ("upd_hashtable: read hlst failed: %s\n",
1087                                  gpg_strerror (rc));
1088                       return rc;
1089                     }
1090                 }
1091               else
1092                 {
1093                   /* Append a new record to the list.  */
1094                   rec.r.hlst.next = item = tdbio_new_recnum (ctrl);
1095                   rc = tdbio_write_record (ctrl, &rec);
1096                   if (rc)
1097                     {
1098                       log_error ("upd_hashtable: write hlst failed: %s\n",
1099                                  gpg_strerror (rc));
1100                       return rc;
1101                     }
1102                   memset (&rec, 0, sizeof rec);
1103                   rec.rectype = RECTYPE_HLST;
1104                   rec.recnum = item;
1105                   rec.r.hlst.rnum[0] = newrecnum;
1106                   rc = tdbio_write_record (ctrl, &rec);
1107                   if (rc)
1108                     log_error ("upd_hashtable: write ext hlst failed: %s\n",
1109                                gpg_strerror (rc));
1110                   return rc; /* Done.  */
1111                 }
1112             } /* end loop over list slots */
1113
1114         }
1115       else if (rec.rectype == RECTYPE_TRUST) /* Insert a list record.  */
1116         {
1117           if (rec.recnum == newrecnum)
1118             {
1119               return 0;
1120             }
1121           item = rec.recnum; /* Save number of key record.  */
1122           memset (&rec, 0, sizeof rec);
1123           rec.rectype = RECTYPE_HLST;
1124           rec.recnum = tdbio_new_recnum (ctrl);
1125           rec.r.hlst.rnum[0] = item;        /* Old key record */
1126           rec.r.hlst.rnum[1] = newrecnum; /* and new key record */
1127           rc = tdbio_write_record (ctrl, &rec);
1128           if (rc)
1129             {
1130               log_error( "upd_hashtable: write new hlst failed: %s\n",
1131                            gpg_strerror (rc) );
1132               return rc;
1133             }
1134           /* Update the hashtable record.  */
1135           lastrec.r.htbl.item[msb % ITEMS_PER_HTBL_RECORD] = rec.recnum;
1136           rc = tdbio_write_record (ctrl, &lastrec);
1137           if (rc)
1138             log_error ("upd_hashtable: update htbl failed: %s\n",
1139                        gpg_strerror (rc));
1140           return rc; /* Ready.  */
1141         }
1142       else
1143         {
1144           log_error ("hashtbl %lu: %lu/%d points to an invalid record %lu\n",
1145                      table, hashrec, (msb % ITEMS_PER_HTBL_RECORD), item);
1146           if (opt.verbose > 1)
1147             list_trustdb (ctrl, es_stderr, NULL);
1148           return GPG_ERR_TRUSTDB;
1149         }
1150     }
1151
1152   return 0;
1153 }
1154
1155
1156 /*
1157  * Drop an entry from a hashtable.  TABLE gives the start of the
1158  * table, KEY and KEYLEN are the key.
1159  *
1160  * Return: 0 on success or an error code.
1161  */
1162 static int
1163 drop_from_hashtable (ctrl_t ctrl, ulong table,
1164                      byte *key, int keylen, ulong recnum)
1165 {
1166   TRUSTREC rec;
1167   ulong hashrec, item;
1168   int msb;
1169   int level = 0;
1170   int rc, i;
1171
1172   hashrec = table;
1173  next_level:
1174   msb = key[level];
1175   hashrec += msb / ITEMS_PER_HTBL_RECORD;
1176   rc = tdbio_read_record (hashrec, &rec, RECTYPE_HTBL );
1177   if (rc)
1178     {
1179       log_error ("drop_from_hashtable: read failed: %s\n", gpg_strerror (rc));
1180       return rc;
1181     }
1182
1183   item = rec.r.htbl.item[msb % ITEMS_PER_HTBL_RECORD];
1184   if (!item)
1185     return 0;   /* Not found - forget about it.  */
1186
1187   if (item == recnum) /* Table points direct to the record.  */
1188     {
1189       rec.r.htbl.item[msb % ITEMS_PER_HTBL_RECORD] = 0;
1190       rc = tdbio_write_record (ctrl, &rec);
1191       if (rc)
1192         log_error ("drop_from_hashtable: write htbl failed: %s\n",
1193                    gpg_strerror (rc));
1194       return rc;
1195     }
1196
1197   rc = tdbio_read_record (item, &rec, 0);
1198   if (rc)
1199     {
1200       log_error ("drop_from_hashtable: read item failed: %s\n",
1201                  gpg_strerror (rc));
1202       return rc;
1203     }
1204
1205   if (rec.rectype == RECTYPE_HTBL)
1206     {
1207       hashrec = item;
1208       level++;
1209       if (level >= keylen)
1210         {
1211           log_error ("hashtable has invalid indirections.\n");
1212           return GPG_ERR_TRUSTDB;
1213         }
1214       goto next_level;
1215     }
1216
1217   if (rec.rectype == RECTYPE_HLST)
1218     {
1219       for (;;)
1220         {
1221           for (i=0; i < ITEMS_PER_HLST_RECORD; i++)
1222             {
1223               if (rec.r.hlst.rnum[i] == recnum)
1224                 {
1225                   rec.r.hlst.rnum[i] = 0; /* Mark as free.  */
1226                   rc = tdbio_write_record (ctrl, &rec);
1227                   if (rc)
1228                     log_error("drop_from_hashtable: write htbl failed: %s\n",
1229                               gpg_strerror (rc));
1230                   return rc;
1231                 }
1232             }
1233           if (rec.r.hlst.next)
1234             {
1235               rc = tdbio_read_record (rec.r.hlst.next, &rec, RECTYPE_HLST);
1236               if (rc)
1237                 {
1238                   log_error ("drop_from_hashtable: read hlst failed: %s\n",
1239                              gpg_strerror (rc));
1240                   return rc;
1241                 }
1242             }
1243           else
1244             return 0; /* Key not in table.  */
1245         }
1246     }
1247
1248   log_error ("hashtbl %lu: %lu/%d points to wrong record %lu\n",
1249              table, hashrec, (msb % ITEMS_PER_HTBL_RECORD), item);
1250   return GPG_ERR_TRUSTDB;
1251 }
1252
1253
1254
1255 /*
1256  * Lookup a record via the hashtable TABLE by (KEY,KEYLEN) and return
1257  * the result in REC.  The return value of CMP() should be True if the
1258  * record is the desired one.
1259  *
1260  * Return: 0 if found, GPG_ERR_NOT_FOUND, or another error code.
1261  */
1262 static gpg_error_t
1263 lookup_hashtable (ulong table, const byte *key, size_t keylen,
1264                   int (*cmpfnc)(const void*, const TRUSTREC *),
1265                   const void *cmpdata, TRUSTREC *rec )
1266 {
1267   int rc;
1268   ulong hashrec, item;
1269   int msb;
1270   int level = 0;
1271
1272   hashrec = table;
1273  next_level:
1274   msb = key[level];
1275   hashrec += msb / ITEMS_PER_HTBL_RECORD;
1276   rc = tdbio_read_record (hashrec, rec, RECTYPE_HTBL);
1277   if (rc)
1278     {
1279       log_error("lookup_hashtable failed: %s\n", gpg_strerror (rc) );
1280       return rc;
1281     }
1282
1283   item = rec->r.htbl.item[msb % ITEMS_PER_HTBL_RECORD];
1284   if (!item)
1285     return gpg_error (GPG_ERR_NOT_FOUND);
1286
1287   rc = tdbio_read_record (item, rec, 0);
1288   if (rc)
1289     {
1290       log_error( "hashtable read failed: %s\n", gpg_strerror (rc) );
1291       return rc;
1292     }
1293   if (rec->rectype == RECTYPE_HTBL)
1294     {
1295       hashrec = item;
1296       level++;
1297       if (level >= keylen)
1298         {
1299           log_error ("hashtable has invalid indirections\n");
1300           return GPG_ERR_TRUSTDB;
1301         }
1302       goto next_level;
1303     }
1304   else if (rec->rectype == RECTYPE_HLST)
1305     {
1306       for (;;)
1307         {
1308           int i;
1309
1310           for (i=0; i < ITEMS_PER_HLST_RECORD; i++)
1311             {
1312               if (rec->r.hlst.rnum[i])
1313                 {
1314                   TRUSTREC tmp;
1315
1316                   rc = tdbio_read_record (rec->r.hlst.rnum[i], &tmp, 0);
1317                   if (rc)
1318                     {
1319                       log_error ("lookup_hashtable: read item failed: %s\n",
1320                                  gpg_strerror (rc));
1321                       return rc;
1322                     }
1323                   if ((*cmpfnc)(cmpdata, &tmp))
1324                     {
1325                       *rec = tmp;
1326                       return 0;
1327                     }
1328                 }
1329             }
1330           if (rec->r.hlst.next)
1331             {
1332               rc = tdbio_read_record (rec->r.hlst.next, rec, RECTYPE_HLST);
1333               if (rc)
1334                 {
1335                   log_error ("lookup_hashtable: read hlst failed: %s\n",
1336                              gpg_strerror (rc) );
1337                   return rc;
1338                 }
1339             }
1340           else
1341             return gpg_error (GPG_ERR_NOT_FOUND);
1342         }
1343     }
1344
1345   if ((*cmpfnc)(cmpdata, rec))
1346     return 0; /* really found */
1347
1348   return gpg_error (GPG_ERR_NOT_FOUND); /* no: not found */
1349 }
1350
1351
1352 /*
1353  * Update the trust hash table TR or create the table if it does not
1354  * exist.
1355  *
1356  * Return: 0 on success or an error code.
1357  */
1358 static int
1359 update_trusthashtbl (ctrl_t ctrl, TRUSTREC *tr)
1360 {
1361   return upd_hashtable (ctrl, get_trusthashrec (),
1362                         tr->r.trust.fingerprint, 20, tr->recnum);
1363 }
1364
1365
1366 /*
1367  * Dump the trustdb record REC to stream FP.
1368  */
1369 void
1370 tdbio_dump_record (TRUSTREC *rec, estream_t fp)
1371 {
1372   int i;
1373   ulong rnum = rec->recnum;
1374
1375   es_fprintf (fp, "rec %5lu, ", rnum);
1376
1377   switch (rec->rectype)
1378     {
1379     case 0:
1380       es_fprintf (fp, "blank\n");
1381       break;
1382
1383     case RECTYPE_VER:
1384       es_fprintf (fp,
1385          "version, td=%lu, f=%lu, m/c/d=%d/%d/%d tm=%d mcl=%d nc=%lu (%s)\n",
1386                   rec->r.ver.trusthashtbl,
1387                   rec->r.ver.firstfree,
1388                   rec->r.ver.marginals,
1389                   rec->r.ver.completes,
1390                   rec->r.ver.cert_depth,
1391                   rec->r.ver.trust_model,
1392                   rec->r.ver.min_cert_level,
1393                   rec->r.ver.nextcheck,
1394                   strtimestamp(rec->r.ver.nextcheck)
1395                   );
1396       break;
1397
1398     case RECTYPE_FREE:
1399       es_fprintf (fp, "free, next=%lu\n", rec->r.free.next);
1400       break;
1401
1402     case RECTYPE_HTBL:
1403       es_fprintf (fp, "htbl,");
1404       for (i=0; i < ITEMS_PER_HTBL_RECORD; i++)
1405         es_fprintf (fp, " %lu", rec->r.htbl.item[i]);
1406       es_putc ('\n', fp);
1407       break;
1408
1409     case RECTYPE_HLST:
1410       es_fprintf (fp, "hlst, next=%lu,", rec->r.hlst.next);
1411       for (i=0; i < ITEMS_PER_HLST_RECORD; i++)
1412         es_fprintf (fp, " %lu", rec->r.hlst.rnum[i]);
1413       es_putc ('\n', fp);
1414       break;
1415
1416     case RECTYPE_TRUST:
1417       es_fprintf (fp, "trust ");
1418       for (i=0; i < 20; i++)
1419         es_fprintf (fp, "%02X", rec->r.trust.fingerprint[i]);
1420       es_fprintf (fp, ", ot=%d, d=%d, vl=%lu\n", rec->r.trust.ownertrust,
1421                   rec->r.trust.depth, rec->r.trust.validlist);
1422       break;
1423
1424     case RECTYPE_VALID:
1425       es_fprintf (fp, "valid ");
1426       for (i=0; i < 20; i++)
1427         es_fprintf(fp, "%02X", rec->r.valid.namehash[i]);
1428       es_fprintf (fp, ", v=%d, next=%lu\n", rec->r.valid.validity,
1429                   rec->r.valid.next);
1430       break;
1431
1432     default:
1433       es_fprintf (fp, "unknown type %d\n", rec->rectype );
1434       break;
1435     }
1436 }
1437
1438
1439 /*
1440  * Read the record with number RECNUM into the structure REC.  If
1441  * EXPECTED is not 0 reading any other record type will return an
1442  * error.
1443  *
1444  * Return: 0 on success, -1 on EOF, or an error code.
1445  */
1446 int
1447 tdbio_read_record (ulong recnum, TRUSTREC *rec, int expected)
1448 {
1449   byte readbuf[TRUST_RECORD_LEN];
1450   const byte *buf, *p;
1451   gpg_error_t err = 0;
1452   int n, i;
1453
1454   if (db_fd == -1)
1455     open_db ();
1456
1457   buf = get_record_from_cache( recnum );
1458   if (!buf)
1459     {
1460       if (lseek (db_fd, recnum * TRUST_RECORD_LEN, SEEK_SET) == -1)
1461         {
1462           err = gpg_error_from_syserror ();
1463           log_error (_("trustdb: lseek failed: %s\n"), strerror (errno));
1464           return err;
1465         }
1466       n = read (db_fd, readbuf, TRUST_RECORD_LEN);
1467       if (!n)
1468         {
1469           return -1; /* eof */
1470         }
1471       else if (n != TRUST_RECORD_LEN)
1472         {
1473           err = gpg_error_from_syserror ();
1474           log_error (_("trustdb: read failed (n=%d): %s\n"),
1475                      n, strerror(errno));
1476           return err;
1477         }
1478       buf = readbuf;
1479     }
1480   rec->recnum = recnum;
1481   rec->dirty = 0;
1482   p = buf;
1483   rec->rectype = *p++;
1484   if (expected && rec->rectype != expected)
1485     {
1486       log_error ("%lu: read expected rec type %d, got %d\n",
1487                  recnum, expected, rec->rectype);
1488       return gpg_error (GPG_ERR_TRUSTDB);
1489     }
1490   p++;    /* Skip reserved byte.  */
1491   switch (rec->rectype)
1492     {
1493     case 0:  /* unused (free) record */
1494       break;
1495
1496     case RECTYPE_VER: /* version record */
1497       if (memcmp(buf+1, GPGEXT_GPG, 3))
1498         {
1499           log_error (_("%s: not a trustdb file\n"), db_name );
1500           err = gpg_error (GPG_ERR_TRUSTDB);
1501         }
1502       else
1503         {
1504           p += 2; /* skip "gpg" */
1505           rec->r.ver.version  = *p++;
1506           rec->r.ver.marginals = *p++;
1507           rec->r.ver.completes = *p++;
1508           rec->r.ver.cert_depth = *p++;
1509           rec->r.ver.trust_model = *p++;
1510           rec->r.ver.min_cert_level = *p++;
1511           p += 2;
1512           rec->r.ver.created  = buf32_to_ulong(p);
1513           p += 4;
1514           rec->r.ver.nextcheck = buf32_to_ulong(p);
1515           p += 4;
1516           p += 4;
1517           p += 4;
1518           rec->r.ver.firstfree = buf32_to_ulong(p);
1519           p += 4;
1520           p += 4;
1521           rec->r.ver.trusthashtbl = buf32_to_ulong(p);
1522           if (recnum)
1523             {
1524               log_error( _("%s: version record with recnum %lu\n"), db_name,
1525                          (ulong)recnum );
1526               err = gpg_error (GPG_ERR_TRUSTDB);
1527             }
1528           else if (rec->r.ver.version != 3)
1529             {
1530               log_error( _("%s: invalid file version %d\n"), db_name,
1531                          rec->r.ver.version );
1532               err = gpg_error (GPG_ERR_TRUSTDB);
1533             }
1534         }
1535       break;
1536
1537     case RECTYPE_FREE:
1538       rec->r.free.next  = buf32_to_ulong(p);
1539       break;
1540
1541     case RECTYPE_HTBL:
1542       for (i=0; i < ITEMS_PER_HTBL_RECORD; i++)
1543         {
1544           rec->r.htbl.item[i] = buf32_to_ulong(p);
1545           p += 4;
1546         }
1547       break;
1548
1549     case RECTYPE_HLST:
1550       rec->r.hlst.next = buf32_to_ulong(p);
1551       p += 4;
1552       for (i=0; i < ITEMS_PER_HLST_RECORD; i++)
1553         {
1554           rec->r.hlst.rnum[i] = buf32_to_ulong(p);
1555           p += 4;
1556         }
1557       break;
1558
1559     case RECTYPE_TRUST:
1560       memcpy (rec->r.trust.fingerprint, p, 20);
1561       p+=20;
1562       rec->r.trust.ownertrust = *p++;
1563       rec->r.trust.depth = *p++;
1564       rec->r.trust.min_ownertrust = *p++;
1565       p++;
1566       rec->r.trust.validlist = buf32_to_ulong(p);
1567       break;
1568
1569     case RECTYPE_VALID:
1570       memcpy (rec->r.valid.namehash, p, 20);
1571       p+=20;
1572       rec->r.valid.validity = *p++;
1573       rec->r.valid.next = buf32_to_ulong(p);
1574       p += 4;
1575       rec->r.valid.full_count = *p++;
1576       rec->r.valid.marginal_count = *p++;
1577       break;
1578
1579     default:
1580       log_error ("%s: invalid record type %d at recnum %lu\n",
1581                  db_name, rec->rectype, (ulong)recnum);
1582       err = gpg_error (GPG_ERR_TRUSTDB);
1583       break;
1584     }
1585
1586   return err;
1587 }
1588
1589
1590 /*
1591  * Write the record from the struct REC.
1592  *
1593  * Return: 0 on success or an error code.
1594  */
1595 int
1596 tdbio_write_record (ctrl_t ctrl, TRUSTREC *rec)
1597 {
1598   byte buf[TRUST_RECORD_LEN];
1599   byte *p;
1600   int rc = 0;
1601   int i;
1602   ulong recnum = rec->recnum;
1603
1604   if (db_fd == -1)
1605     open_db ();
1606
1607   memset (buf, 0, TRUST_RECORD_LEN);
1608   p = buf;
1609   *p++ = rec->rectype; p++;
1610
1611   switch (rec->rectype)
1612     {
1613     case 0:  /* unused record */
1614       break;
1615
1616     case RECTYPE_VER: /* version record */
1617       if (recnum)
1618         BUG ();
1619       memcpy(p-1, GPGEXT_GPG, 3 ); p += 2;
1620       *p++ = rec->r.ver.version;
1621       *p++ = rec->r.ver.marginals;
1622       *p++ = rec->r.ver.completes;
1623       *p++ = rec->r.ver.cert_depth;
1624       *p++ = rec->r.ver.trust_model;
1625       *p++ = rec->r.ver.min_cert_level;
1626       p += 2;
1627       ulongtobuf(p, rec->r.ver.created); p += 4;
1628       ulongtobuf(p, rec->r.ver.nextcheck); p += 4;
1629       p += 4;
1630       p += 4;
1631       ulongtobuf(p, rec->r.ver.firstfree ); p += 4;
1632       p += 4;
1633       ulongtobuf(p, rec->r.ver.trusthashtbl ); p += 4;
1634       break;
1635
1636     case RECTYPE_FREE:
1637       ulongtobuf(p, rec->r.free.next); p += 4;
1638       break;
1639
1640     case RECTYPE_HTBL:
1641       for (i=0; i < ITEMS_PER_HTBL_RECORD; i++)
1642         {
1643           ulongtobuf( p, rec->r.htbl.item[i]); p += 4;
1644         }
1645       break;
1646
1647     case RECTYPE_HLST:
1648       ulongtobuf( p, rec->r.hlst.next); p += 4;
1649       for (i=0; i < ITEMS_PER_HLST_RECORD; i++ )
1650         {
1651           ulongtobuf( p, rec->r.hlst.rnum[i]); p += 4;
1652         }
1653       break;
1654
1655     case RECTYPE_TRUST:
1656       memcpy (p, rec->r.trust.fingerprint, 20); p += 20;
1657       *p++ = rec->r.trust.ownertrust;
1658       *p++ = rec->r.trust.depth;
1659       *p++ = rec->r.trust.min_ownertrust;
1660       p++;
1661       ulongtobuf( p, rec->r.trust.validlist); p += 4;
1662       break;
1663
1664     case RECTYPE_VALID:
1665       memcpy (p, rec->r.valid.namehash, 20); p += 20;
1666       *p++ = rec->r.valid.validity;
1667       ulongtobuf( p, rec->r.valid.next); p += 4;
1668       *p++ = rec->r.valid.full_count;
1669       *p++ = rec->r.valid.marginal_count;
1670       break;
1671
1672     default:
1673       BUG();
1674     }
1675
1676   rc = put_record_into_cache (recnum, buf);
1677   if (rc)
1678     ;
1679   else if (rec->rectype == RECTYPE_TRUST)
1680     rc = update_trusthashtbl (ctrl, rec);
1681
1682   return rc;
1683 }
1684
1685
1686 /*
1687  * Delete the record at record number RECNUm from the trustdb.
1688  *
1689  * Return: 0 on success or an error code.
1690  */
1691 int
1692 tdbio_delete_record (ctrl_t ctrl, ulong recnum)
1693 {
1694   TRUSTREC vr, rec;
1695   int rc;
1696
1697   /* Must read the record fist, so we can drop it from the hash tables */
1698   rc = tdbio_read_record (recnum, &rec, 0);
1699   if (rc)
1700     ;
1701   else if (rec.rectype == RECTYPE_TRUST)
1702     {
1703       rc = drop_from_hashtable (ctrl, get_trusthashrec(),
1704                                 rec.r.trust.fingerprint, 20, rec.recnum);
1705     }
1706
1707   if (rc)
1708     return rc;
1709
1710   /* Now we can change it to a free record.  */
1711   rc = tdbio_read_record (0, &vr, RECTYPE_VER);
1712   if (rc)
1713     log_fatal (_("%s: error reading version record: %s\n"),
1714                db_name, gpg_strerror (rc));
1715
1716   rec.recnum = recnum;
1717   rec.rectype = RECTYPE_FREE;
1718   rec.r.free.next = vr.r.ver.firstfree;
1719   vr.r.ver.firstfree = recnum;
1720   rc = tdbio_write_record (ctrl, &rec);
1721   if (!rc)
1722     rc = tdbio_write_record (ctrl, &vr);
1723
1724   return rc;
1725 }
1726
1727
1728 /*
1729  * Create a new record and return its record number.
1730  */
1731 ulong
1732 tdbio_new_recnum (ctrl_t ctrl)
1733 {
1734   off_t offset;
1735   ulong recnum;
1736   TRUSTREC vr, rec;
1737   int rc;
1738
1739   /* Look for unused records.  */
1740   rc = tdbio_read_record (0, &vr, RECTYPE_VER);
1741   if (rc)
1742     log_fatal( _("%s: error reading version record: %s\n"),
1743                db_name, gpg_strerror (rc));
1744   if (vr.r.ver.firstfree)
1745     {
1746       recnum = vr.r.ver.firstfree;
1747       rc = tdbio_read_record (recnum, &rec, RECTYPE_FREE);
1748       if (rc)
1749         {
1750           log_error (_("%s: error reading free record: %s\n"),
1751                      db_name,  gpg_strerror (rc));
1752           return rc;
1753         }
1754       /* Update dir record.  */
1755       vr.r.ver.firstfree = rec.r.free.next;
1756       rc = tdbio_write_record (ctrl, &vr);
1757       if (rc)
1758         {
1759           log_error (_("%s: error writing dir record: %s\n"),
1760                      db_name, gpg_strerror (rc));
1761           return rc;
1762         }
1763       /* Zero out the new record.  */
1764       memset (&rec, 0, sizeof rec);
1765       rec.rectype = 0; /* Mark as unused record (actually already done
1766                           my the memset).  */
1767       rec.recnum = recnum;
1768       rc = tdbio_write_record (ctrl, &rec);
1769       if (rc)
1770         log_fatal (_("%s: failed to zero a record: %s\n"),
1771                    db_name, gpg_strerror (rc));
1772     }
1773   else /* Not found - append a new record.  */
1774     {
1775       offset = lseek (db_fd, 0, SEEK_END);
1776       if (offset == (off_t)(-1))
1777         log_fatal ("trustdb: lseek to end failed: %s\n", strerror (errno));
1778       recnum = offset / TRUST_RECORD_LEN;
1779       log_assert (recnum); /* this is will never be the first record */
1780       /* We must write a record, so that the next call to this
1781        * function returns another recnum.  */
1782       memset (&rec, 0, sizeof rec);
1783       rec.rectype = 0; /* unused record */
1784       rec.recnum = recnum;
1785       rc = 0;
1786       if (lseek( db_fd, recnum * TRUST_RECORD_LEN, SEEK_SET) == -1)
1787         {
1788           rc = gpg_error_from_syserror ();
1789           log_error (_("trustdb rec %lu: lseek failed: %s\n"),
1790                      recnum, strerror (errno));
1791         }
1792       else
1793         {
1794           int n;
1795
1796           n = write (db_fd, &rec, TRUST_RECORD_LEN);
1797           if (n != TRUST_RECORD_LEN)
1798             {
1799               rc = gpg_error_from_syserror ();
1800               log_error (_("trustdb rec %lu: write failed (n=%d): %s\n"),
1801                          recnum, n, strerror (errno));
1802             }
1803         }
1804
1805       if (rc)
1806         log_fatal (_("%s: failed to append a record: %s\n"),
1807                    db_name,     gpg_strerror (rc));
1808     }
1809
1810   return recnum ;
1811 }
1812
1813
1814
1815 /* Helper function for tdbio_search_trust_byfpr.  */
1816 static int
1817 cmp_trec_fpr ( const void *fpr, const TRUSTREC *rec )
1818 {
1819   return (rec->rectype == RECTYPE_TRUST
1820           && !memcmp (rec->r.trust.fingerprint, fpr, 20));
1821 }
1822
1823
1824 /*
1825  * Given a 20 byte FINGERPRINT search its trust record and return
1826  * that at REC.
1827  *
1828  * Return: 0 if found, GPG_ERR_NOT_FOUND, or another error code.
1829  */
1830 gpg_error_t
1831 tdbio_search_trust_byfpr (const byte *fingerprint, TRUSTREC *rec)
1832 {
1833   int rc;
1834
1835   /* Locate the trust record using the hash table */
1836   rc = lookup_hashtable (get_trusthashrec(), fingerprint, 20,
1837                          cmp_trec_fpr, fingerprint, rec );
1838   return rc;
1839 }
1840
1841
1842 /*
1843  * Given a primary public key object PK search its trust record and
1844  * return that at REC.
1845  *
1846  * Return: 0 if found, GPG_ERR_NOT_FOUND, or another error code.
1847  */
1848 gpg_error_t
1849 tdbio_search_trust_bypk (PKT_public_key *pk, TRUSTREC *rec)
1850 {
1851   byte fingerprint[MAX_FINGERPRINT_LEN];
1852   size_t fingerlen;
1853
1854   fingerprint_from_pk( pk, fingerprint, &fingerlen );
1855   for (; fingerlen < 20; fingerlen++)
1856     fingerprint[fingerlen] = 0;
1857   return tdbio_search_trust_byfpr (fingerprint, rec);
1858 }
1859
1860
1861 /*
1862  * Terminate the process with a message about a corrupted trustdb.
1863  */
1864 void
1865 tdbio_invalid (void)
1866 {
1867   log_error (_("Error: The trustdb is corrupted.\n"));
1868   how_to_fix_the_trustdb ();
1869   g10_exit (2);
1870 }