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