gpg: Set a limit for a WKD import of 256 KiB.
[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 (ctrl_t ctrl)
978 {
979   static ulong trusthashtbl; /* Record number of the trust hashtable.  */
980
981   (void)ctrl;
982
983   if (!trusthashtbl)
984     {
985       TRUSTREC vr;
986       int rc;
987
988       rc = tdbio_read_record (0, &vr, RECTYPE_VER );
989       if (rc)
990         log_fatal (_("%s: error reading version record: %s\n"),
991                    db_name, gpg_strerror (rc) );
992
993       if (!vr.r.ver.trusthashtbl)
994         {
995           /* Oops: the trustdb is corrupt because the hashtable is
996            * always created along with the version record.  However,
997            * if something went initially wrong it may happen that
998            * there is just the version record.  We try to fix it here.
999            * If we can't do that we return 0 - this is the version
1000            * record and thus the actual read will detect the mismatch
1001            * and bail out.  Note that create_hashtable updates VR.  */
1002           take_write_lock ();
1003           if (lseek (db_fd, 0, SEEK_END) == TRUST_RECORD_LEN)
1004             create_hashtable (ctrl, &vr, 0);
1005           release_write_lock ();
1006         }
1007       trusthashtbl = vr.r.ver.trusthashtbl;
1008     }
1009
1010   return trusthashtbl;
1011 }
1012
1013
1014
1015 /*
1016  * Update a hashtable in the trustdb.  TABLE gives the start of the
1017  * table, KEY and KEYLEN are the key, NEWRECNUM is the record number
1018  * to insert into the table.
1019  *
1020  * Return: 0 on success or an error code.
1021  */
1022 static int
1023 upd_hashtable (ctrl_t ctrl, ulong table, byte *key, int keylen, ulong newrecnum)
1024 {
1025   TRUSTREC lastrec, rec;
1026   ulong hashrec, item;
1027   int msb;
1028   int level = 0;
1029   int rc, i;
1030
1031   hashrec = table;
1032  next_level:
1033   msb = key[level];
1034   hashrec += msb / ITEMS_PER_HTBL_RECORD;
1035   rc = tdbio_read_record (hashrec, &rec, RECTYPE_HTBL);
1036   if (rc)
1037     {
1038       log_error ("upd_hashtable: read failed: %s\n", gpg_strerror (rc));
1039       return rc;
1040     }
1041
1042   item = rec.r.htbl.item[msb % ITEMS_PER_HTBL_RECORD];
1043   if (!item)  /* Insert a new item into the hash table.  */
1044     {
1045       rec.r.htbl.item[msb % ITEMS_PER_HTBL_RECORD] = newrecnum;
1046       rc = tdbio_write_record (ctrl, &rec);
1047       if (rc)
1048         {
1049           log_error ("upd_hashtable: write htbl failed: %s\n",
1050                      gpg_strerror (rc));
1051           return rc;
1052         }
1053     }
1054   else if (item != newrecnum) /* Must do an update.  */
1055     {
1056       lastrec = rec;
1057       rc = tdbio_read_record (item, &rec, 0);
1058       if (rc)
1059         {
1060           log_error ("upd_hashtable: read item failed: %s\n",
1061                      gpg_strerror (rc));
1062           return rc;
1063         }
1064
1065       if (rec.rectype == RECTYPE_HTBL)
1066         {
1067           hashrec = item;
1068           level++;
1069           if (level >= keylen)
1070             {
1071               log_error ("hashtable has invalid indirections.\n");
1072               return GPG_ERR_TRUSTDB;
1073             }
1074           goto next_level;
1075         }
1076       else if (rec.rectype == RECTYPE_HLST) /* Extend the list.  */
1077         {
1078           /* Check whether the key is already in this list. */
1079           for (;;)
1080             {
1081               for (i=0; i < ITEMS_PER_HLST_RECORD; i++)
1082                 {
1083                   if (rec.r.hlst.rnum[i] == newrecnum)
1084                     {
1085                       return 0; /* Okay, already in the list.  */
1086                     }
1087                 }
1088               if (rec.r.hlst.next)
1089                 {
1090                   rc = tdbio_read_record (rec.r.hlst.next, &rec, RECTYPE_HLST);
1091                   if (rc)
1092                     {
1093                       log_error ("upd_hashtable: read hlst failed: %s\n",
1094                                  gpg_strerror (rc) );
1095                       return rc;
1096                     }
1097                 }
1098               else
1099                 break; /* key is not in the list */
1100             }
1101
1102           /* Find the next free entry and put it in.  */
1103           for (;;)
1104             {
1105               for (i=0; i < ITEMS_PER_HLST_RECORD; i++)
1106                 {
1107                   if (!rec.r.hlst.rnum[i])
1108                     {
1109                       /* Empty slot found.  */
1110                       rec.r.hlst.rnum[i] = newrecnum;
1111                       rc = tdbio_write_record (ctrl, &rec);
1112                       if (rc)
1113                         log_error ("upd_hashtable: write hlst failed: %s\n",
1114                                    gpg_strerror (rc));
1115                       return rc; /* Done.  */
1116                     }
1117                 }
1118
1119               if (rec.r.hlst.next)
1120                 {
1121                   /* read the next reord of the list.  */
1122                   rc = tdbio_read_record (rec.r.hlst.next, &rec, RECTYPE_HLST);
1123                   if (rc)
1124                     {
1125                       log_error ("upd_hashtable: read hlst failed: %s\n",
1126                                  gpg_strerror (rc));
1127                       return rc;
1128                     }
1129                 }
1130               else
1131                 {
1132                   /* Append a new record to the list.  */
1133                   rec.r.hlst.next = item = tdbio_new_recnum (ctrl);
1134                   rc = tdbio_write_record (ctrl, &rec);
1135                   if (rc)
1136                     {
1137                       log_error ("upd_hashtable: write hlst failed: %s\n",
1138                                  gpg_strerror (rc));
1139                       return rc;
1140                     }
1141                   memset (&rec, 0, sizeof rec);
1142                   rec.rectype = RECTYPE_HLST;
1143                   rec.recnum = item;
1144                   rec.r.hlst.rnum[0] = newrecnum;
1145                   rc = tdbio_write_record (ctrl, &rec);
1146                   if (rc)
1147                     log_error ("upd_hashtable: write ext hlst failed: %s\n",
1148                                gpg_strerror (rc));
1149                   return rc; /* Done.  */
1150                 }
1151             } /* end loop over list slots */
1152
1153         }
1154       else if (rec.rectype == RECTYPE_TRUST) /* Insert a list record.  */
1155         {
1156           if (rec.recnum == newrecnum)
1157             {
1158               return 0;
1159             }
1160           item = rec.recnum; /* Save number of key record.  */
1161           memset (&rec, 0, sizeof rec);
1162           rec.rectype = RECTYPE_HLST;
1163           rec.recnum = tdbio_new_recnum (ctrl);
1164           rec.r.hlst.rnum[0] = item;        /* Old key record */
1165           rec.r.hlst.rnum[1] = newrecnum; /* and new key record */
1166           rc = tdbio_write_record (ctrl, &rec);
1167           if (rc)
1168             {
1169               log_error( "upd_hashtable: write new hlst failed: %s\n",
1170                            gpg_strerror (rc) );
1171               return rc;
1172             }
1173           /* Update the hashtable record.  */
1174           lastrec.r.htbl.item[msb % ITEMS_PER_HTBL_RECORD] = rec.recnum;
1175           rc = tdbio_write_record (ctrl, &lastrec);
1176           if (rc)
1177             log_error ("upd_hashtable: update htbl failed: %s\n",
1178                        gpg_strerror (rc));
1179           return rc; /* Ready.  */
1180         }
1181       else
1182         {
1183           log_error ("hashtbl %lu: %lu/%d points to an invalid record %lu\n",
1184                      table, hashrec, (msb % ITEMS_PER_HTBL_RECORD), item);
1185           if (opt.verbose > 1)
1186             list_trustdb (ctrl, es_stderr, NULL);
1187           return GPG_ERR_TRUSTDB;
1188         }
1189     }
1190
1191   return 0;
1192 }
1193
1194
1195 /*
1196  * Drop an entry from a hashtable.  TABLE gives the start of the
1197  * table, KEY and KEYLEN are the key.
1198  *
1199  * Return: 0 on success or an error code.
1200  */
1201 static int
1202 drop_from_hashtable (ctrl_t ctrl, ulong table,
1203                      byte *key, int keylen, ulong recnum)
1204 {
1205   TRUSTREC rec;
1206   ulong hashrec, item;
1207   int msb;
1208   int level = 0;
1209   int rc, i;
1210
1211   hashrec = table;
1212  next_level:
1213   msb = key[level];
1214   hashrec += msb / ITEMS_PER_HTBL_RECORD;
1215   rc = tdbio_read_record (hashrec, &rec, RECTYPE_HTBL );
1216   if (rc)
1217     {
1218       log_error ("drop_from_hashtable: read failed: %s\n", gpg_strerror (rc));
1219       return rc;
1220     }
1221
1222   item = rec.r.htbl.item[msb % ITEMS_PER_HTBL_RECORD];
1223   if (!item)
1224     return 0;   /* Not found - forget about it.  */
1225
1226   if (item == recnum) /* Table points direct to the record.  */
1227     {
1228       rec.r.htbl.item[msb % ITEMS_PER_HTBL_RECORD] = 0;
1229       rc = tdbio_write_record (ctrl, &rec);
1230       if (rc)
1231         log_error ("drop_from_hashtable: write htbl failed: %s\n",
1232                    gpg_strerror (rc));
1233       return rc;
1234     }
1235
1236   rc = tdbio_read_record (item, &rec, 0);
1237   if (rc)
1238     {
1239       log_error ("drop_from_hashtable: read item failed: %s\n",
1240                  gpg_strerror (rc));
1241       return rc;
1242     }
1243
1244   if (rec.rectype == RECTYPE_HTBL)
1245     {
1246       hashrec = item;
1247       level++;
1248       if (level >= keylen)
1249         {
1250           log_error ("hashtable has invalid indirections.\n");
1251           return GPG_ERR_TRUSTDB;
1252         }
1253       goto next_level;
1254     }
1255
1256   if (rec.rectype == RECTYPE_HLST)
1257     {
1258       for (;;)
1259         {
1260           for (i=0; i < ITEMS_PER_HLST_RECORD; i++)
1261             {
1262               if (rec.r.hlst.rnum[i] == recnum)
1263                 {
1264                   rec.r.hlst.rnum[i] = 0; /* Mark as free.  */
1265                   rc = tdbio_write_record (ctrl, &rec);
1266                   if (rc)
1267                     log_error("drop_from_hashtable: write htbl failed: %s\n",
1268                               gpg_strerror (rc));
1269                   return rc;
1270                 }
1271             }
1272           if (rec.r.hlst.next)
1273             {
1274               rc = tdbio_read_record (rec.r.hlst.next, &rec, RECTYPE_HLST);
1275               if (rc)
1276                 {
1277                   log_error ("drop_from_hashtable: read hlst failed: %s\n",
1278                              gpg_strerror (rc));
1279                   return rc;
1280                 }
1281             }
1282           else
1283             return 0; /* Key not in table.  */
1284         }
1285     }
1286
1287   log_error ("hashtbl %lu: %lu/%d points to wrong record %lu\n",
1288              table, hashrec, (msb % ITEMS_PER_HTBL_RECORD), item);
1289   return GPG_ERR_TRUSTDB;
1290 }
1291
1292
1293
1294 /*
1295  * Lookup a record via the hashtable TABLE by (KEY,KEYLEN) and return
1296  * the result in REC.  The return value of CMP() should be True if the
1297  * record is the desired one.
1298  *
1299  * Return: 0 if found, GPG_ERR_NOT_FOUND, or another error code.
1300  */
1301 static gpg_error_t
1302 lookup_hashtable (ulong table, const byte *key, size_t keylen,
1303                   int (*cmpfnc)(const void*, const TRUSTREC *),
1304                   const void *cmpdata, TRUSTREC *rec )
1305 {
1306   int rc;
1307   ulong hashrec, item;
1308   int msb;
1309   int level = 0;
1310
1311   if (!table)
1312     {
1313       rc = gpg_error (GPG_ERR_INV_RECORD);
1314       log_error("lookup_hashtable failed: %s\n", "request for record 0");
1315       return rc;
1316     }
1317
1318   hashrec = table;
1319  next_level:
1320   msb = key[level];
1321   hashrec += msb / ITEMS_PER_HTBL_RECORD;
1322   rc = tdbio_read_record (hashrec, rec, RECTYPE_HTBL);
1323   if (rc)
1324     {
1325       log_error("lookup_hashtable failed: %s\n", gpg_strerror (rc) );
1326       return rc;
1327     }
1328
1329   item = rec->r.htbl.item[msb % ITEMS_PER_HTBL_RECORD];
1330   if (!item)
1331     return gpg_error (GPG_ERR_NOT_FOUND);
1332
1333   rc = tdbio_read_record (item, rec, 0);
1334   if (rc)
1335     {
1336       log_error( "hashtable read failed: %s\n", gpg_strerror (rc) );
1337       return rc;
1338     }
1339   if (rec->rectype == RECTYPE_HTBL)
1340     {
1341       hashrec = item;
1342       level++;
1343       if (level >= keylen)
1344         {
1345           log_error ("hashtable has invalid indirections\n");
1346           return GPG_ERR_TRUSTDB;
1347         }
1348       goto next_level;
1349     }
1350   else if (rec->rectype == RECTYPE_HLST)
1351     {
1352       for (;;)
1353         {
1354           int i;
1355
1356           for (i=0; i < ITEMS_PER_HLST_RECORD; i++)
1357             {
1358               if (rec->r.hlst.rnum[i])
1359                 {
1360                   TRUSTREC tmp;
1361
1362                   rc = tdbio_read_record (rec->r.hlst.rnum[i], &tmp, 0);
1363                   if (rc)
1364                     {
1365                       log_error ("lookup_hashtable: read item failed: %s\n",
1366                                  gpg_strerror (rc));
1367                       return rc;
1368                     }
1369                   if ((*cmpfnc)(cmpdata, &tmp))
1370                     {
1371                       *rec = tmp;
1372                       return 0;
1373                     }
1374                 }
1375             }
1376           if (rec->r.hlst.next)
1377             {
1378               rc = tdbio_read_record (rec->r.hlst.next, rec, RECTYPE_HLST);
1379               if (rc)
1380                 {
1381                   log_error ("lookup_hashtable: read hlst failed: %s\n",
1382                              gpg_strerror (rc) );
1383                   return rc;
1384                 }
1385             }
1386           else
1387             return gpg_error (GPG_ERR_NOT_FOUND);
1388         }
1389     }
1390
1391   if ((*cmpfnc)(cmpdata, rec))
1392     return 0; /* really found */
1393
1394   return gpg_error (GPG_ERR_NOT_FOUND); /* no: not found */
1395 }
1396
1397
1398 /*
1399  * Update the trust hash table TR or create the table if it does not
1400  * exist.
1401  *
1402  * Return: 0 on success or an error code.
1403  */
1404 static int
1405 update_trusthashtbl (ctrl_t ctrl, TRUSTREC *tr)
1406 {
1407   return upd_hashtable (ctrl, get_trusthashrec (ctrl),
1408                         tr->r.trust.fingerprint, 20, tr->recnum);
1409 }
1410
1411
1412 /*
1413  * Dump the trustdb record REC to stream FP.
1414  */
1415 void
1416 tdbio_dump_record (TRUSTREC *rec, estream_t fp)
1417 {
1418   int i;
1419   ulong rnum = rec->recnum;
1420
1421   es_fprintf (fp, "rec %5lu, ", rnum);
1422
1423   switch (rec->rectype)
1424     {
1425     case 0:
1426       es_fprintf (fp, "blank\n");
1427       break;
1428
1429     case RECTYPE_VER:
1430       es_fprintf (fp,
1431          "version, td=%lu, f=%lu, m/c/d=%d/%d/%d tm=%d mcl=%d nc=%lu (%s)\n",
1432                   rec->r.ver.trusthashtbl,
1433                   rec->r.ver.firstfree,
1434                   rec->r.ver.marginals,
1435                   rec->r.ver.completes,
1436                   rec->r.ver.cert_depth,
1437                   rec->r.ver.trust_model,
1438                   rec->r.ver.min_cert_level,
1439                   rec->r.ver.nextcheck,
1440                   strtimestamp(rec->r.ver.nextcheck)
1441                   );
1442       break;
1443
1444     case RECTYPE_FREE:
1445       es_fprintf (fp, "free, next=%lu\n", rec->r.free.next);
1446       break;
1447
1448     case RECTYPE_HTBL:
1449       es_fprintf (fp, "htbl,");
1450       for (i=0; i < ITEMS_PER_HTBL_RECORD; i++)
1451         es_fprintf (fp, " %lu", rec->r.htbl.item[i]);
1452       es_putc ('\n', fp);
1453       break;
1454
1455     case RECTYPE_HLST:
1456       es_fprintf (fp, "hlst, next=%lu,", rec->r.hlst.next);
1457       for (i=0; i < ITEMS_PER_HLST_RECORD; i++)
1458         es_fprintf (fp, " %lu", rec->r.hlst.rnum[i]);
1459       es_putc ('\n', fp);
1460       break;
1461
1462     case RECTYPE_TRUST:
1463       es_fprintf (fp, "trust ");
1464       for (i=0; i < 20; i++)
1465         es_fprintf (fp, "%02X", rec->r.trust.fingerprint[i]);
1466       es_fprintf (fp, ", ot=%d, d=%d, vl=%lu\n", rec->r.trust.ownertrust,
1467                   rec->r.trust.depth, rec->r.trust.validlist);
1468       break;
1469
1470     case RECTYPE_VALID:
1471       es_fprintf (fp, "valid ");
1472       for (i=0; i < 20; i++)
1473         es_fprintf(fp, "%02X", rec->r.valid.namehash[i]);
1474       es_fprintf (fp, ", v=%d, next=%lu\n", rec->r.valid.validity,
1475                   rec->r.valid.next);
1476       break;
1477
1478     default:
1479       es_fprintf (fp, "unknown type %d\n", rec->rectype );
1480       break;
1481     }
1482 }
1483
1484
1485 /*
1486  * Read the record with number RECNUM into the structure REC.  If
1487  * EXPECTED is not 0 reading any other record type will return an
1488  * error.
1489  *
1490  * Return: 0 on success or an error code.
1491  */
1492 int
1493 tdbio_read_record (ulong recnum, TRUSTREC *rec, int expected)
1494 {
1495   byte readbuf[TRUST_RECORD_LEN];
1496   const byte *buf, *p;
1497   gpg_error_t err = 0;
1498   int n, i;
1499
1500   if (db_fd == -1)
1501     open_db ();
1502
1503   buf = get_record_from_cache( recnum );
1504   if (!buf)
1505     {
1506       if (lseek (db_fd, recnum * TRUST_RECORD_LEN, SEEK_SET) == -1)
1507         {
1508           err = gpg_error_from_syserror ();
1509           log_error (_("trustdb: lseek failed: %s\n"), strerror (errno));
1510           return err;
1511         }
1512       n = read (db_fd, readbuf, TRUST_RECORD_LEN);
1513       if (!n)
1514         {
1515           return gpg_error (GPG_ERR_EOF);
1516         }
1517       else if (n != TRUST_RECORD_LEN)
1518         {
1519           err = gpg_error_from_syserror ();
1520           log_error (_("trustdb: read failed (n=%d): %s\n"),
1521                      n, strerror(errno));
1522           return err;
1523         }
1524       buf = readbuf;
1525     }
1526   rec->recnum = recnum;
1527   rec->dirty = 0;
1528   p = buf;
1529   rec->rectype = *p++;
1530   if (expected && rec->rectype != expected)
1531     {
1532       log_error ("%lu: read expected rec type %d, got %d\n",
1533                  recnum, expected, rec->rectype);
1534       return gpg_error (GPG_ERR_TRUSTDB);
1535     }
1536   p++;    /* Skip reserved byte.  */
1537   switch (rec->rectype)
1538     {
1539     case 0:  /* unused (free) record */
1540       break;
1541
1542     case RECTYPE_VER: /* version record */
1543       if (memcmp(buf+1, GPGEXT_GPG, 3))
1544         {
1545           log_error (_("%s: not a trustdb file\n"), db_name );
1546           err = gpg_error (GPG_ERR_TRUSTDB);
1547         }
1548       else
1549         {
1550           p += 2; /* skip "gpg" */
1551           rec->r.ver.version  = *p++;
1552           rec->r.ver.marginals = *p++;
1553           rec->r.ver.completes = *p++;
1554           rec->r.ver.cert_depth = *p++;
1555           rec->r.ver.trust_model = *p++;
1556           rec->r.ver.min_cert_level = *p++;
1557           p += 2;
1558           rec->r.ver.created  = buf32_to_ulong(p);
1559           p += 4;
1560           rec->r.ver.nextcheck = buf32_to_ulong(p);
1561           p += 4;
1562           p += 4;
1563           p += 4;
1564           rec->r.ver.firstfree = buf32_to_ulong(p);
1565           p += 4;
1566           p += 4;
1567           rec->r.ver.trusthashtbl = buf32_to_ulong(p);
1568           if (recnum)
1569             {
1570               log_error( _("%s: version record with recnum %lu\n"), db_name,
1571                          (ulong)recnum );
1572               err = gpg_error (GPG_ERR_TRUSTDB);
1573             }
1574           else if (rec->r.ver.version != 3)
1575             {
1576               log_error( _("%s: invalid file version %d\n"), db_name,
1577                          rec->r.ver.version );
1578               err = gpg_error (GPG_ERR_TRUSTDB);
1579             }
1580         }
1581       break;
1582
1583     case RECTYPE_FREE:
1584       rec->r.free.next  = buf32_to_ulong(p);
1585       break;
1586
1587     case RECTYPE_HTBL:
1588       for (i=0; i < ITEMS_PER_HTBL_RECORD; i++)
1589         {
1590           rec->r.htbl.item[i] = buf32_to_ulong(p);
1591           p += 4;
1592         }
1593       break;
1594
1595     case RECTYPE_HLST:
1596       rec->r.hlst.next = buf32_to_ulong(p);
1597       p += 4;
1598       for (i=0; i < ITEMS_PER_HLST_RECORD; i++)
1599         {
1600           rec->r.hlst.rnum[i] = buf32_to_ulong(p);
1601           p += 4;
1602         }
1603       break;
1604
1605     case RECTYPE_TRUST:
1606       memcpy (rec->r.trust.fingerprint, p, 20);
1607       p+=20;
1608       rec->r.trust.ownertrust = *p++;
1609       rec->r.trust.depth = *p++;
1610       rec->r.trust.min_ownertrust = *p++;
1611       p++;
1612       rec->r.trust.validlist = buf32_to_ulong(p);
1613       break;
1614
1615     case RECTYPE_VALID:
1616       memcpy (rec->r.valid.namehash, p, 20);
1617       p+=20;
1618       rec->r.valid.validity = *p++;
1619       rec->r.valid.next = buf32_to_ulong(p);
1620       p += 4;
1621       rec->r.valid.full_count = *p++;
1622       rec->r.valid.marginal_count = *p++;
1623       break;
1624
1625     default:
1626       log_error ("%s: invalid record type %d at recnum %lu\n",
1627                  db_name, rec->rectype, (ulong)recnum);
1628       err = gpg_error (GPG_ERR_TRUSTDB);
1629       break;
1630     }
1631
1632   return err;
1633 }
1634
1635
1636 /*
1637  * Write the record from the struct REC.
1638  *
1639  * Return: 0 on success or an error code.
1640  */
1641 int
1642 tdbio_write_record (ctrl_t ctrl, TRUSTREC *rec)
1643 {
1644   byte buf[TRUST_RECORD_LEN];
1645   byte *p;
1646   int rc = 0;
1647   int i;
1648   ulong recnum = rec->recnum;
1649
1650   if (db_fd == -1)
1651     open_db ();
1652
1653   memset (buf, 0, TRUST_RECORD_LEN);
1654   p = buf;
1655   *p++ = rec->rectype; p++;
1656
1657   switch (rec->rectype)
1658     {
1659     case 0:  /* unused record */
1660       break;
1661
1662     case RECTYPE_VER: /* version record */
1663       if (recnum)
1664         BUG ();
1665       memcpy(p-1, GPGEXT_GPG, 3 ); p += 2;
1666       *p++ = rec->r.ver.version;
1667       *p++ = rec->r.ver.marginals;
1668       *p++ = rec->r.ver.completes;
1669       *p++ = rec->r.ver.cert_depth;
1670       *p++ = rec->r.ver.trust_model;
1671       *p++ = rec->r.ver.min_cert_level;
1672       p += 2;
1673       ulongtobuf(p, rec->r.ver.created); p += 4;
1674       ulongtobuf(p, rec->r.ver.nextcheck); p += 4;
1675       p += 4;
1676       p += 4;
1677       ulongtobuf(p, rec->r.ver.firstfree ); p += 4;
1678       p += 4;
1679       ulongtobuf(p, rec->r.ver.trusthashtbl ); p += 4;
1680       break;
1681
1682     case RECTYPE_FREE:
1683       ulongtobuf(p, rec->r.free.next); p += 4;
1684       break;
1685
1686     case RECTYPE_HTBL:
1687       for (i=0; i < ITEMS_PER_HTBL_RECORD; i++)
1688         {
1689           ulongtobuf( p, rec->r.htbl.item[i]); p += 4;
1690         }
1691       break;
1692
1693     case RECTYPE_HLST:
1694       ulongtobuf( p, rec->r.hlst.next); p += 4;
1695       for (i=0; i < ITEMS_PER_HLST_RECORD; i++ )
1696         {
1697           ulongtobuf( p, rec->r.hlst.rnum[i]); p += 4;
1698         }
1699       break;
1700
1701     case RECTYPE_TRUST:
1702       memcpy (p, rec->r.trust.fingerprint, 20); p += 20;
1703       *p++ = rec->r.trust.ownertrust;
1704       *p++ = rec->r.trust.depth;
1705       *p++ = rec->r.trust.min_ownertrust;
1706       p++;
1707       ulongtobuf( p, rec->r.trust.validlist); p += 4;
1708       break;
1709
1710     case RECTYPE_VALID:
1711       memcpy (p, rec->r.valid.namehash, 20); p += 20;
1712       *p++ = rec->r.valid.validity;
1713       ulongtobuf( p, rec->r.valid.next); p += 4;
1714       *p++ = rec->r.valid.full_count;
1715       *p++ = rec->r.valid.marginal_count;
1716       break;
1717
1718     default:
1719       BUG();
1720     }
1721
1722   rc = put_record_into_cache (recnum, buf);
1723   if (rc)
1724     ;
1725   else if (rec->rectype == RECTYPE_TRUST)
1726     rc = update_trusthashtbl (ctrl, rec);
1727
1728   return rc;
1729 }
1730
1731
1732 /*
1733  * Delete the record at record number RECNUm from the trustdb.
1734  *
1735  * Return: 0 on success or an error code.
1736  */
1737 int
1738 tdbio_delete_record (ctrl_t ctrl, ulong recnum)
1739 {
1740   TRUSTREC vr, rec;
1741   int rc;
1742
1743   /* Must read the record fist, so we can drop it from the hash tables */
1744   rc = tdbio_read_record (recnum, &rec, 0);
1745   if (rc)
1746     ;
1747   else if (rec.rectype == RECTYPE_TRUST)
1748     {
1749       rc = drop_from_hashtable (ctrl, get_trusthashrec (ctrl),
1750                                 rec.r.trust.fingerprint, 20, rec.recnum);
1751     }
1752
1753   if (rc)
1754     return rc;
1755
1756   /* Now we can change it to a free record.  */
1757   rc = tdbio_read_record (0, &vr, RECTYPE_VER);
1758   if (rc)
1759     log_fatal (_("%s: error reading version record: %s\n"),
1760                db_name, gpg_strerror (rc));
1761
1762   rec.recnum = recnum;
1763   rec.rectype = RECTYPE_FREE;
1764   rec.r.free.next = vr.r.ver.firstfree;
1765   vr.r.ver.firstfree = recnum;
1766   rc = tdbio_write_record (ctrl, &rec);
1767   if (!rc)
1768     rc = tdbio_write_record (ctrl, &vr);
1769
1770   return rc;
1771 }
1772
1773
1774 /*
1775  * Create a new record and return its record number.
1776  */
1777 ulong
1778 tdbio_new_recnum (ctrl_t ctrl)
1779 {
1780   off_t offset;
1781   ulong recnum;
1782   TRUSTREC vr, rec;
1783   int rc;
1784
1785   /* Look for unused records.  */
1786   rc = tdbio_read_record (0, &vr, RECTYPE_VER);
1787   if (rc)
1788     log_fatal( _("%s: error reading version record: %s\n"),
1789                db_name, gpg_strerror (rc));
1790   if (vr.r.ver.firstfree)
1791     {
1792       recnum = vr.r.ver.firstfree;
1793       rc = tdbio_read_record (recnum, &rec, RECTYPE_FREE);
1794       if (rc)
1795         log_fatal (_("%s: error reading free record: %s\n"),
1796                    db_name, gpg_strerror (rc));
1797       /* Update dir record.  */
1798       vr.r.ver.firstfree = rec.r.free.next;
1799       rc = tdbio_write_record (ctrl, &vr);
1800       if (rc)
1801         log_fatal (_("%s: error writing dir record: %s\n"),
1802                    db_name, gpg_strerror (rc));
1803       /* Zero out the new record.  */
1804       memset (&rec, 0, sizeof rec);
1805       rec.rectype = 0; /* Mark as unused record (actually already done
1806                           my the memset).  */
1807       rec.recnum = recnum;
1808       rc = tdbio_write_record (ctrl, &rec);
1809       if (rc)
1810         log_fatal (_("%s: failed to zero a record: %s\n"),
1811                    db_name, gpg_strerror (rc));
1812     }
1813   else /* Not found - append a new record.  */
1814     {
1815       offset = lseek (db_fd, 0, SEEK_END);
1816       if (offset == (off_t)(-1))
1817         log_fatal ("trustdb: lseek to end failed: %s\n", strerror (errno));
1818       recnum = offset / TRUST_RECORD_LEN;
1819       log_assert (recnum); /* This will never be the first record */
1820       /* We must write a record, so that the next call to this
1821        * function returns another recnum.  */
1822       memset (&rec, 0, sizeof rec);
1823       rec.rectype = 0; /* unused record */
1824       rec.recnum = recnum;
1825       rc = 0;
1826       if (lseek( db_fd, recnum * TRUST_RECORD_LEN, SEEK_SET) == -1)
1827         {
1828           rc = gpg_error_from_syserror ();
1829           log_error (_("trustdb rec %lu: lseek failed: %s\n"),
1830                      recnum, strerror (errno));
1831         }
1832       else
1833         {
1834           int n;
1835
1836           n = write (db_fd, &rec, TRUST_RECORD_LEN);
1837           if (n != TRUST_RECORD_LEN)
1838             {
1839               rc = gpg_error_from_syserror ();
1840               log_error (_("trustdb rec %lu: write failed (n=%d): %s\n"),
1841                          recnum, n, gpg_strerror (rc));
1842             }
1843         }
1844
1845       if (rc)
1846         log_fatal (_("%s: failed to append a record: %s\n"),
1847                    db_name, gpg_strerror (rc));
1848     }
1849
1850   return recnum ;
1851 }
1852
1853
1854
1855 /* Helper function for tdbio_search_trust_byfpr.  */
1856 static int
1857 cmp_trec_fpr ( const void *fpr, const TRUSTREC *rec )
1858 {
1859   return (rec->rectype == RECTYPE_TRUST
1860           && !memcmp (rec->r.trust.fingerprint, fpr, 20));
1861 }
1862
1863
1864 /*
1865  * Given a 20 byte FINGERPRINT search its trust record and return
1866  * that at REC.
1867  *
1868  * Return: 0 if found, GPG_ERR_NOT_FOUND, or another error code.
1869  */
1870 gpg_error_t
1871 tdbio_search_trust_byfpr (ctrl_t ctrl, const byte *fingerprint, TRUSTREC *rec)
1872 {
1873   int rc;
1874
1875   /* Locate the trust record using the hash table */
1876   rc = lookup_hashtable (get_trusthashrec (ctrl), fingerprint, 20,
1877                          cmp_trec_fpr, fingerprint, rec );
1878   return rc;
1879 }
1880
1881
1882 /*
1883  * Given a primary public key object PK search its trust record and
1884  * return that at REC.
1885  *
1886  * Return: 0 if found, GPG_ERR_NOT_FOUND, or another error code.
1887  */
1888 gpg_error_t
1889 tdbio_search_trust_bypk (ctrl_t ctrl, PKT_public_key *pk, TRUSTREC *rec)
1890 {
1891   byte fingerprint[MAX_FINGERPRINT_LEN];
1892   size_t fingerlen;
1893
1894   fingerprint_from_pk( pk, fingerprint, &fingerlen );
1895   for (; fingerlen < 20; fingerlen++)
1896     fingerprint[fingerlen] = 0;
1897   return tdbio_search_trust_byfpr (ctrl, fingerprint, rec);
1898 }
1899
1900
1901 /*
1902  * Terminate the process with a message about a corrupted trustdb.
1903  */
1904 void
1905 tdbio_invalid (void)
1906 {
1907   log_error (_("Error: The trustdb is corrupted.\n"));
1908   how_to_fix_the_trustdb ();
1909   g10_exit (2);
1910 }