gpg: Improve the keyblock cache's transparency.
[gnupg.git] / g10 / keydb.c
1 /* keydb.c - key database dispatcher
2  * Copyright (C) 2001-2013 Free Software Foundation, Inc.
3  * Coyrright (C) 2001-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 <assert.h>
27 #include <sys/types.h>
28 #include <sys/stat.h>
29 #include <unistd.h>
30
31 #include "gpg.h"
32 #include "util.h"
33 #include "options.h"
34 #include "main.h" /*try_make_homedir ()*/
35 #include "packet.h"
36 #include "keyring.h"
37 #include "../kbx/keybox.h"
38 #include "keydb.h"
39 #include "i18n.h"
40
41 static int active_handles;
42
43 typedef enum
44   {
45     KEYDB_RESOURCE_TYPE_NONE = 0,
46     KEYDB_RESOURCE_TYPE_KEYRING,
47     KEYDB_RESOURCE_TYPE_KEYBOX
48   } KeydbResourceType;
49 #define MAX_KEYDB_RESOURCES 40
50
51 struct resource_item
52 {
53   KeydbResourceType type;
54   union {
55     KEYRING_HANDLE kr;
56     KEYBOX_HANDLE kb;
57   } u;
58   void *token;
59 };
60
61 static struct resource_item all_resources[MAX_KEYDB_RESOURCES];
62 static int used_resources;
63 static void *primary_keyring=NULL;
64
65
66 /* This is a simple cache used to return the last result of a
67    successful fingerprint search.  This works only for keybox resources
68    because (due to lack of a copy_keyblock function) we need to store
69    an image of the keyblock which is fortunately instantly available
70    for keyboxes.  */
71 enum keyblock_cache_states {
72   KEYBLOCK_CACHE_EMPTY,
73   KEYBLOCK_CACHE_PREPARED,
74   KEYBLOCK_CACHE_FILLED
75 };
76
77 struct keyblock_cache {
78   enum keyblock_cache_states state;
79   byte fpr[MAX_FINGERPRINT_LEN];
80   iobuf_t iobuf; /* Image of the keyblock.  */
81   u32 *sigstatus;
82   int pk_no;
83   int uid_no;
84   /* Offset of the record in the keybox.  */
85   int resource;
86   off_t offset;
87 };
88
89
90 struct keydb_handle
91 {
92   /* When we locked all of the resources in ACTIVE (using keyring_lock
93      / keybox_lock, as appropriate).  */
94   int locked;
95
96   /* The index into ACTIVE of the resources in which the last search
97      result was found.  Initially -1.  */
98   int found;
99
100   /* Initially -1 (invalid).  This is used to save a search result and
101      later restore it as the selected result.  */
102   int saved_found;
103
104   /* The number of skipped long blobs since the last search
105      (keydb_search_reset).  */
106   unsigned long skipped_long_blobs;
107
108   /* If set, this disables the use of the keyblock cache.  */
109   int no_caching;
110
111   /* Whether the next search will be from the beginning of the
112      database (and thus consider all records).  */
113   int is_reset;
114
115   /* The "file position."  In our case, this is index of the current
116      resource in ACTIVE.  */
117   int current;
118
119   /* The number of resources in ACTIVE.  */
120   int used;
121
122   /* Cache of the last found and parsed key block (only used for
123      keyboxes, not keyrings).  */
124   struct keyblock_cache keyblock_cache;
125
126   /* Copy of ALL_RESOURCES when keydb_new is called.  */
127   struct resource_item active[MAX_KEYDB_RESOURCES];
128 };
129
130 /* Looking up keys is expensive.  To hide the cost, we cache whether
131    keys exist in the key database.  Then, if we know a key does not
132    exist, we don't have to spend time looking it up.  This
133    particularly helps the --list-sigs and --check-sigs commands.
134
135    The cache stores the results in a hash using separate chaining.
136    Concretely: we use the LSB of the keyid to index the hash table and
137    each bucket consists of a linked list of entries.  An entry
138    consists of the 64-bit key id.  If a key id is not in the cache,
139    then we don't know whether it is in the DB or not.
140
141    To simplify the cache consistency protocol, we simply flush the
142    whole cache whenever a key is inserted or updated.  */
143
144 #define KID_NOT_FOUND_CACHE_BUCKETS 256
145 static struct kid_not_found_cache_bucket *
146   kid_not_found_cache[KID_NOT_FOUND_CACHE_BUCKETS];
147
148 /* The total number of entries in the hash table.  */
149 static unsigned int kid_not_found_cache_count;
150
151 struct kid_not_found_cache_bucket
152 {
153   struct kid_not_found_cache_bucket *next;
154   u32 kid[2];
155 };
156
157
158 static int lock_all (KEYDB_HANDLE hd);
159 static void unlock_all (KEYDB_HANDLE hd);
160
161
162 /* Check whether the keyid KID is in key id is definitely not in the
163    database.
164
165    Returns:
166
167      0 - Indeterminate: the key id is not in the cache; we don't know
168          whether the key is in the database or not.  If you want a
169          definitive answer, you'll need to perform a lookup.
170
171      1 - There is definitely no key with this key id in the database.
172          We searched for a key with this key id previously, but we
173          didn't find it in the database.  */
174 static int
175 kid_not_found_p (u32 *kid)
176 {
177   struct kid_not_found_cache_bucket *k;
178
179   for (k = kid_not_found_cache[kid[0] % KID_NOT_FOUND_CACHE_BUCKETS]; k; k = k->next)
180     if (k->kid[0] == kid[0] && k->kid[1] == kid[1])
181       {
182         if (DBG_CACHE)
183           log_debug ("keydb: kid_not_found_p (%08lx%08lx) => not in DB\n",
184                      (ulong)kid[0], (ulong)kid[1]);
185         return 1;
186       }
187
188   if (DBG_CACHE)
189     log_debug ("keydb: kid_not_found_p (%08lx%08lx) => indeterminate\n",
190                (ulong)kid[0], (ulong)kid[1]);
191   return 0;
192 }
193
194
195 /* Insert the keyid KID into the kid_not_found_cache.  FOUND is whether
196    the key is in the key database or not.
197
198    Note this function does not check whether the key id is already in
199    the cache.  As such, kid_not_found_p() should be called first.  */
200 static void
201 kid_not_found_insert (u32 *kid)
202 {
203   struct kid_not_found_cache_bucket *k;
204
205   if (DBG_CACHE)
206     log_debug ("keydb: kid_not_found_insert (%08lx%08lx)\n",
207                (ulong)kid[0], (ulong)kid[1]);
208   k = xmalloc (sizeof *k);
209   k->kid[0] = kid[0];
210   k->kid[1] = kid[1];
211   k->next = kid_not_found_cache[kid[0] % KID_NOT_FOUND_CACHE_BUCKETS];
212   kid_not_found_cache[kid[0] % KID_NOT_FOUND_CACHE_BUCKETS] = k;
213   kid_not_found_cache_count++;
214 }
215
216
217 /* Flush the kid not found cache.  */
218 static void
219 kid_not_found_flush (void)
220 {
221   struct kid_not_found_cache_bucket *k, *knext;
222   int i;
223
224   if (DBG_CACHE)
225     log_debug ("keydb: kid_not_found_flush\n");
226
227   if (!kid_not_found_cache_count)
228     return;
229
230   for (i=0; i < DIM(kid_not_found_cache); i++)
231     {
232       for (k = kid_not_found_cache[i]; k; k = knext)
233         {
234           knext = k->next;
235           xfree (k);
236         }
237       kid_not_found_cache[i] = NULL;
238     }
239   kid_not_found_cache_count = 0;
240 }
241
242
243 static void
244 keyblock_cache_clear (struct keydb_handle *hd)
245 {
246   hd->keyblock_cache.state = KEYBLOCK_CACHE_EMPTY;
247   xfree (hd->keyblock_cache.sigstatus);
248   hd->keyblock_cache.sigstatus = NULL;
249   iobuf_close (hd->keyblock_cache.iobuf);
250   hd->keyblock_cache.iobuf = NULL;
251   hd->keyblock_cache.resource = -1;
252   hd->keyblock_cache.offset = -1;
253 }
254
255
256 /* Handle the creation of a keyring or a keybox if it does not yet
257    exist.  Take into account that other processes might have the
258    keyring/keybox already locked.  This lock check does not work if
259    the directory itself is not yet available.  If IS_BOX is true the
260    filename is expected to refer to a keybox.  If FORCE_CREATE is true
261    the keyring or keybox will be created.
262
263    Return 0 if it is okay to access the specified file.  */
264 static int
265 maybe_create_keyring_or_box (char *filename, int is_box, int force_create)
266 {
267   dotlock_t lockhd = NULL;
268   IOBUF iobuf;
269   int rc;
270   mode_t oldmask;
271   char *last_slash_in_filename;
272   int save_slash;
273
274   /* A quick test whether the filename already exists. */
275   if (!access (filename, F_OK))
276     return 0;
277
278   /* If we don't want to create a new file at all, there is no need to
279      go any further - bail out right here.  */
280   if (!force_create)
281     return gpg_error (GPG_ERR_ENOENT);
282
283   /* First of all we try to create the home directory.  Note, that we
284      don't do any locking here because any sane application of gpg
285      would create the home directory by itself and not rely on gpg's
286      tricky auto-creation which is anyway only done for certain home
287      directory name pattern. */
288   last_slash_in_filename = strrchr (filename, DIRSEP_C);
289 #if HAVE_W32_SYSTEM
290   {
291     /* Windows may either have a slash or a backslash.  Take care of it.  */
292     char *p = strrchr (filename, '/');
293     if (!last_slash_in_filename || p > last_slash_in_filename)
294       last_slash_in_filename = p;
295   }
296 #endif /*HAVE_W32_SYSTEM*/
297   if (!last_slash_in_filename)
298     return gpg_error (GPG_ERR_ENOENT);  /* No slash at all - should
299                                            not happen though.  */
300   save_slash = *last_slash_in_filename;
301   *last_slash_in_filename = 0;
302   if (access(filename, F_OK))
303     {
304       static int tried;
305
306       if (!tried)
307         {
308           tried = 1;
309           try_make_homedir (filename);
310         }
311       if (access (filename, F_OK))
312         {
313           rc = gpg_error_from_syserror ();
314           *last_slash_in_filename = save_slash;
315           goto leave;
316         }
317     }
318   *last_slash_in_filename = save_slash;
319
320   /* To avoid races with other instances of gpg trying to create or
321      update the keyring (it is removed during an update for a short
322      time), we do the next stuff in a locked state. */
323   lockhd = dotlock_create (filename, 0);
324   if (!lockhd)
325     {
326       rc = gpg_error_from_syserror ();
327       /* A reason for this to fail is that the directory is not
328          writable. However, this whole locking stuff does not make
329          sense if this is the case. An empty non-writable directory
330          with no keyring is not really useful at all. */
331       if (opt.verbose)
332         log_info ("can't allocate lock for '%s': %s\n",
333                   filename, gpg_strerror (rc));
334
335       if (!force_create)
336         return gpg_error (GPG_ERR_ENOENT);  /* Won't happen.  */
337       else
338         return rc;
339     }
340
341   if ( dotlock_take (lockhd, -1) )
342     {
343       rc = gpg_error_from_syserror ();
344       /* This is something bad.  Probably a stale lockfile.  */
345       log_info ("can't lock '%s': %s\n", filename, gpg_strerror (rc));
346       goto leave;
347     }
348
349   /* Now the real test while we are locked. */
350   if (!access (filename, F_OK))
351     {
352       rc = 0;  /* Okay, we may access the file now.  */
353       goto leave;
354     }
355
356   /* The file does not yet exist, create it now. */
357   oldmask = umask (077);
358   if (is_secured_filename (filename))
359     {
360       iobuf = NULL;
361       gpg_err_set_errno (EPERM);
362     }
363   else
364     iobuf = iobuf_create (filename, 0);
365   umask (oldmask);
366   if (!iobuf)
367     {
368       rc = gpg_error_from_syserror ();
369       if (is_box)
370         log_error (_("error creating keybox '%s': %s\n"),
371                    filename, gpg_strerror (rc));
372       else
373         log_error (_("error creating keyring '%s': %s\n"),
374                    filename, gpg_strerror (rc));
375       goto leave;
376     }
377
378   iobuf_close (iobuf);
379   /* Must invalidate that ugly cache */
380   iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, filename);
381
382   /* Make sure that at least one record is in a new keybox file, so
383      that the detection magic will work the next time it is used.  */
384   if (is_box)
385     {
386       FILE *fp = fopen (filename, "w");
387       if (!fp)
388         rc = gpg_error_from_syserror ();
389       else
390         {
391           rc = _keybox_write_header_blob (fp, 1);
392           fclose (fp);
393         }
394       if (rc)
395         {
396           if (is_box)
397             log_error (_("error creating keybox '%s': %s\n"),
398                        filename, gpg_strerror (rc));
399           else
400             log_error (_("error creating keyring '%s': %s\n"),
401                        filename, gpg_strerror (rc));
402           goto leave;
403         }
404     }
405
406   if (!opt.quiet)
407     {
408       if (is_box)
409         log_info (_("keybox '%s' created\n"), filename);
410       else
411         log_info (_("keyring '%s' created\n"), filename);
412     }
413
414   rc = 0;
415
416  leave:
417   if (lockhd)
418     {
419       dotlock_release (lockhd);
420       dotlock_destroy (lockhd);
421     }
422   return rc;
423 }
424
425
426 /* Helper for keydb_add_resource.  Opens FILENAME to figure out the
427    resource type.
428
429    Returns the specified file's likely type.  If the file does not
430    exist, returns KEYDB_RESOURCE_TYPE_NONE and sets *R_FOUND to 0.
431    Otherwise, tries to figure out the file's type.  This is either
432    KEYDB_RESOURCE_TYPE_KEYBOX, KEYDB_RESOURCE_TYPE_KEYRING or
433    KEYDB_RESOURCE_TYPE_KEYNONE.  If the file is a keybox and it has
434    the OpenPGP flag set, then R_OPENPGP is also set.  */
435 static KeydbResourceType
436 rt_from_file (const char *filename, int *r_found, int *r_openpgp)
437 {
438   u32 magic;
439   unsigned char verbuf[4];
440   FILE *fp;
441   KeydbResourceType rt = KEYDB_RESOURCE_TYPE_NONE;
442
443   *r_found = *r_openpgp = 0;
444   fp = fopen (filename, "rb");
445   if (fp)
446     {
447       *r_found = 1;
448
449       if (fread (&magic, 4, 1, fp) == 1 )
450         {
451           if (magic == 0x13579ace || magic == 0xce9a5713)
452             ; /* GDBM magic - not anymore supported. */
453           else if (fread (&verbuf, 4, 1, fp) == 1
454                    && verbuf[0] == 1
455                    && fread (&magic, 4, 1, fp) == 1
456                    && !memcmp (&magic, "KBXf", 4))
457             {
458               if ((verbuf[3] & 0x02))
459                 *r_openpgp = 1;
460               rt = KEYDB_RESOURCE_TYPE_KEYBOX;
461             }
462           else
463             rt = KEYDB_RESOURCE_TYPE_KEYRING;
464         }
465       else /* Maybe empty: assume keyring. */
466         rt = KEYDB_RESOURCE_TYPE_KEYRING;
467
468       fclose (fp);
469     }
470
471   return rt;
472 }
473 \f
474 char *
475 keydb_search_desc_dump (struct keydb_search_desc *desc)
476 {
477   char b[MAX_FORMATTED_FINGERPRINT_LEN + 1];
478   char fpr[2 * MAX_FINGERPRINT_LEN + 1];
479
480   switch (desc->mode)
481     {
482     case KEYDB_SEARCH_MODE_EXACT:
483       return xasprintf ("EXACT: '%s'", desc->u.name);
484     case KEYDB_SEARCH_MODE_SUBSTR:
485       return xasprintf ("SUBSTR: '%s'", desc->u.name);
486     case KEYDB_SEARCH_MODE_MAIL:
487       return xasprintf ("MAIL: '%s'", desc->u.name);
488     case KEYDB_SEARCH_MODE_MAILSUB:
489       return xasprintf ("MAILSUB: '%s'", desc->u.name);
490     case KEYDB_SEARCH_MODE_MAILEND:
491       return xasprintf ("MAILEND: '%s'", desc->u.name);
492     case KEYDB_SEARCH_MODE_WORDS:
493       return xasprintf ("WORDS: '%s'", desc->u.name);
494     case KEYDB_SEARCH_MODE_SHORT_KID:
495       return xasprintf ("SHORT_KID: '%s'",
496                         format_keyid (desc->u.kid, KF_SHORT, b, sizeof (b)));
497     case KEYDB_SEARCH_MODE_LONG_KID:
498       return xasprintf ("LONG_KID: '%s'",
499                         format_keyid (desc->u.kid, KF_LONG, b, sizeof (b)));
500     case KEYDB_SEARCH_MODE_FPR16:
501       bin2hex (desc->u.fpr, 16, fpr);
502       return xasprintf ("FPR16: '%s'",
503                         format_hexfingerprint (fpr, b, sizeof (b)));
504     case KEYDB_SEARCH_MODE_FPR20:
505       bin2hex (desc->u.fpr, 20, fpr);
506       return xasprintf ("FPR20: '%s'",
507                         format_hexfingerprint (fpr, b, sizeof (b)));
508     case KEYDB_SEARCH_MODE_FPR:
509       bin2hex (desc->u.fpr, 20, fpr);
510       return xasprintf ("FPR: '%s'",
511                         format_hexfingerprint (fpr, b, sizeof (b)));
512     case KEYDB_SEARCH_MODE_ISSUER:
513       return xasprintf ("ISSUER: '%s'", desc->u.name);
514     case KEYDB_SEARCH_MODE_ISSUER_SN:
515       return xasprintf ("ISSUER_SN: '%*s'",
516                         (int) (desc->snlen == -1
517                                ? strlen (desc->sn) : desc->snlen),
518                         desc->sn);
519     case KEYDB_SEARCH_MODE_SN:
520       return xasprintf ("SN: '%*s'",
521                         (int) (desc->snlen == -1
522                                ? strlen (desc->sn) : desc->snlen),
523                         desc->sn);
524     case KEYDB_SEARCH_MODE_SUBJECT:
525       return xasprintf ("SUBJECT: '%s'", desc->u.name);
526     case KEYDB_SEARCH_MODE_KEYGRIP:
527       return xasprintf ("KEYGRIP: %s", desc->u.grip);
528     case KEYDB_SEARCH_MODE_FIRST:
529       return xasprintf ("FIRST");
530     case KEYDB_SEARCH_MODE_NEXT:
531       return xasprintf ("NEXT");
532     default:
533       return xasprintf ("Bad search mode (%d)", desc->mode);
534     }
535 }
536 \f
537 gpg_error_t
538 keydb_add_resource (const char *url, unsigned int flags)
539 {
540   /* Whether we have successfully registered a resource.  */
541   static int any_registered;
542   /* The file named by the URL (i.e., without the prototype).  */
543   const char *resname = url;
544
545   char *filename = NULL;
546   int create;
547   int read_only = !!(flags&KEYDB_RESOURCE_FLAG_READONLY);
548   int is_default = !!(flags&KEYDB_RESOURCE_FLAG_DEFAULT);
549   int is_gpgvdef = !!(flags&KEYDB_RESOURCE_FLAG_GPGVDEF);
550   int rc = 0;
551   KeydbResourceType rt = KEYDB_RESOURCE_TYPE_NONE;
552   void *token;
553
554   /* Create the resource if it is the first registered one.  */
555   create = (!read_only && !any_registered);
556
557   if (strlen (resname) > 11 && !strncmp( resname, "gnupg-ring:", 11) )
558     {
559       rt = KEYDB_RESOURCE_TYPE_KEYRING;
560       resname += 11;
561     }
562   else if (strlen (resname) > 10 && !strncmp (resname, "gnupg-kbx:", 10) )
563     {
564       rt = KEYDB_RESOURCE_TYPE_KEYBOX;
565       resname += 10;
566     }
567 #if !defined(HAVE_DRIVE_LETTERS) && !defined(__riscos__)
568   else if (strchr (resname, ':'))
569     {
570       log_error ("invalid key resource URL '%s'\n", url );
571       rc = gpg_error (GPG_ERR_GENERAL);
572       goto leave;
573     }
574 #endif /* !HAVE_DRIVE_LETTERS && !__riscos__ */
575
576   if (*resname != DIRSEP_C
577 #ifdef HAVE_W32_SYSTEM
578       && *resname != '/'  /* Fixme: does not handle drive letters.  */
579 #endif
580         )
581     {
582       /* Do tilde expansion etc. */
583       if (strchr (resname, DIRSEP_C)
584 #ifdef HAVE_W32_SYSTEM
585           || strchr (resname, '/')  /* Windows also accepts this.  */
586 #endif
587           )
588         filename = make_filename (resname, NULL);
589       else
590         filename = make_filename (opt.homedir, resname, NULL);
591     }
592   else
593     filename = xstrdup (resname);
594
595   /* See whether we can determine the filetype.  */
596   if (rt == KEYDB_RESOURCE_TYPE_NONE)
597     {
598       int found, openpgp_flag;
599       int pass = 0;
600       size_t filenamelen;
601
602     check_again:
603       filenamelen = strlen (filename);
604       rt = rt_from_file (filename, &found, &openpgp_flag);
605       if (found)
606         {
607           /* The file exists and we have the resource type in RT.
608
609              Now let us check whether in addition to the "pubring.gpg"
610              a "pubring.kbx with openpgp keys exists.  This is so that
611              GPG 2.1 will use an existing "pubring.kbx" by default iff
612              that file has been created or used by 2.1.  This check is
613              needed because after creation or use of the kbx file with
614              2.1 an older version of gpg may have created a new
615              pubring.gpg for its own use.  */
616           if (!pass && is_default && rt == KEYDB_RESOURCE_TYPE_KEYRING
617               && filenamelen > 4 && !strcmp (filename+filenamelen-4, ".gpg"))
618             {
619               strcpy (filename+filenamelen-4, ".kbx");
620               if ((rt_from_file (filename, &found, &openpgp_flag)
621                    == KEYDB_RESOURCE_TYPE_KEYBOX) && found && openpgp_flag)
622                 rt = KEYDB_RESOURCE_TYPE_KEYBOX;
623               else /* Restore filename */
624                 strcpy (filename+filenamelen-4, ".gpg");
625             }
626         }
627       else if (!pass && is_gpgvdef
628                && filenamelen > 4 && !strcmp (filename+filenamelen-4, ".kbx"))
629         {
630           /* Not found but gpgv's default "trustedkeys.kbx" file has
631              been requested.  We did not found it so now check whether
632              a "trustedkeys.gpg" file exists and use that instead.  */
633           KeydbResourceType rttmp;
634
635           strcpy (filename+filenamelen-4, ".gpg");
636           rttmp = rt_from_file (filename, &found, &openpgp_flag);
637           if (found
638               && ((rttmp == KEYDB_RESOURCE_TYPE_KEYBOX && openpgp_flag)
639                   || (rttmp == KEYDB_RESOURCE_TYPE_KEYRING)))
640             rt = rttmp;
641           else /* Restore filename */
642             strcpy (filename+filenamelen-4, ".kbx");
643         }
644       else if (!pass
645                && is_default && create
646                && filenamelen > 4 && !strcmp (filename+filenamelen-4, ".gpg"))
647         {
648           /* The file does not exist, the default resource has been
649              requested, the file shall be created, and the file has a
650              ".gpg" suffix.  Change the suffix to ".kbx" and try once
651              more.  This way we achieve that we open an existing
652              ".gpg" keyring, but create a new keybox file with an
653              ".kbx" suffix.  */
654           strcpy (filename+filenamelen-4, ".kbx");
655           pass++;
656           goto check_again;
657         }
658       else /* No file yet: create keybox. */
659         rt = KEYDB_RESOURCE_TYPE_KEYBOX;
660     }
661
662   switch (rt)
663     {
664     case KEYDB_RESOURCE_TYPE_NONE:
665       log_error ("unknown type of key resource '%s'\n", url );
666       rc = gpg_error (GPG_ERR_GENERAL);
667       goto leave;
668
669     case KEYDB_RESOURCE_TYPE_KEYRING:
670       rc = maybe_create_keyring_or_box (filename, 0, create);
671       if (rc)
672         goto leave;
673
674       if (keyring_register_filename (filename, read_only, &token))
675         {
676           if (used_resources >= MAX_KEYDB_RESOURCES)
677             rc = gpg_error (GPG_ERR_RESOURCE_LIMIT);
678           else
679             {
680               if ((flags & KEYDB_RESOURCE_FLAG_PRIMARY))
681                 primary_keyring = token;
682               all_resources[used_resources].type = rt;
683               all_resources[used_resources].u.kr = NULL; /* Not used here */
684               all_resources[used_resources].token = token;
685               used_resources++;
686             }
687         }
688       else
689         {
690           /* This keyring was already registered, so ignore it.
691              However, we can still mark it as primary even if it was
692              already registered.  */
693           if ((flags & KEYDB_RESOURCE_FLAG_PRIMARY))
694             primary_keyring = token;
695         }
696       break;
697
698     case KEYDB_RESOURCE_TYPE_KEYBOX:
699       {
700         rc = maybe_create_keyring_or_box (filename, 1, create);
701         if (rc)
702           goto leave;
703
704         /* FIXME: How do we register a read-only keybox?  */
705         token = keybox_register_file (filename, 0);
706         if (token)
707           {
708             if (used_resources >= MAX_KEYDB_RESOURCES)
709               rc = gpg_error (GPG_ERR_RESOURCE_LIMIT);
710             else
711               {
712                 /* if ((flags & KEYDB_RESOURCE_FLAG_PRIMARY)) */
713                 /*   primary_keyring = token; */
714                 all_resources[used_resources].type = rt;
715                 all_resources[used_resources].u.kb = NULL; /* Not used here */
716                 all_resources[used_resources].token = token;
717
718                 /* FIXME: Do a compress run if needed and no other
719                    user is currently using the keybox. */
720
721                 used_resources++;
722               }
723           }
724         else
725           {
726             /* Already registered.  We will mark it as the primary key
727                if requested.  */
728             /* FIXME: How to do that?  Change the keybox interface?  */
729             /* if ((flags & KEYDB_RESOURCE_FLAG_PRIMARY)) */
730             /*   primary_keyring = token; */
731           }
732       }
733       break;
734
735       default:
736         log_error ("resource type of '%s' not supported\n", url);
737         rc = gpg_error (GPG_ERR_GENERAL);
738         goto leave;
739     }
740
741   /* fixme: check directory permissions and print a warning */
742
743  leave:
744   if (rc)
745     log_error (_("keyblock resource '%s': %s\n"), filename, gpg_strerror (rc));
746   else
747     any_registered = 1;
748   xfree (filename);
749   return rc;
750 }
751
752
753 void
754 keydb_dump_stats (void)
755 {
756   if (kid_not_found_cache_count)
757     log_info ("keydb: kid_not_found_cache: total: %u\n",
758               kid_not_found_cache_count);
759 }
760
761
762 /* Create a new database handle.  A database handle is similar to a
763    file handle: it contains a local file position.  This is used when
764    searching: subsequent searches resume where the previous search
765    left off.  To rewind the position, use keydb_search_reset().  This
766    function returns NULL on error, sets ERRNO, and prints an error
767    diagnostic. */
768 KEYDB_HANDLE
769 keydb_new (void)
770 {
771   KEYDB_HANDLE hd;
772   int i, j;
773   int die = 0;
774   int reterrno;
775
776   if (DBG_CLOCK)
777     log_clock ("keydb_new");
778
779   hd = xtrycalloc (1, sizeof *hd);
780   if (!hd)
781     goto leave;
782   hd->found = -1;
783   hd->saved_found = -1;
784   hd->is_reset = 1;
785
786   assert (used_resources <= MAX_KEYDB_RESOURCES);
787   for (i=j=0; ! die && i < used_resources; i++)
788     {
789       switch (all_resources[i].type)
790         {
791         case KEYDB_RESOURCE_TYPE_NONE: /* ignore */
792           break;
793         case KEYDB_RESOURCE_TYPE_KEYRING:
794           hd->active[j].type   = all_resources[i].type;
795           hd->active[j].token  = all_resources[i].token;
796           hd->active[j].u.kr = keyring_new (all_resources[i].token);
797           if (!hd->active[j].u.kr)
798             {
799               reterrno = errno;
800               die = 1;
801             }
802           j++;
803           break;
804         case KEYDB_RESOURCE_TYPE_KEYBOX:
805           hd->active[j].type   = all_resources[i].type;
806           hd->active[j].token  = all_resources[i].token;
807           hd->active[j].u.kb   = keybox_new_openpgp (all_resources[i].token, 0);
808           if (!hd->active[j].u.kb)
809             {
810               reterrno = errno;
811               die = 1;
812             }
813           j++;
814           break;
815         }
816     }
817   hd->used = j;
818
819   active_handles++;
820
821   if (die)
822     {
823       keydb_release (hd);
824       gpg_err_set_errno (reterrno);
825       hd = NULL;
826     }
827
828  leave:
829   if (!hd)
830     log_error (_("error opening key DB: %s\n"),
831                gpg_strerror (gpg_error_from_syserror()));
832
833   return hd;
834 }
835
836
837 void
838 keydb_release (KEYDB_HANDLE hd)
839 {
840   int i;
841
842   if (!hd)
843     return;
844   assert (active_handles > 0);
845   active_handles--;
846
847   unlock_all (hd);
848   for (i=0; i < hd->used; i++)
849     {
850       switch (hd->active[i].type)
851         {
852         case KEYDB_RESOURCE_TYPE_NONE:
853           break;
854         case KEYDB_RESOURCE_TYPE_KEYRING:
855           keyring_release (hd->active[i].u.kr);
856           break;
857         case KEYDB_RESOURCE_TYPE_KEYBOX:
858           keybox_release (hd->active[i].u.kb);
859           break;
860         }
861     }
862
863   xfree (hd);
864 }
865
866
867 void
868 keydb_disable_caching (KEYDB_HANDLE hd)
869 {
870   if (hd)
871     hd->no_caching = 1;
872 }
873
874
875 const char *
876 keydb_get_resource_name (KEYDB_HANDLE hd)
877 {
878   int idx;
879   const char *s = NULL;
880
881   if (!hd)
882     return NULL;
883
884   if ( hd->found >= 0 && hd->found < hd->used)
885     idx = hd->found;
886   else if ( hd->current >= 0 && hd->current < hd->used)
887     idx = hd->current;
888   else
889     idx = 0;
890
891   switch (hd->active[idx].type)
892     {
893     case KEYDB_RESOURCE_TYPE_NONE:
894       s = NULL;
895       break;
896     case KEYDB_RESOURCE_TYPE_KEYRING:
897       s = keyring_get_resource_name (hd->active[idx].u.kr);
898       break;
899     case KEYDB_RESOURCE_TYPE_KEYBOX:
900       s = keybox_get_resource_name (hd->active[idx].u.kb);
901       break;
902     }
903
904   return s? s: "";
905 }
906
907
908
909 static int
910 lock_all (KEYDB_HANDLE hd)
911 {
912   int i, rc = 0;
913
914   /* Fixme: This locking scheme may lead to a deadlock if the resources
915      are not added in the same order by all processes.  We are
916      currently only allowing one resource so it is not a problem.
917      [Oops: Who claimed the latter]
918
919      To fix this we need to use a lock file to protect lock_all.  */
920
921   for (i=0; !rc && i < hd->used; i++)
922     {
923       switch (hd->active[i].type)
924         {
925         case KEYDB_RESOURCE_TYPE_NONE:
926           break;
927         case KEYDB_RESOURCE_TYPE_KEYRING:
928           rc = keyring_lock (hd->active[i].u.kr, 1);
929           break;
930         case KEYDB_RESOURCE_TYPE_KEYBOX:
931           rc = keybox_lock (hd->active[i].u.kb, 1);
932           break;
933         }
934     }
935
936   if (rc)
937     {
938       /* Revert the already taken locks.  */
939       for (i--; i >= 0; i--)
940         {
941           switch (hd->active[i].type)
942             {
943             case KEYDB_RESOURCE_TYPE_NONE:
944               break;
945             case KEYDB_RESOURCE_TYPE_KEYRING:
946               keyring_lock (hd->active[i].u.kr, 0);
947               break;
948             case KEYDB_RESOURCE_TYPE_KEYBOX:
949               rc = keybox_lock (hd->active[i].u.kb, 0);
950               break;
951             }
952         }
953     }
954   else
955     hd->locked = 1;
956
957   return rc;
958 }
959
960
961 static void
962 unlock_all (KEYDB_HANDLE hd)
963 {
964   int i;
965
966   if (!hd->locked)
967     return;
968
969   for (i=hd->used-1; i >= 0; i--)
970     {
971       switch (hd->active[i].type)
972         {
973         case KEYDB_RESOURCE_TYPE_NONE:
974           break;
975         case KEYDB_RESOURCE_TYPE_KEYRING:
976           keyring_lock (hd->active[i].u.kr, 0);
977           break;
978         case KEYDB_RESOURCE_TYPE_KEYBOX:
979           keybox_lock (hd->active[i].u.kb, 0);
980           break;
981         }
982     }
983   hd->locked = 0;
984 }
985
986
987 \f
988 void
989 keydb_push_found_state (KEYDB_HANDLE hd)
990 {
991   if (!hd)
992     return;
993
994   if (hd->found < 0 || hd->found >= hd->used)
995     {
996       hd->saved_found = -1;
997       return;
998     }
999
1000   switch (hd->active[hd->found].type)
1001     {
1002     case KEYDB_RESOURCE_TYPE_NONE:
1003       break;
1004     case KEYDB_RESOURCE_TYPE_KEYRING:
1005       keyring_push_found_state (hd->active[hd->found].u.kr);
1006       break;
1007     case KEYDB_RESOURCE_TYPE_KEYBOX:
1008       keybox_push_found_state (hd->active[hd->found].u.kb);
1009       break;
1010     }
1011
1012   hd->saved_found = hd->found;
1013   hd->found = -1;
1014 }
1015
1016
1017 void
1018 keydb_pop_found_state (KEYDB_HANDLE hd)
1019 {
1020   if (!hd)
1021     return;
1022
1023   hd->found = hd->saved_found;
1024   hd->saved_found = -1;
1025   if (hd->found < 0 || hd->found >= hd->used)
1026     return;
1027
1028   switch (hd->active[hd->found].type)
1029     {
1030     case KEYDB_RESOURCE_TYPE_NONE:
1031       break;
1032     case KEYDB_RESOURCE_TYPE_KEYRING:
1033       keyring_pop_found_state (hd->active[hd->found].u.kr);
1034       break;
1035     case KEYDB_RESOURCE_TYPE_KEYBOX:
1036       keybox_pop_found_state (hd->active[hd->found].u.kb);
1037       break;
1038     }
1039 }
1040
1041
1042 \f
1043 static gpg_error_t
1044 parse_keyblock_image (iobuf_t iobuf, int pk_no, int uid_no,
1045                       const u32 *sigstatus, kbnode_t *r_keyblock)
1046 {
1047   gpg_error_t err;
1048   PACKET *pkt;
1049   kbnode_t keyblock = NULL;
1050   kbnode_t node, *tail;
1051   int in_cert, save_mode;
1052   u32 n_sigs;
1053   int pk_count, uid_count;
1054
1055   *r_keyblock = NULL;
1056
1057   pkt = xtrymalloc (sizeof *pkt);
1058   if (!pkt)
1059     return gpg_error_from_syserror ();
1060   init_packet (pkt);
1061   save_mode = set_packet_list_mode (0);
1062   in_cert = 0;
1063   n_sigs = 0;
1064   tail = NULL;
1065   pk_count = uid_count = 0;
1066   while ((err = parse_packet (iobuf, pkt)) != -1)
1067     {
1068       if (gpg_err_code (err) == GPG_ERR_UNKNOWN_PACKET)
1069         {
1070           free_packet (pkt);
1071           init_packet (pkt);
1072           continue;
1073         }
1074       if (err)
1075         {
1076           log_error ("parse_keyblock_image: read error: %s\n",
1077                      gpg_strerror (err));
1078           err = gpg_error (GPG_ERR_INV_KEYRING);
1079           break;
1080         }
1081
1082       /* Filter allowed packets.  */
1083       switch (pkt->pkttype)
1084         {
1085         case PKT_PUBLIC_KEY:
1086         case PKT_PUBLIC_SUBKEY:
1087         case PKT_SECRET_KEY:
1088         case PKT_SECRET_SUBKEY:
1089         case PKT_USER_ID:
1090         case PKT_ATTRIBUTE:
1091         case PKT_SIGNATURE:
1092           break; /* Allowed per RFC.  */
1093
1094         default:
1095           /* Note that can't allow ring trust packets here and some of
1096              the other GPG specific packets don't make sense either.  */
1097           log_error ("skipped packet of type %d in keybox\n",
1098                      (int)pkt->pkttype);
1099           free_packet(pkt);
1100           init_packet(pkt);
1101           continue;
1102         }
1103
1104       /* Other sanity checks.  */
1105       if (!in_cert && pkt->pkttype != PKT_PUBLIC_KEY)
1106         {
1107           log_error ("parse_keyblock_image: first packet in a keybox blob "
1108                      "is not a public key packet\n");
1109           err = gpg_error (GPG_ERR_INV_KEYRING);
1110           break;
1111         }
1112       if (in_cert && (pkt->pkttype == PKT_PUBLIC_KEY
1113                       || pkt->pkttype == PKT_SECRET_KEY))
1114         {
1115           log_error ("parse_keyblock_image: "
1116                      "multiple keyblocks in a keybox blob\n");
1117           err = gpg_error (GPG_ERR_INV_KEYRING);
1118           break;
1119         }
1120       in_cert = 1;
1121
1122       if (pkt->pkttype == PKT_SIGNATURE && sigstatus)
1123         {
1124           PKT_signature *sig = pkt->pkt.signature;
1125
1126           n_sigs++;
1127           if (n_sigs > sigstatus[0])
1128             {
1129               log_error ("parse_keyblock_image: "
1130                          "more signatures than found in the meta data\n");
1131               err = gpg_error (GPG_ERR_INV_KEYRING);
1132               break;
1133
1134             }
1135           if (sigstatus[n_sigs])
1136             {
1137               sig->flags.checked = 1;
1138               if (sigstatus[n_sigs] == 1 )
1139                 ; /* missing key */
1140               else if (sigstatus[n_sigs] == 2 )
1141                 ; /* bad signature */
1142               else if (sigstatus[n_sigs] < 0x10000000)
1143                 ; /* bad flag */
1144               else
1145                 {
1146                   sig->flags.valid = 1;
1147                   /* Fixme: Shall we set the expired flag here?  */
1148                 }
1149             }
1150         }
1151
1152       node = new_kbnode (pkt);
1153
1154       switch (pkt->pkttype)
1155         {
1156         case PKT_PUBLIC_KEY:
1157         case PKT_PUBLIC_SUBKEY:
1158         case PKT_SECRET_KEY:
1159         case PKT_SECRET_SUBKEY:
1160           if (++pk_count == pk_no)
1161             node->flag |= 1;
1162           break;
1163
1164         case PKT_USER_ID:
1165           if (++uid_count == uid_no)
1166             node->flag |= 2;
1167           break;
1168
1169         default:
1170           break;
1171         }
1172
1173       if (!keyblock)
1174         keyblock = node;
1175       else
1176         *tail = node;
1177       tail = &node->next;
1178       pkt = xtrymalloc (sizeof *pkt);
1179       if (!pkt)
1180         {
1181           err = gpg_error_from_syserror ();
1182           break;
1183         }
1184       init_packet (pkt);
1185     }
1186   set_packet_list_mode (save_mode);
1187
1188   if (err == -1 && keyblock)
1189     err = 0; /* Got the entire keyblock.  */
1190
1191   if (!err && sigstatus && n_sigs != sigstatus[0])
1192     {
1193       log_error ("parse_keyblock_image: signature count does not match\n");
1194       err = gpg_error (GPG_ERR_INV_KEYRING);
1195     }
1196
1197   if (err)
1198     release_kbnode (keyblock);
1199   else
1200     *r_keyblock = keyblock;
1201   free_packet (pkt);
1202   xfree (pkt);
1203   return err;
1204 }
1205
1206
1207 gpg_error_t
1208 keydb_get_keyblock (KEYDB_HANDLE hd, KBNODE *ret_kb)
1209 {
1210   gpg_error_t err = 0;
1211
1212   *ret_kb = NULL;
1213
1214   if (!hd)
1215     return gpg_error (GPG_ERR_INV_ARG);
1216
1217   if (DBG_CLOCK)
1218     log_clock ("keydb_get_keybock enter");
1219
1220   if (hd->keyblock_cache.state == KEYBLOCK_CACHE_FILLED)
1221     {
1222       err = iobuf_seek (hd->keyblock_cache.iobuf, 0);
1223       if (err)
1224         {
1225           log_error ("keydb_get_keyblock: failed to rewind iobuf for cache\n");
1226           keyblock_cache_clear (hd);
1227         }
1228       else
1229         {
1230           err = parse_keyblock_image (hd->keyblock_cache.iobuf,
1231                                       hd->keyblock_cache.pk_no,
1232                                       hd->keyblock_cache.uid_no,
1233                                       hd->keyblock_cache.sigstatus,
1234                                       ret_kb);
1235           if (err)
1236             keyblock_cache_clear (hd);
1237           if (DBG_CLOCK)
1238             log_clock (err? "keydb_get_keyblock leave (cached, failed)"
1239                        : "keydb_get_keyblock leave (cached)");
1240           return err;
1241         }
1242     }
1243
1244   if (hd->found < 0 || hd->found >= hd->used)
1245     return gpg_error (GPG_ERR_VALUE_NOT_FOUND);
1246
1247   switch (hd->active[hd->found].type)
1248     {
1249     case KEYDB_RESOURCE_TYPE_NONE:
1250       err = gpg_error (GPG_ERR_GENERAL); /* oops */
1251       break;
1252     case KEYDB_RESOURCE_TYPE_KEYRING:
1253       err = keyring_get_keyblock (hd->active[hd->found].u.kr, ret_kb);
1254       break;
1255     case KEYDB_RESOURCE_TYPE_KEYBOX:
1256       {
1257         iobuf_t iobuf;
1258         u32 *sigstatus;
1259         int pk_no, uid_no;
1260
1261         err = keybox_get_keyblock (hd->active[hd->found].u.kb,
1262                                    &iobuf, &pk_no, &uid_no, &sigstatus);
1263         if (!err)
1264           {
1265             err = parse_keyblock_image (iobuf, pk_no, uid_no, sigstatus,
1266                                         ret_kb);
1267             if (!err && hd->keyblock_cache.state == KEYBLOCK_CACHE_PREPARED)
1268               {
1269                 hd->keyblock_cache.state     = KEYBLOCK_CACHE_FILLED;
1270                 hd->keyblock_cache.sigstatus = sigstatus;
1271                 hd->keyblock_cache.iobuf     = iobuf;
1272                 hd->keyblock_cache.pk_no     = pk_no;
1273                 hd->keyblock_cache.uid_no    = uid_no;
1274               }
1275             else
1276               {
1277                 xfree (sigstatus);
1278                 iobuf_close (iobuf);
1279               }
1280           }
1281       }
1282       break;
1283     }
1284
1285   if (hd->keyblock_cache.state != KEYBLOCK_CACHE_FILLED)
1286     keyblock_cache_clear (hd);
1287
1288   if (DBG_CLOCK)
1289     log_clock (err? "keydb_get_keyblock leave (failed)"
1290                : "keydb_get_keyblock leave");
1291   return err;
1292 }
1293
1294
1295 /* Build a keyblock image from KEYBLOCK.  Returns 0 on success and
1296    only then stores a new iobuf object at R_IOBUF and a signature
1297    status vecotor at R_SIGSTATUS.  */
1298 static gpg_error_t
1299 build_keyblock_image (kbnode_t keyblock, iobuf_t *r_iobuf, u32 **r_sigstatus)
1300 {
1301   gpg_error_t err;
1302   iobuf_t iobuf;
1303   kbnode_t kbctx, node;
1304   u32 n_sigs;
1305   u32 *sigstatus;
1306
1307   *r_iobuf = NULL;
1308   if (r_sigstatus)
1309     *r_sigstatus = NULL;
1310
1311   /* Allocate a vector for the signature cache.  This is an array of
1312      u32 values with the first value giving the number of elements to
1313      follow and each element descriping the cache status of the
1314      signature.  */
1315   if (r_sigstatus)
1316     {
1317       for (kbctx=NULL, n_sigs=0; (node = walk_kbnode (keyblock, &kbctx, 0));)
1318         if (node->pkt->pkttype == PKT_SIGNATURE)
1319           n_sigs++;
1320       sigstatus = xtrycalloc (1+n_sigs, sizeof *sigstatus);
1321       if (!sigstatus)
1322         return gpg_error_from_syserror ();
1323     }
1324   else
1325     sigstatus = NULL;
1326
1327   iobuf = iobuf_temp ();
1328   for (kbctx = NULL, n_sigs = 0; (node = walk_kbnode (keyblock, &kbctx, 0));)
1329     {
1330       /* Make sure to use only packets valid on a keyblock.  */
1331       switch (node->pkt->pkttype)
1332         {
1333         case PKT_PUBLIC_KEY:
1334         case PKT_PUBLIC_SUBKEY:
1335         case PKT_SIGNATURE:
1336         case PKT_USER_ID:
1337         case PKT_ATTRIBUTE:
1338           /* Note that we don't want the ring trust packets.  They are
1339              not useful. */
1340           break;
1341         default:
1342           continue;
1343         }
1344
1345       err = build_packet (iobuf, node->pkt);
1346       if (err)
1347         {
1348           iobuf_close (iobuf);
1349           return err;
1350         }
1351
1352       /* Build signature status vector.  */
1353       if (node->pkt->pkttype == PKT_SIGNATURE)
1354         {
1355           PKT_signature *sig = node->pkt->pkt.signature;
1356
1357           n_sigs++;
1358           /* Fixme: Detect the "missing key" status.  */
1359           if (sig->flags.checked && sigstatus)
1360             {
1361               if (sig->flags.valid)
1362                 {
1363                   if (!sig->expiredate)
1364                     sigstatus[n_sigs] = 0xffffffff;
1365                   else if (sig->expiredate < 0x1000000)
1366                     sigstatus[n_sigs] = 0x10000000;
1367                   else
1368                     sigstatus[n_sigs] = sig->expiredate;
1369                 }
1370               else
1371                 sigstatus[n_sigs] = 0x00000002; /* Bad signature.  */
1372             }
1373         }
1374     }
1375   if (sigstatus)
1376     sigstatus[0] = n_sigs;
1377
1378   *r_iobuf = iobuf;
1379   if (r_sigstatus)
1380     *r_sigstatus = sigstatus;
1381   return 0;
1382 }
1383
1384
1385 gpg_error_t
1386 keydb_update_keyblock (KEYDB_HANDLE hd, kbnode_t kb)
1387 {
1388   gpg_error_t err;
1389
1390   if (!hd)
1391     return gpg_error (GPG_ERR_INV_ARG);
1392
1393   kid_not_found_flush ();
1394   keyblock_cache_clear (hd);
1395
1396   if (hd->found < 0 || hd->found >= hd->used)
1397     return gpg_error (GPG_ERR_VALUE_NOT_FOUND);
1398
1399   if (opt.dry_run)
1400     return 0;
1401
1402   err = lock_all (hd);
1403   if (err)
1404     return err;
1405
1406   switch (hd->active[hd->found].type)
1407     {
1408     case KEYDB_RESOURCE_TYPE_NONE:
1409       err = gpg_error (GPG_ERR_GENERAL); /* oops */
1410       break;
1411     case KEYDB_RESOURCE_TYPE_KEYRING:
1412       err = keyring_update_keyblock (hd->active[hd->found].u.kr, kb);
1413       break;
1414     case KEYDB_RESOURCE_TYPE_KEYBOX:
1415       {
1416         iobuf_t iobuf;
1417
1418         err = build_keyblock_image (kb, &iobuf, NULL);
1419         if (!err)
1420           {
1421             err = keybox_update_keyblock (hd->active[hd->found].u.kb,
1422                                           iobuf_get_temp_buffer (iobuf),
1423                                           iobuf_get_temp_length (iobuf));
1424             iobuf_close (iobuf);
1425           }
1426       }
1427       break;
1428     }
1429
1430   unlock_all (hd);
1431   return err;
1432 }
1433
1434
1435 gpg_error_t
1436 keydb_insert_keyblock (KEYDB_HANDLE hd, kbnode_t kb)
1437 {
1438   gpg_error_t err;
1439   int idx;
1440
1441   if (!hd)
1442     return gpg_error (GPG_ERR_INV_ARG);
1443
1444   kid_not_found_flush ();
1445   keyblock_cache_clear (hd);
1446
1447   if (opt.dry_run)
1448     return 0;
1449
1450   if (hd->found >= 0 && hd->found < hd->used)
1451     idx = hd->found;
1452   else if (hd->current >= 0 && hd->current < hd->used)
1453     idx = hd->current;
1454   else
1455     return gpg_error (GPG_ERR_GENERAL);
1456
1457   err = lock_all (hd);
1458   if (err)
1459     return err;
1460
1461   switch (hd->active[idx].type)
1462     {
1463     case KEYDB_RESOURCE_TYPE_NONE:
1464       err = gpg_error (GPG_ERR_GENERAL); /* oops */
1465       break;
1466     case KEYDB_RESOURCE_TYPE_KEYRING:
1467       err = keyring_insert_keyblock (hd->active[idx].u.kr, kb);
1468       break;
1469     case KEYDB_RESOURCE_TYPE_KEYBOX:
1470       { /* We need to turn our kbnode_t list of packets into a proper
1471            keyblock first.  This is required by the OpenPGP key parser
1472            included in the keybox code.  Eventually we can change this
1473            kludge to have the caller pass the image.  */
1474         iobuf_t iobuf;
1475         u32 *sigstatus;
1476
1477         err = build_keyblock_image (kb, &iobuf, &sigstatus);
1478         if (!err)
1479           {
1480             err = keybox_insert_keyblock (hd->active[idx].u.kb,
1481                                           iobuf_get_temp_buffer (iobuf),
1482                                           iobuf_get_temp_length (iobuf),
1483                                           sigstatus);
1484             xfree (sigstatus);
1485             iobuf_close (iobuf);
1486           }
1487       }
1488       break;
1489     }
1490
1491   unlock_all (hd);
1492   return err;
1493 }
1494
1495
1496 gpg_error_t
1497 keydb_delete_keyblock (KEYDB_HANDLE hd)
1498 {
1499   gpg_error_t rc;
1500
1501   if (!hd)
1502     return gpg_error (GPG_ERR_INV_ARG);
1503
1504   kid_not_found_flush ();
1505   keyblock_cache_clear (hd);
1506
1507   if (hd->found < 0 || hd->found >= hd->used)
1508     return gpg_error (GPG_ERR_VALUE_NOT_FOUND);
1509
1510   if (opt.dry_run)
1511     return 0;
1512
1513   rc = lock_all (hd);
1514   if (rc)
1515     return rc;
1516
1517   switch (hd->active[hd->found].type)
1518     {
1519     case KEYDB_RESOURCE_TYPE_NONE:
1520       rc = gpg_error (GPG_ERR_GENERAL);
1521       break;
1522     case KEYDB_RESOURCE_TYPE_KEYRING:
1523       rc = keyring_delete_keyblock (hd->active[hd->found].u.kr);
1524       break;
1525     case KEYDB_RESOURCE_TYPE_KEYBOX:
1526       rc = keybox_delete (hd->active[hd->found].u.kb);
1527       break;
1528     }
1529
1530   unlock_all (hd);
1531   return rc;
1532 }
1533
1534
1535 \f
1536 gpg_error_t
1537 keydb_locate_writable (KEYDB_HANDLE hd)
1538 {
1539   gpg_error_t rc;
1540
1541   if (!hd)
1542     return GPG_ERR_INV_ARG;
1543
1544   rc = keydb_search_reset (hd); /* this does reset hd->current */
1545   if (rc)
1546     return rc;
1547
1548   /* If we have a primary set, try that one first */
1549   if (primary_keyring)
1550     {
1551       for ( ; hd->current >= 0 && hd->current < hd->used; hd->current++)
1552         {
1553           if(hd->active[hd->current].token==primary_keyring)
1554             {
1555               if(keyring_is_writable (hd->active[hd->current].token))
1556                 return 0;
1557               else
1558                 break;
1559             }
1560         }
1561
1562       rc = keydb_search_reset (hd); /* this does reset hd->current */
1563       if (rc)
1564         return rc;
1565     }
1566
1567   for ( ; hd->current >= 0 && hd->current < hd->used; hd->current++)
1568     {
1569       switch (hd->active[hd->current].type)
1570         {
1571         case KEYDB_RESOURCE_TYPE_NONE:
1572           BUG();
1573           break;
1574         case KEYDB_RESOURCE_TYPE_KEYRING:
1575           if (keyring_is_writable (hd->active[hd->current].token))
1576             return 0; /* found (hd->current is set to it) */
1577           break;
1578         case KEYDB_RESOURCE_TYPE_KEYBOX:
1579           if (keybox_is_writable (hd->active[hd->current].token))
1580             return 0; /* found (hd->current is set to it) */
1581           break;
1582         }
1583     }
1584
1585   return gpg_error (GPG_ERR_NOT_FOUND);
1586 }
1587
1588 void
1589 keydb_rebuild_caches (int noisy)
1590 {
1591   int i, rc;
1592
1593   for (i=0; i < used_resources; i++)
1594     {
1595       if (!keyring_is_writable (all_resources[i].token))
1596         continue;
1597       switch (all_resources[i].type)
1598         {
1599         case KEYDB_RESOURCE_TYPE_NONE: /* ignore */
1600           break;
1601         case KEYDB_RESOURCE_TYPE_KEYRING:
1602           rc = keyring_rebuild_cache (all_resources[i].token,noisy);
1603           if (rc)
1604             log_error (_("failed to rebuild keyring cache: %s\n"),
1605                        gpg_strerror (rc));
1606           break;
1607         case KEYDB_RESOURCE_TYPE_KEYBOX:
1608           /* N/A.  */
1609           break;
1610         }
1611     }
1612 }
1613
1614
1615 unsigned long
1616 keydb_get_skipped_counter (KEYDB_HANDLE hd)
1617 {
1618   return hd ? hd->skipped_long_blobs : 0;
1619 }
1620
1621
1622 gpg_error_t
1623 keydb_search_reset (KEYDB_HANDLE hd)
1624 {
1625   gpg_error_t rc = 0;
1626   int i;
1627
1628   if (!hd)
1629     return gpg_error (GPG_ERR_INV_ARG);
1630
1631   keyblock_cache_clear (hd);
1632
1633   if (DBG_CLOCK)
1634     log_clock ("keydb_search_reset");
1635
1636   if (DBG_CACHE)
1637     log_debug ("keydb_search: reset  (hd=%p)", hd);
1638
1639   hd->skipped_long_blobs = 0;
1640   hd->current = 0;
1641   hd->found = -1;
1642   /* Now reset all resources.  */
1643   for (i=0; !rc && i < hd->used; i++)
1644     {
1645       switch (hd->active[i].type)
1646         {
1647         case KEYDB_RESOURCE_TYPE_NONE:
1648           break;
1649         case KEYDB_RESOURCE_TYPE_KEYRING:
1650           rc = keyring_search_reset (hd->active[i].u.kr);
1651           break;
1652         case KEYDB_RESOURCE_TYPE_KEYBOX:
1653           rc = keybox_search_reset (hd->active[i].u.kb);
1654           break;
1655         }
1656     }
1657   hd->is_reset = 1;
1658   return rc;
1659 }
1660
1661
1662 gpg_error_t
1663 keydb_search (KEYDB_HANDLE hd, KEYDB_SEARCH_DESC *desc,
1664               size_t ndesc, size_t *descindex)
1665 {
1666   int i;
1667   gpg_error_t rc;
1668   int was_reset = hd->is_reset;
1669   /* If an entry is already in the cache, then don't add it again.  */
1670   int already_in_cache = 0;
1671
1672   if (descindex)
1673     *descindex = 0; /* Make sure it is always set on return.  */
1674
1675   if (!hd)
1676     return gpg_error (GPG_ERR_INV_ARG);
1677
1678   if (DBG_CLOCK)
1679     log_clock ("keydb_search enter");
1680
1681   if (DBG_LOOKUP)
1682     {
1683       log_debug ("%s: %zd search descriptions:\n", __func__, ndesc);
1684       for (i = 0; i < ndesc; i ++)
1685         {
1686           char *t = keydb_search_desc_dump (&desc[i]);
1687           log_debug ("%s   %d: %s\n", __func__, i, t);
1688           xfree (t);
1689         }
1690     }
1691
1692
1693   if (ndesc == 1 && desc[0].mode == KEYDB_SEARCH_MODE_LONG_KID
1694       && (already_in_cache = kid_not_found_p (desc[0].u.kid)) == 1 )
1695     {
1696       if (DBG_CLOCK)
1697         log_clock ("keydb_search leave (not found, cached)");
1698       return gpg_error (GPG_ERR_NOT_FOUND);
1699     }
1700
1701   /* NB: If one of the exact search modes below is used in a loop to
1702      walk over all keys (with the same fingerprint) the caching must
1703      have been disabled for the handle.  */
1704   if (!hd->no_caching
1705       && ndesc == 1
1706       && (desc[0].mode == KEYDB_SEARCH_MODE_FPR20
1707           || desc[0].mode == KEYDB_SEARCH_MODE_FPR)
1708       && hd->keyblock_cache.state  == KEYBLOCK_CACHE_FILLED
1709       && !memcmp (hd->keyblock_cache.fpr, desc[0].u.fpr, 20)
1710       /* Make sure the current file position occurs before the cached
1711          result to avoid an infinite loop.  */
1712       && (hd->current < hd->keyblock_cache.resource
1713           || (hd->current == hd->keyblock_cache.resource
1714               && (keybox_offset (hd->active[hd->current].u.kb)
1715                   <= hd->keyblock_cache.offset))))
1716     {
1717       /* (DESCINDEX is already set).  */
1718       if (DBG_CLOCK)
1719         log_clock ("keydb_search leave (cached)");
1720
1721       hd->current = hd->keyblock_cache.resource;
1722       /* HD->KEYBLOCK_CACHE.OFFSET is the last byte in the record.
1723          Seek just beyond that.  */
1724       keybox_seek (hd->active[hd->current].u.kb,
1725                    hd->keyblock_cache.offset + 1);
1726       return 0;
1727     }
1728
1729   rc = -1;
1730   while ((rc == -1 || gpg_err_code (rc) == GPG_ERR_EOF)
1731          && hd->current >= 0 && hd->current < hd->used)
1732     {
1733       if (DBG_LOOKUP)
1734         log_debug ("%s: searching %s (resource %d of %d)\n",
1735                    __func__,
1736                    hd->active[hd->current].type == KEYDB_RESOURCE_TYPE_KEYRING
1737                    ? "keyring"
1738                    : (hd->active[hd->current].type == KEYDB_RESOURCE_TYPE_KEYBOX
1739                       ? "keybox" : "unknown type"),
1740                    hd->current, hd->used);
1741
1742        switch (hd->active[hd->current].type)
1743         {
1744         case KEYDB_RESOURCE_TYPE_NONE:
1745           BUG(); /* we should never see it here */
1746           break;
1747         case KEYDB_RESOURCE_TYPE_KEYRING:
1748           rc = keyring_search (hd->active[hd->current].u.kr, desc,
1749                                ndesc, descindex, 1);
1750           break;
1751         case KEYDB_RESOURCE_TYPE_KEYBOX:
1752           do
1753             rc = keybox_search (hd->active[hd->current].u.kb, desc,
1754                                 ndesc, KEYBOX_BLOBTYPE_PGP,
1755                                 descindex, &hd->skipped_long_blobs);
1756           while (rc == GPG_ERR_LEGACY_KEY);
1757           break;
1758         }
1759
1760       if (DBG_LOOKUP)
1761         log_debug ("%s: searched %s (resource %d of %d) => %s\n",
1762                    __func__,
1763                    hd->active[hd->current].type == KEYDB_RESOURCE_TYPE_KEYRING
1764                    ? "keyring"
1765                    : (hd->active[hd->current].type == KEYDB_RESOURCE_TYPE_KEYBOX
1766                       ? "keybox" : "unknown type"),
1767                    hd->current, hd->used,
1768                    rc == -1 ? "EOF" : gpg_strerror (rc));
1769
1770       if (rc == -1 || gpg_err_code (rc) == GPG_ERR_EOF)
1771         {
1772           /* EOF -> switch to next resource */
1773           hd->current++;
1774         }
1775       else if (!rc)
1776         hd->found = hd->current;
1777     }
1778   hd->is_reset = 0;
1779
1780   rc = ((rc == -1 || gpg_err_code (rc) == GPG_ERR_EOF)
1781         ? gpg_error (GPG_ERR_NOT_FOUND)
1782         : rc);
1783
1784   keyblock_cache_clear (hd);
1785   if (!hd->no_caching
1786       && !rc
1787       && ndesc == 1 && (desc[0].mode == KEYDB_SEARCH_MODE_FPR20
1788                         || desc[0].mode == KEYDB_SEARCH_MODE_FPR)
1789       && hd->active[hd->current].type == KEYDB_RESOURCE_TYPE_KEYBOX)
1790     {
1791       hd->keyblock_cache.state = KEYBLOCK_CACHE_PREPARED;
1792       hd->keyblock_cache.resource = hd->current;
1793       /* The current offset is at the start of the next record.  Since
1794          a record is at least 1 byte, we just use offset - 1, which is
1795          within the record.  */
1796       hd->keyblock_cache.offset
1797         = keybox_offset (hd->active[hd->current].u.kb) - 1;
1798       memcpy (hd->keyblock_cache.fpr, desc[0].u.fpr, 20);
1799     }
1800
1801   if (gpg_err_code (rc) == GPG_ERR_NOT_FOUND
1802       && ndesc == 1 && desc[0].mode == KEYDB_SEARCH_MODE_LONG_KID && was_reset
1803       && !already_in_cache)
1804     kid_not_found_insert (desc[0].u.kid);
1805
1806   if (DBG_CLOCK)
1807     log_clock (rc? "keydb_search leave (not found)"
1808                  : "keydb_search leave (found)");
1809   return rc;
1810 }
1811
1812
1813 gpg_error_t
1814 keydb_search_first (KEYDB_HANDLE hd)
1815 {
1816   gpg_error_t err;
1817   KEYDB_SEARCH_DESC desc;
1818
1819   err = keydb_search_reset (hd);
1820   if (err)
1821     return err;
1822
1823   memset (&desc, 0, sizeof desc);
1824   desc.mode = KEYDB_SEARCH_MODE_FIRST;
1825   return keydb_search (hd, &desc, 1, NULL);
1826 }
1827
1828
1829 gpg_error_t
1830 keydb_search_next (KEYDB_HANDLE hd)
1831 {
1832   KEYDB_SEARCH_DESC desc;
1833
1834   memset (&desc, 0, sizeof desc);
1835   desc.mode = KEYDB_SEARCH_MODE_NEXT;
1836   return keydb_search (hd, &desc, 1, NULL);
1837 }
1838
1839 gpg_error_t
1840 keydb_search_kid (KEYDB_HANDLE hd, u32 *kid)
1841 {
1842   KEYDB_SEARCH_DESC desc;
1843
1844   memset (&desc, 0, sizeof desc);
1845   desc.mode = KEYDB_SEARCH_MODE_LONG_KID;
1846   desc.u.kid[0] = kid[0];
1847   desc.u.kid[1] = kid[1];
1848   return keydb_search (hd, &desc, 1, NULL);
1849 }
1850
1851 gpg_error_t
1852 keydb_search_fpr (KEYDB_HANDLE hd, const byte *fpr)
1853 {
1854   KEYDB_SEARCH_DESC desc;
1855
1856   memset (&desc, 0, sizeof desc);
1857   desc.mode = KEYDB_SEARCH_MODE_FPR;
1858   memcpy (desc.u.fpr, fpr, MAX_FINGERPRINT_LEN);
1859   return keydb_search (hd, &desc, 1, NULL);
1860 }