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