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