gpg: The option --passphrase= can be empty.
[gnupg.git] / sm / keydb.c
1 /* keydb.c - key database dispatcher
2  * Copyright (C) 2001, 2003, 2004 Free Software Foundation, Inc.
3  * Copyright (C) 2014 g10 Code GmbH
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 <unistd.h>
29
30 #include "gpgsm.h"
31 #include "../kbx/keybox.h"
32 #include "keydb.h"
33 #include "../common/i18n.h"
34
35 static int active_handles;
36
37 typedef enum {
38     KEYDB_RESOURCE_TYPE_NONE = 0,
39     KEYDB_RESOURCE_TYPE_KEYBOX
40 } KeydbResourceType;
41 #define MAX_KEYDB_RESOURCES 20
42
43 struct resource_item {
44   KeydbResourceType type;
45   union {
46     KEYBOX_HANDLE kr;
47   } u;
48   void *token;
49 };
50
51 static struct resource_item all_resources[MAX_KEYDB_RESOURCES];
52 static int used_resources;
53
54 /* Whether we have successfully registered any resource.  */
55 static int any_registered;
56
57
58 struct keydb_handle {
59
60   /* If this flag is set the resources is locked.  */
61   int locked;
62
63   /* If this flag is set a lock will only be released by
64    * keydb_release.  */
65   int keep_lock;
66
67   int found;
68   int saved_found;
69   int current;
70   int is_ephemeral;
71   int used; /* items in active */
72   struct resource_item active[MAX_KEYDB_RESOURCES];
73 };
74
75
76 static int lock_all (KEYDB_HANDLE hd);
77 static void unlock_all (KEYDB_HANDLE hd);
78
79
80 static void
81 try_make_homedir (const char *fname)
82 {
83   const char *defhome = standard_homedir ();
84
85   /* Create the directory only if the supplied directory name is the
86      same as the default one.  This way we avoid to create arbitrary
87      directories when a non-default home directory is used.  To cope
88      with HOME, we do compare only the suffix if we see that the
89      default homedir does start with a tilde.  */
90   if ( opt.dry_run || opt.no_homedir_creation )
91     return;
92
93   if (
94 #ifdef HAVE_W32_SYSTEM
95       ( !compare_filenames (fname, defhome) )
96 #else
97       ( *defhome == '~'
98         && (strlen(fname) >= strlen (defhome+1)
99             && !strcmp(fname+strlen(fname)-strlen(defhome+1), defhome+1 ) ))
100       || (*defhome != '~'  && !compare_filenames( fname, defhome ) )
101 #endif
102       )
103     {
104       if (gnupg_mkdir (fname, "-rwx"))
105         log_info (_("can't create directory '%s': %s\n"),
106                   fname, strerror(errno) );
107       else if (!opt.quiet )
108         log_info (_("directory '%s' created\n"), fname);
109     }
110 }
111
112
113 /* Handle the creation of a keybox if it does not yet exist.  Take
114    into account that other processes might have the keybox already
115    locked.  This lock check does not work if the directory itself is
116    not yet available.  If R_CREATED is not NULL it will be set to true
117    if the function created a new keybox.  */
118 static gpg_error_t
119 maybe_create_keybox (char *filename, int force, int *r_created)
120 {
121   dotlock_t lockhd = NULL;
122   FILE *fp;
123   int rc;
124   mode_t oldmask;
125   char *last_slash_in_filename;
126   int save_slash;
127
128   if (r_created)
129     *r_created = 0;
130
131   /* A quick test whether the filename already exists. */
132   if (!access (filename, F_OK))
133     return !access (filename, R_OK)? 0 : gpg_error (GPG_ERR_EACCES);
134
135   /* If we don't want to create a new file at all, there is no need to
136      go any further - bail out right here.  */
137   if (!force)
138     return gpg_error (GPG_ERR_ENOENT);
139
140   /* First of all we try to create the home directory.  Note, that we
141      don't do any locking here because any sane application of gpg
142      would create the home directory by itself and not rely on gpg's
143      tricky auto-creation which is anyway only done for some home
144      directory name patterns. */
145   last_slash_in_filename = strrchr (filename, DIRSEP_C);
146 #if HAVE_W32_SYSTEM
147   {
148     /* Windows may either have a slash or a backslash.  Take care of it.  */
149     char *p = strrchr (filename, '/');
150     if (!last_slash_in_filename || p > last_slash_in_filename)
151       last_slash_in_filename = p;
152   }
153 #endif /*HAVE_W32_SYSTEM*/
154   if (!last_slash_in_filename)
155     return gpg_error (GPG_ERR_ENOENT);  /* No slash at all - should
156                                            not happen though.  */
157   save_slash = *last_slash_in_filename;
158   *last_slash_in_filename = 0;
159   if (access(filename, F_OK))
160     {
161       static int tried;
162
163       if (!tried)
164         {
165           tried = 1;
166           try_make_homedir (filename);
167         }
168       if (access (filename, F_OK))
169         {
170           rc = gpg_error_from_syserror ();
171           *last_slash_in_filename = save_slash;
172           goto leave;
173         }
174     }
175   *last_slash_in_filename = save_slash;
176
177   /* To avoid races with other instances of gpg trying to create or
178      update the keybox (it is removed during an update for a short
179      time), we do the next stuff in a locked state. */
180   lockhd = dotlock_create (filename, 0);
181   if (!lockhd)
182     {
183       /* A reason for this to fail is that the directory is not
184          writable. However, this whole locking stuff does not make
185          sense if this is the case. An empty non-writable directory
186          with no keyring is not really useful at all. */
187       if (opt.verbose)
188         log_info ("can't allocate lock for '%s'\n", filename );
189
190       if (!force)
191         return gpg_error (GPG_ERR_ENOENT);
192       else
193         return gpg_error (GPG_ERR_GENERAL);
194     }
195
196   if ( dotlock_take (lockhd, -1) )
197     {
198       /* This is something bad.  Probably a stale lockfile.  */
199       log_info ("can't lock '%s'\n", filename);
200       rc = gpg_error (GPG_ERR_GENERAL);
201       goto leave;
202     }
203
204   /* Now the real test while we are locked. */
205   if (!access(filename, F_OK))
206     {
207       rc = 0;  /* Okay, we may access the file now.  */
208       goto leave;
209     }
210
211   /* The file does not yet exist, create it now. */
212   oldmask = umask (077);
213   fp = fopen (filename, "wb");
214   if (!fp)
215     {
216       rc = gpg_error_from_syserror ();
217       umask (oldmask);
218       log_error (_("error creating keybox '%s': %s\n"),
219                  filename, gpg_strerror (rc));
220       goto leave;
221     }
222   umask (oldmask);
223
224   /* Make sure that at least one record is in a new keybox file, so
225      that the detection magic for OpenPGP keyboxes works the next time
226      it is used.  */
227   rc = _keybox_write_header_blob (fp, 0);
228   if (rc)
229     {
230       fclose (fp);
231       log_error (_("error creating keybox '%s': %s\n"),
232                  filename, gpg_strerror (rc));
233       goto leave;
234     }
235
236   if (!opt.quiet)
237     log_info (_("keybox '%s' created\n"), filename);
238   if (r_created)
239     *r_created = 1;
240
241   fclose (fp);
242   rc = 0;
243
244  leave:
245   if (lockhd)
246     {
247       dotlock_release (lockhd);
248       dotlock_destroy (lockhd);
249     }
250   return rc;
251 }
252
253
254 /*
255  * Register a resource (which currently may only be a keybox file).
256  * The first keybox which is added by this function is created if it
257  * does not exist.  If AUTO_CREATED is not NULL it will be set to true
258  * if the function has created a new keybox.
259  */
260 gpg_error_t
261 keydb_add_resource (ctrl_t ctrl, const char *url, int force, int *auto_created)
262 {
263   const char *resname = url;
264   char *filename = NULL;
265   gpg_error_t err = 0;
266   KeydbResourceType rt = KEYDB_RESOURCE_TYPE_NONE;
267
268   if (auto_created)
269     *auto_created = 0;
270
271   /* Do we have an URL?
272      gnupg-kbx:filename := this is a plain keybox
273      filename := See what it is, but create as plain keybox.
274   */
275   if (strlen (resname) > 10)
276     {
277       if (!strncmp (resname, "gnupg-kbx:", 10) )
278         {
279           rt = KEYDB_RESOURCE_TYPE_KEYBOX;
280           resname += 10;
281         }
282 #if !defined(HAVE_DRIVE_LETTERS) && !defined(__riscos__)
283       else if (strchr (resname, ':'))
284         {
285           log_error ("invalid key resource URL '%s'\n", url );
286           err = gpg_error (GPG_ERR_GENERAL);
287           goto leave;
288         }
289 #endif /* !HAVE_DRIVE_LETTERS && !__riscos__ */
290     }
291
292   if (*resname != DIRSEP_C )
293     { /* do tilde expansion etc */
294       if (strchr(resname, DIRSEP_C) )
295         filename = make_filename (resname, NULL);
296       else
297         filename = make_filename (gnupg_homedir (), resname, NULL);
298     }
299   else
300     filename = xstrdup (resname);
301
302   if (!force)
303     force = !any_registered;
304
305   /* see whether we can determine the filetype */
306   if (rt == KEYDB_RESOURCE_TYPE_NONE)
307     {
308       FILE *fp = fopen( filename, "rb" );
309
310       if (fp)
311         {
312           u32 magic;
313
314           /* FIXME: check for the keybox magic */
315           if (fread (&magic, 4, 1, fp) == 1 )
316             {
317               if (magic == 0x13579ace || magic == 0xce9a5713)
318                 ; /* GDBM magic - no more support */
319               else
320                 rt = KEYDB_RESOURCE_TYPE_KEYBOX;
321             }
322           else /* maybe empty: assume keybox */
323             rt = KEYDB_RESOURCE_TYPE_KEYBOX;
324           fclose (fp);
325         }
326       else /* no file yet: create keybox */
327         rt = KEYDB_RESOURCE_TYPE_KEYBOX;
328     }
329
330   switch (rt)
331     {
332     case KEYDB_RESOURCE_TYPE_NONE:
333       log_error ("unknown type of key resource '%s'\n", url );
334       err = gpg_error (GPG_ERR_GENERAL);
335       goto leave;
336
337     case KEYDB_RESOURCE_TYPE_KEYBOX:
338       err = maybe_create_keybox (filename, force, auto_created);
339       if (err)
340         goto leave;
341       /* Now register the file */
342       {
343         void *token;
344
345         err = keybox_register_file (filename, 0, &token);
346         if (gpg_err_code (err) == GPG_ERR_EEXIST)
347           ; /* Already registered - ignore.  */
348         else if (err)
349           ; /* Other error.  */
350         else if (used_resources >= MAX_KEYDB_RESOURCES)
351           err = gpg_error (GPG_ERR_RESOURCE_LIMIT);
352         else
353           {
354             KEYBOX_HANDLE kbxhd;
355
356             all_resources[used_resources].type = rt;
357             all_resources[used_resources].u.kr = NULL; /* Not used here */
358             all_resources[used_resources].token = token;
359
360             /* Do a compress run if needed and the keybox is not locked. */
361             kbxhd = keybox_new_x509 (token, 0);
362             if (kbxhd)
363               {
364                 if (!keybox_lock (kbxhd, 1, 0))
365                   keybox_compress (kbxhd);
366
367                 keybox_release (kbxhd);
368               }
369
370             used_resources++;
371           }
372       }
373       break;
374
375     default:
376       log_error ("resource type of '%s' not supported\n", url);
377       err = gpg_error (GPG_ERR_NOT_SUPPORTED);
378       goto leave;
379     }
380
381   /* fixme: check directory permissions and print a warning */
382
383  leave:
384   if (err)
385     {
386       log_error ("keyblock resource '%s': %s\n", filename, gpg_strerror (err));
387       gpgsm_status_with_error (ctrl, STATUS_ERROR,
388                                "add_keyblock_resource", err);
389     }
390   else
391     any_registered = 1;
392   xfree (filename);
393   return err;
394 }
395
396
397 KEYDB_HANDLE
398 keydb_new (void)
399 {
400   KEYDB_HANDLE hd;
401   int i, j;
402
403   if (DBG_CLOCK)
404     log_clock ("%s: enter\n", __func__);
405
406   hd = xcalloc (1, sizeof *hd);
407   hd->found = -1;
408   hd->saved_found = -1;
409
410   log_assert (used_resources <= MAX_KEYDB_RESOURCES);
411   for (i=j=0; i < used_resources; i++)
412     {
413       switch (all_resources[i].type)
414         {
415         case KEYDB_RESOURCE_TYPE_NONE: /* ignore */
416           break;
417         case KEYDB_RESOURCE_TYPE_KEYBOX:
418           hd->active[j].type   = all_resources[i].type;
419           hd->active[j].token  = all_resources[i].token;
420           hd->active[j].u.kr = keybox_new_x509 (all_resources[i].token, 0);
421           if (!hd->active[j].u.kr)
422             {
423               xfree (hd);
424               return NULL; /* fixme: release all previously allocated handles*/
425             }
426           j++;
427           break;
428         }
429     }
430   hd->used = j;
431
432   active_handles++;
433   if (DBG_CLOCK)
434     log_clock ("%s: leave (hd=%p)\n", __func__, hd);
435   return hd;
436 }
437
438 void
439 keydb_release (KEYDB_HANDLE hd)
440 {
441   int i;
442
443   if (!hd)
444     return;
445
446   if (DBG_CLOCK)
447     log_clock ("%s: enter (hd=%p)\n", __func__, hd);
448
449   log_assert (active_handles > 0);
450   active_handles--;
451
452   hd->keep_lock = 0;
453   unlock_all (hd);
454   for (i=0; i < hd->used; i++)
455     {
456       switch (hd->active[i].type)
457         {
458         case KEYDB_RESOURCE_TYPE_NONE:
459           break;
460         case KEYDB_RESOURCE_TYPE_KEYBOX:
461           keybox_release (hd->active[i].u.kr);
462           break;
463         }
464     }
465
466   xfree (hd);
467   if (DBG_CLOCK)
468     log_clock ("%s: leave\n", __func__);
469 }
470
471
472 /* Return the name of the current resource.  This is function first
473    looks for the last found found, then for the current search
474    position, and last returns the first available resource.  The
475    returned string is only valid as long as the handle exists.  This
476    function does only return NULL if no handle is specified, in all
477    other error cases an empty string is returned.  */
478 const char *
479 keydb_get_resource_name (KEYDB_HANDLE hd)
480 {
481   int idx;
482   const char *s = NULL;
483
484   if (!hd)
485     return NULL;
486
487   if ( hd->found >= 0 && hd->found < hd->used)
488     idx = hd->found;
489   else if ( hd->current >= 0 && hd->current < hd->used)
490     idx = hd->current;
491   else
492     idx = 0;
493
494   switch (hd->active[idx].type)
495     {
496     case KEYDB_RESOURCE_TYPE_NONE:
497       s = NULL;
498       break;
499     case KEYDB_RESOURCE_TYPE_KEYBOX:
500       s = keybox_get_resource_name (hd->active[idx].u.kr);
501       break;
502     }
503
504   return s? s: "";
505 }
506
507 /* Switch the handle into ephemeral mode and return the original value. */
508 int
509 keydb_set_ephemeral (KEYDB_HANDLE hd, int yes)
510 {
511   int i;
512
513   if (!hd)
514     return 0;
515
516   yes = !!yes;
517   if (hd->is_ephemeral != yes)
518     {
519       for (i=0; i < hd->used; i++)
520         {
521           switch (hd->active[i].type)
522             {
523             case KEYDB_RESOURCE_TYPE_NONE:
524               break;
525             case KEYDB_RESOURCE_TYPE_KEYBOX:
526               keybox_set_ephemeral (hd->active[i].u.kr, yes);
527               break;
528             }
529         }
530     }
531
532   i = hd->is_ephemeral;
533   hd->is_ephemeral = yes;
534   return i;
535 }
536
537
538 /* If the keyring has not yet been locked, lock it now.  This
539  * operation is required before any update operation; it is optional
540  * for an insert operation.  The lock is kept until a keydb_release so
541  * that internal unlock_all calls have no effect.  */
542 gpg_error_t
543 keydb_lock (KEYDB_HANDLE hd)
544 {
545   gpg_error_t err;
546
547   if (!hd)
548     return gpg_error (GPG_ERR_INV_HANDLE);
549
550   if (DBG_CLOCK)
551     log_clock ("%s: enter (hd=%p)\n", __func__, hd);
552   err = lock_all (hd);
553   if (!err)
554     hd->keep_lock = 1;
555
556   if (DBG_CLOCK)
557     log_clock ("%s: leave (err=%s)\n", __func__, gpg_strerror (err));
558   return err;
559 }
560
561
562 \f
563 static int
564 lock_all (KEYDB_HANDLE hd)
565 {
566   int i, rc = 0;
567
568   /* Fixme: This locking scheme may lead to deadlock if the resources
569      are not added in the same order by all processes.  We are
570      currently only allowing one resource so it is not a problem. */
571   for (i=0; i < hd->used; i++)
572     {
573       switch (hd->active[i].type)
574         {
575         case KEYDB_RESOURCE_TYPE_NONE:
576           break;
577         case KEYDB_RESOURCE_TYPE_KEYBOX:
578           rc = keybox_lock (hd->active[i].u.kr, 1, -1);
579           break;
580         }
581       if (rc)
582         break;
583     }
584
585     if (rc)
586       {
587         /* Revert the already set locks.  */
588         for (i--; i >= 0; i--)
589           {
590             switch (hd->active[i].type)
591               {
592               case KEYDB_RESOURCE_TYPE_NONE:
593                 break;
594               case KEYDB_RESOURCE_TYPE_KEYBOX:
595                 keybox_lock (hd->active[i].u.kr, 0, 0);
596                 break;
597               }
598           }
599       }
600     else
601       hd->locked = 1;
602
603     return rc;
604 }
605
606 static void
607 unlock_all (KEYDB_HANDLE hd)
608 {
609   int i;
610
611   if (!hd->locked || hd->keep_lock)
612     return;
613
614   for (i=hd->used-1; i >= 0; i--)
615     {
616       switch (hd->active[i].type)
617         {
618         case KEYDB_RESOURCE_TYPE_NONE:
619           break;
620         case KEYDB_RESOURCE_TYPE_KEYBOX:
621           keybox_lock (hd->active[i].u.kr, 0, 0);
622           break;
623         }
624     }
625   hd->locked = 0;
626 }
627
628
629 \f
630 /* Push the last found state if any.  */
631 void
632 keydb_push_found_state (KEYDB_HANDLE hd)
633 {
634   if (!hd)
635     return;
636
637   if (hd->found < 0 || hd->found >= hd->used)
638     {
639       hd->saved_found = -1;
640       return;
641     }
642
643   switch (hd->active[hd->found].type)
644     {
645     case KEYDB_RESOURCE_TYPE_NONE:
646       break;
647     case KEYDB_RESOURCE_TYPE_KEYBOX:
648       keybox_push_found_state (hd->active[hd->found].u.kr);
649       break;
650     }
651
652   hd->saved_found = hd->found;
653   hd->found = -1;
654   if (DBG_CLOCK)
655     log_clock ("%s: done (hd=%p)\n", __func__, hd);
656 }
657
658
659 /* Pop the last found state.  */
660 void
661 keydb_pop_found_state (KEYDB_HANDLE hd)
662 {
663   if (!hd)
664     return;
665
666   hd->found = hd->saved_found;
667   hd->saved_found = -1;
668   if (hd->found < 0 || hd->found >= hd->used)
669     return;
670
671   switch (hd->active[hd->found].type)
672     {
673     case KEYDB_RESOURCE_TYPE_NONE:
674       break;
675     case KEYDB_RESOURCE_TYPE_KEYBOX:
676       keybox_pop_found_state (hd->active[hd->found].u.kr);
677       break;
678     }
679   if (DBG_CLOCK)
680     log_clock ("%s: done (hd=%p)\n", __func__, hd);
681 }
682
683
684 \f
685 /*
686   Return the last found object.  Caller must free it.  The returned
687   keyblock has the kbode flag bit 0 set for the node with the public
688   key used to locate the keyblock or flag bit 1 set for the user ID
689   node.  */
690 int
691 keydb_get_cert (KEYDB_HANDLE hd, ksba_cert_t *r_cert)
692 {
693   int rc = 0;
694
695   if (!hd)
696     return gpg_error (GPG_ERR_INV_VALUE);
697
698   if (DBG_CLOCK)
699     log_clock ("%s: enter (hd=%p)\n", __func__, hd);
700
701   if ( hd->found < 0 || hd->found >= hd->used)
702     {
703       rc = -1; /* nothing found */
704       goto leave;
705     }
706
707   rc = GPG_ERR_BUG;
708   switch (hd->active[hd->found].type)
709     {
710     case KEYDB_RESOURCE_TYPE_NONE:
711       rc = gpg_error (GPG_ERR_GENERAL); /* oops */
712       break;
713     case KEYDB_RESOURCE_TYPE_KEYBOX:
714       rc = keybox_get_cert (hd->active[hd->found].u.kr, r_cert);
715       break;
716     }
717
718  leave:
719   if (DBG_CLOCK)
720     log_clock ("%s: leave (rc=%d)\n", __func__, rc);
721   return rc;
722 }
723
724
725 /* Return a flag of the last found object. WHICH is the flag requested;
726    it should be one of the KEYBOX_FLAG_ values.  If the operation is
727    successful, the flag value will be stored at the address given by
728    VALUE.  Return 0 on success or an error code. */
729 gpg_error_t
730 keydb_get_flags (KEYDB_HANDLE hd, int which, int idx, unsigned int *value)
731 {
732   gpg_error_t err;
733
734   if (!hd)
735     return gpg_error (GPG_ERR_INV_VALUE);
736
737   if (DBG_CLOCK)
738     log_clock ("%s: enter (hd=%p)\n", __func__, hd);
739
740   if ( hd->found < 0 || hd->found >= hd->used)
741     {
742       err = gpg_error (GPG_ERR_NOTHING_FOUND);
743       goto leave;
744     }
745
746   err = gpg_error (GPG_ERR_BUG);
747   switch (hd->active[hd->found].type)
748     {
749     case KEYDB_RESOURCE_TYPE_NONE:
750       err = gpg_error (GPG_ERR_GENERAL); /* oops */
751       break;
752     case KEYDB_RESOURCE_TYPE_KEYBOX:
753       err = keybox_get_flags (hd->active[hd->found].u.kr, which, idx, value);
754       break;
755     }
756
757  leave:
758   if (DBG_CLOCK)
759     log_clock ("%s: leave (err=%s)\n", __func__, gpg_strerror (err));
760   return err;
761 }
762
763
764 /* Set a flag of the last found object. WHICH is the flag to be set; it
765    should be one of the KEYBOX_FLAG_ values.  If the operation is
766    successful, the flag value will be stored in the keybox.  Note,
767    that some flag values can't be updated and thus may return an
768    error, some other flag values may be masked out before an update.
769    Returns 0 on success or an error code. */
770 gpg_error_t
771 keydb_set_flags (KEYDB_HANDLE hd, int which, int idx, unsigned int value)
772 {
773   gpg_error_t err = 0;
774
775   if (!hd)
776     return gpg_error (GPG_ERR_INV_VALUE);
777
778   if (DBG_CLOCK)
779     log_clock ("%s: enter (hd=%p)\n", __func__, hd);
780
781   if ( hd->found < 0 || hd->found >= hd->used)
782     {
783       err = gpg_error (GPG_ERR_NOTHING_FOUND);
784       goto leave;
785     }
786
787   if (!hd->locked)
788     {
789       err = gpg_error (GPG_ERR_NOT_LOCKED);
790       goto leave;
791     }
792
793   switch (hd->active[hd->found].type)
794     {
795     case KEYDB_RESOURCE_TYPE_NONE:
796       err = gpg_error (GPG_ERR_GENERAL); /* oops */
797       break;
798     case KEYDB_RESOURCE_TYPE_KEYBOX:
799       err = keybox_set_flags (hd->active[hd->found].u.kr, which, idx, value);
800       break;
801     }
802
803  leave:
804   if (DBG_CLOCK)
805     log_clock ("%s: leave (err=%s)\n", __func__, gpg_strerror (err));
806   return err;
807 }
808
809 /*
810  * Insert a new Certificate into one of the resources.
811  */
812 gpg_error_t
813 keydb_insert_cert (KEYDB_HANDLE hd, ksba_cert_t cert)
814 {
815   gpg_error_t err;
816   int idx;
817   unsigned char digest[20];
818
819   if (!hd)
820     return gpg_error (GPG_ERR_INV_VALUE);
821
822   if (opt.dry_run)
823     return 0;
824
825   if (DBG_CLOCK)
826     log_clock ("%s: enter (hd=%p)\n", __func__, hd);
827
828   if ( hd->found >= 0 && hd->found < hd->used)
829     idx = hd->found;
830   else if ( hd->current >= 0 && hd->current < hd->used)
831     idx = hd->current;
832   else
833     {
834       err = gpg_error (GPG_ERR_GENERAL);
835       goto leave;
836     }
837
838   if (!hd->locked)
839     {
840       err = gpg_error (GPG_ERR_NOT_LOCKED);
841       goto leave;
842     }
843
844   gpgsm_get_fingerprint (cert, GCRY_MD_SHA1, digest, NULL); /* kludge*/
845
846   err = gpg_error (GPG_ERR_BUG);
847   switch (hd->active[idx].type)
848     {
849     case KEYDB_RESOURCE_TYPE_NONE:
850       err = gpg_error (GPG_ERR_GENERAL);
851       break;
852     case KEYDB_RESOURCE_TYPE_KEYBOX:
853       err = keybox_insert_cert (hd->active[idx].u.kr, cert, digest);
854       break;
855     }
856
857   unlock_all (hd);
858
859  leave:
860   if (DBG_CLOCK)
861     log_clock ("%s: leave (err=%s)\n", __func__, gpg_strerror (err));
862   return err;
863 }
864
865
866
867 /* Update the current keyblock with KB.  */
868 /* Note: This function is currently not called.  */
869 gpg_error_t
870 keydb_update_cert (KEYDB_HANDLE hd, ksba_cert_t cert)
871 {
872   gpg_error_t err;
873   unsigned char digest[20];
874
875   if (!hd)
876     return gpg_error (GPG_ERR_INV_VALUE);
877
878   if ( hd->found < 0 || hd->found >= hd->used)
879     return gpg_error (GPG_ERR_NOT_FOUND);
880
881   if (opt.dry_run)
882     return 0;
883
884   if (DBG_CLOCK)
885     log_clock ("%s: enter (hd=%p)\n", __func__, hd);
886
887   err = lock_all (hd);
888   if (err)
889     goto leave;
890
891   gpgsm_get_fingerprint (cert, GCRY_MD_SHA1, digest, NULL); /* kludge*/
892
893   err = gpg_error (GPG_ERR_BUG);
894   switch (hd->active[hd->found].type)
895     {
896     case KEYDB_RESOURCE_TYPE_NONE:
897       err = gpg_error (GPG_ERR_GENERAL); /* oops */
898       break;
899     case KEYDB_RESOURCE_TYPE_KEYBOX:
900       err = keybox_update_cert (hd->active[hd->found].u.kr, cert, digest);
901       break;
902     }
903
904   unlock_all (hd);
905  leave:
906   if (DBG_CLOCK)
907     log_clock ("%s: leave (err=%s)\n", __func__, gpg_strerror (err));
908   return err;
909 }
910
911
912 /*
913  * The current keyblock or cert will be deleted.
914  */
915 gpg_error_t
916 keydb_delete (KEYDB_HANDLE hd)
917 {
918   gpg_error_t err;
919
920   if (!hd)
921     return gpg_error (GPG_ERR_INV_VALUE);
922
923   if ( hd->found < 0 || hd->found >= hd->used)
924     return gpg_error (GPG_ERR_NOT_FOUND);
925
926   if (opt.dry_run)
927     return 0;
928
929   if (DBG_CLOCK)
930     log_clock ("%s: enter (hd=%p)\n", __func__, hd);
931
932   if (!hd->locked)
933     {
934       err = gpg_error (GPG_ERR_NOT_LOCKED);
935       goto leave;
936     }
937
938   err = gpg_error (GPG_ERR_BUG);
939   switch (hd->active[hd->found].type)
940     {
941     case KEYDB_RESOURCE_TYPE_NONE:
942       err = gpg_error (GPG_ERR_GENERAL);
943       break;
944     case KEYDB_RESOURCE_TYPE_KEYBOX:
945       err = keybox_delete (hd->active[hd->found].u.kr);
946       break;
947     }
948
949   unlock_all (hd);
950
951  leave:
952   if (DBG_CLOCK)
953     log_clock ("%s: leave (err=%s)\n", __func__, gpg_strerror (err));
954   return err;
955 }
956
957
958 \f
959 /*
960  * Locate the default writable key resource, so that the next
961  * operation (which is only relevant for inserts) will be done on this
962  * resource.
963  */
964 int
965 keydb_locate_writable (KEYDB_HANDLE hd, const char *reserved)
966 {
967   int rc;
968
969   (void)reserved;
970
971   if (!hd)
972     return gpg_error (GPG_ERR_INV_VALUE);
973
974   rc = keydb_search_reset (hd); /* this does reset hd->current */
975   if (rc)
976     return rc;
977
978   for ( ; hd->current >= 0 && hd->current < hd->used; hd->current++)
979     {
980       switch (hd->active[hd->current].type)
981         {
982         case KEYDB_RESOURCE_TYPE_NONE:
983           BUG();
984           break;
985         case KEYDB_RESOURCE_TYPE_KEYBOX:
986           if (keybox_is_writable (hd->active[hd->current].token))
987             return 0; /* found (hd->current is set to it) */
988           break;
989         }
990     }
991
992   return -1;
993 }
994
995 /*
996  * Rebuild the caches of all key resources.
997  */
998 void
999 keydb_rebuild_caches (void)
1000 {
1001   int i;
1002
1003   for (i=0; i < used_resources; i++)
1004     {
1005       switch (all_resources[i].type)
1006         {
1007         case KEYDB_RESOURCE_TYPE_NONE: /* ignore */
1008           break;
1009         case KEYDB_RESOURCE_TYPE_KEYBOX:
1010 /*            rc = keybox_rebuild_cache (all_resources[i].token); */
1011 /*            if (rc) */
1012 /*              log_error (_("failed to rebuild keybox cache: %s\n"), */
1013 /*                         g10_errstr (rc)); */
1014           break;
1015         }
1016     }
1017 }
1018
1019
1020
1021 /*
1022  * Start the next search on this handle right at the beginning
1023  */
1024 gpg_error_t
1025 keydb_search_reset (KEYDB_HANDLE hd)
1026 {
1027   gpg_error_t err = 0;
1028   int i;
1029
1030   if (!hd)
1031     return gpg_error (GPG_ERR_INV_VALUE);
1032
1033   if (DBG_CLOCK)
1034     log_clock ("%s: enter (hd=%p)\n", __func__, hd);
1035
1036   hd->current = 0;
1037   hd->found = -1;
1038   /* and reset all resources */
1039   for (i=0; !err && i < hd->used; i++)
1040     {
1041       switch (hd->active[i].type)
1042         {
1043         case KEYDB_RESOURCE_TYPE_NONE:
1044           break;
1045         case KEYDB_RESOURCE_TYPE_KEYBOX:
1046           err = keybox_search_reset (hd->active[i].u.kr);
1047           break;
1048         }
1049     }
1050
1051   if (DBG_CLOCK)
1052     log_clock ("%s: leave (err=%s)\n", __func__, gpg_strerror (err));
1053   return err;
1054 }
1055
1056
1057 char *
1058 keydb_search_desc_dump (struct keydb_search_desc *desc)
1059 {
1060   char *fpr;
1061   char *result;
1062
1063   switch (desc->mode)
1064     {
1065     case KEYDB_SEARCH_MODE_EXACT:
1066       return xasprintf ("EXACT: '%s'", desc->u.name);
1067     case KEYDB_SEARCH_MODE_SUBSTR:
1068       return xasprintf ("SUBSTR: '%s'", desc->u.name);
1069     case KEYDB_SEARCH_MODE_MAIL:
1070       return xasprintf ("MAIL: '%s'", desc->u.name);
1071     case KEYDB_SEARCH_MODE_MAILSUB:
1072       return xasprintf ("MAILSUB: '%s'", desc->u.name);
1073     case KEYDB_SEARCH_MODE_MAILEND:
1074       return xasprintf ("MAILEND: '%s'", desc->u.name);
1075     case KEYDB_SEARCH_MODE_WORDS:
1076       return xasprintf ("WORDS: '%s'", desc->u.name);
1077     case KEYDB_SEARCH_MODE_SHORT_KID:
1078       return xasprintf ("SHORT_KID: '%08lX'", (ulong)desc->u.kid[1]);
1079     case KEYDB_SEARCH_MODE_LONG_KID:
1080       return xasprintf ("LONG_KID: '%08lX%08lX'",
1081                         (ulong)desc->u.kid[0], (ulong)desc->u.kid[1]);
1082     case KEYDB_SEARCH_MODE_FPR:
1083       fpr = bin2hexcolon (desc->u.fpr, desc->fprlen, NULL);
1084       result = xasprintf ("FPR%02d: '%s'", desc->fprlen, fpr);
1085       xfree (fpr);
1086       return result;
1087     case KEYDB_SEARCH_MODE_ISSUER:
1088       return xasprintf ("ISSUER: '%s'", desc->u.name);
1089     case KEYDB_SEARCH_MODE_ISSUER_SN:
1090       return xasprintf ("ISSUER_SN: '%*s'",
1091                         (int) (desc->snlen == -1
1092                                ? strlen (desc->sn) : desc->snlen),
1093                         desc->sn);
1094     case KEYDB_SEARCH_MODE_SN:
1095       return xasprintf ("SN: '%*s'",
1096                         (int) (desc->snlen == -1
1097                                ? strlen (desc->sn) : desc->snlen),
1098                         desc->sn);
1099     case KEYDB_SEARCH_MODE_SUBJECT:
1100       return xasprintf ("SUBJECT: '%s'", desc->u.name);
1101     case KEYDB_SEARCH_MODE_KEYGRIP:
1102       return xasprintf ("KEYGRIP: %s", desc->u.grip);
1103     case KEYDB_SEARCH_MODE_FIRST:
1104       return xasprintf ("FIRST");
1105     case KEYDB_SEARCH_MODE_NEXT:
1106       return xasprintf ("NEXT");
1107     default:
1108       return xasprintf ("Bad search mode (%d)", desc->mode);
1109     }
1110 }
1111
1112
1113 /*
1114  * Search through all keydb resources, starting at the current position,
1115  * for a keyblock which contains one of the keys described in the DESC array.
1116  */
1117 int
1118 keydb_search (ctrl_t ctrl, KEYDB_HANDLE hd,
1119               KEYDB_SEARCH_DESC *desc, size_t ndesc)
1120 {
1121   int rc = -1;
1122   unsigned long skipped;
1123   int i;
1124
1125   if (!hd)
1126     return gpg_error (GPG_ERR_INV_VALUE);
1127
1128   if (!any_registered)
1129     {
1130       gpgsm_status_with_error (ctrl, STATUS_ERROR, "keydb_search",
1131                                gpg_error (GPG_ERR_KEYRING_OPEN));
1132       return gpg_error (GPG_ERR_NOT_FOUND);
1133     }
1134
1135   if (DBG_CLOCK)
1136     log_clock ("%s: enter (hd=%p)\n", __func__, hd);
1137
1138   if (DBG_LOOKUP)
1139     {
1140       log_debug ("%s: %zd search description(s):\n", __func__, ndesc);
1141       for (i = 0; i < ndesc; i ++)
1142         {
1143           char *t = keydb_search_desc_dump (&desc[i]);
1144           log_debug ("%s:   %d: %s\n", __func__, i, t);
1145           xfree (t);
1146         }
1147     }
1148
1149   while ((rc == -1 || gpg_err_code (rc) == GPG_ERR_EOF)
1150          && hd->current >= 0 && hd->current < hd->used)
1151     {
1152       switch (hd->active[hd->current].type)
1153         {
1154         case KEYDB_RESOURCE_TYPE_NONE:
1155           BUG(); /* we should never see it here */
1156           break;
1157         case KEYDB_RESOURCE_TYPE_KEYBOX:
1158           rc = keybox_search (hd->active[hd->current].u.kr, desc, ndesc,
1159                               KEYBOX_BLOBTYPE_X509,
1160                               NULL, &skipped);
1161           break;
1162         }
1163
1164       if (DBG_LOOKUP)
1165         log_debug ("%s: searched %s (resource %d of %d) => %s\n",
1166                    __func__,
1167                    hd->active[hd->current].type == KEYDB_RESOURCE_TYPE_KEYBOX
1168                       ? "keybox" : "unknown type",
1169                    hd->current, hd->used,
1170                    rc == -1 ? "EOF" : gpg_strerror (rc));
1171
1172       if (rc == -1 || gpg_err_code (rc) == GPG_ERR_EOF)
1173         { /* EOF -> switch to next resource */
1174           hd->current++;
1175         }
1176       else if (!rc)
1177         hd->found = hd->current;
1178     }
1179
1180
1181   if (DBG_CLOCK)
1182     log_clock ("%s: leave (rc=%d)\n", __func__, rc);
1183   return rc;
1184 }
1185
1186
1187 int
1188 keydb_search_first (ctrl_t ctrl, KEYDB_HANDLE hd)
1189 {
1190   KEYDB_SEARCH_DESC desc;
1191
1192   memset (&desc, 0, sizeof desc);
1193   desc.mode = KEYDB_SEARCH_MODE_FIRST;
1194   return keydb_search (ctrl, hd, &desc, 1);
1195 }
1196
1197 int
1198 keydb_search_next (ctrl_t ctrl, KEYDB_HANDLE hd)
1199 {
1200   KEYDB_SEARCH_DESC desc;
1201
1202   memset (&desc, 0, sizeof desc);
1203   desc.mode = KEYDB_SEARCH_MODE_NEXT;
1204   return keydb_search (ctrl, hd, &desc, 1);
1205 }
1206
1207 int
1208 keydb_search_kid (ctrl_t ctrl, KEYDB_HANDLE hd, u32 *kid)
1209 {
1210   KEYDB_SEARCH_DESC desc;
1211
1212   (void)kid;
1213
1214   memset (&desc, 0, sizeof desc);
1215   desc.mode = KEYDB_SEARCH_MODE_LONG_KID;
1216   desc.u.kid[0] = kid[0];
1217   desc.u.kid[1] = kid[1];
1218   return keydb_search (ctrl, hd, &desc, 1);
1219 }
1220
1221 int
1222 keydb_search_fpr (ctrl_t ctrl, KEYDB_HANDLE hd, const byte *fpr)
1223 {
1224   KEYDB_SEARCH_DESC desc;
1225
1226   memset (&desc, 0, sizeof desc);
1227   desc.mode = KEYDB_SEARCH_MODE_FPR;
1228   memcpy (desc.u.fpr, fpr, 20);
1229   desc.fprlen = 20;
1230   return keydb_search (ctrl, hd, &desc, 1);
1231 }
1232
1233 int
1234 keydb_search_issuer (ctrl_t ctrl, KEYDB_HANDLE hd, const char *issuer)
1235 {
1236   KEYDB_SEARCH_DESC desc;
1237   int rc;
1238
1239   memset (&desc, 0, sizeof desc);
1240   desc.mode = KEYDB_SEARCH_MODE_ISSUER;
1241   desc.u.name = issuer;
1242   rc = keydb_search (ctrl, hd, &desc, 1);
1243   return rc;
1244 }
1245
1246 int
1247 keydb_search_issuer_sn (ctrl_t ctrl, KEYDB_HANDLE hd,
1248                         const char *issuer, ksba_const_sexp_t serial)
1249 {
1250   KEYDB_SEARCH_DESC desc;
1251   int rc;
1252   const unsigned char *s;
1253
1254   memset (&desc, 0, sizeof desc);
1255   desc.mode = KEYDB_SEARCH_MODE_ISSUER_SN;
1256   s = serial;
1257   if (*s !='(')
1258     return gpg_error (GPG_ERR_INV_VALUE);
1259   s++;
1260   for (desc.snlen = 0; digitp (s); s++)
1261     desc.snlen = 10*desc.snlen + atoi_1 (s);
1262   if (*s !=':')
1263     return gpg_error (GPG_ERR_INV_VALUE);
1264   desc.sn = s+1;
1265   desc.u.name = issuer;
1266   rc = keydb_search (ctrl, hd, &desc, 1);
1267   return rc;
1268 }
1269
1270 int
1271 keydb_search_subject (ctrl_t ctrl, KEYDB_HANDLE hd, const char *name)
1272 {
1273   KEYDB_SEARCH_DESC desc;
1274   int rc;
1275
1276   memset (&desc, 0, sizeof desc);
1277   desc.mode = KEYDB_SEARCH_MODE_SUBJECT;
1278   desc.u.name = name;
1279   rc = keydb_search (ctrl, hd, &desc, 1);
1280   return rc;
1281 }
1282
1283
1284 \f
1285 /* Store the certificate in the key DB but make sure that it does not
1286    already exists.  We do this simply by comparing the fingerprint.
1287    If EXISTED is not NULL it will be set to true if the certificate
1288    was already in the DB. */
1289 int
1290 keydb_store_cert (ctrl_t ctrl, ksba_cert_t cert, int ephemeral, int *existed)
1291 {
1292   KEYDB_HANDLE kh;
1293   int rc;
1294   unsigned char fpr[20];
1295
1296   if (existed)
1297     *existed = 0;
1298
1299   if (!gpgsm_get_fingerprint (cert, 0, fpr, NULL))
1300     {
1301       log_error (_("failed to get the fingerprint\n"));
1302       return gpg_error (GPG_ERR_GENERAL);
1303     }
1304
1305   kh = keydb_new ();
1306   if (!kh)
1307     {
1308       log_error (_("failed to allocate keyDB handle\n"));
1309       return gpg_error (GPG_ERR_ENOMEM);;
1310     }
1311
1312   /* Set the ephemeral flag so that the search looks at all
1313      records.  */
1314   keydb_set_ephemeral (kh, 1);
1315
1316   rc = lock_all (kh);
1317   if (rc)
1318     return rc;
1319
1320   rc = keydb_search_fpr (ctrl, kh, fpr);
1321   if (rc != -1)
1322     {
1323       keydb_release (kh);
1324       if (!rc)
1325         {
1326           if (existed)
1327             *existed = 1;
1328           if (!ephemeral)
1329             {
1330               /* Remove ephemeral flags from existing certificate to "store"
1331                  it permanently. */
1332               rc = keydb_set_cert_flags (ctrl, cert, 1, KEYBOX_FLAG_BLOB, 0,
1333                                          KEYBOX_FLAG_BLOB_EPHEMERAL, 0);
1334               if (rc)
1335                 {
1336                   log_error ("clearing ephemeral flag failed: %s\n",
1337                              gpg_strerror (rc));
1338                   return rc;
1339                 }
1340             }
1341           return 0; /* okay */
1342         }
1343       log_error (_("problem looking for existing certificate: %s\n"),
1344                  gpg_strerror (rc));
1345       return rc;
1346     }
1347
1348   /* Reset the ephemeral flag if not requested.  */
1349   if (!ephemeral)
1350     keydb_set_ephemeral (kh, 0);
1351
1352   rc = keydb_locate_writable (kh, 0);
1353   if (rc)
1354     {
1355       log_error (_("error finding writable keyDB: %s\n"), gpg_strerror (rc));
1356       keydb_release (kh);
1357       return rc;
1358     }
1359
1360   rc = keydb_insert_cert (kh, cert);
1361   if (rc)
1362     {
1363       log_error (_("error storing certificate: %s\n"), gpg_strerror (rc));
1364       keydb_release (kh);
1365       return rc;
1366     }
1367   keydb_release (kh);
1368   return 0;
1369 }
1370
1371
1372 /* This is basically keydb_set_flags but it implements a complete
1373    transaction by locating the certificate in the DB and updating the
1374    flags. */
1375 gpg_error_t
1376 keydb_set_cert_flags (ctrl_t ctrl, ksba_cert_t cert, int ephemeral,
1377                       int which, int idx,
1378                       unsigned int mask, unsigned int value)
1379 {
1380   KEYDB_HANDLE kh;
1381   gpg_error_t err;
1382   unsigned char fpr[20];
1383   unsigned int old_value;
1384
1385   if (!gpgsm_get_fingerprint (cert, 0, fpr, NULL))
1386     {
1387       log_error (_("failed to get the fingerprint\n"));
1388       return gpg_error (GPG_ERR_GENERAL);
1389     }
1390
1391   kh = keydb_new ();
1392   if (!kh)
1393     {
1394       log_error (_("failed to allocate keyDB handle\n"));
1395       return gpg_error (GPG_ERR_ENOMEM);;
1396     }
1397
1398   if (ephemeral)
1399     keydb_set_ephemeral (kh, 1);
1400
1401   err = keydb_lock (kh);
1402   if (err)
1403     {
1404       log_error (_("error locking keybox: %s\n"), gpg_strerror (err));
1405       keydb_release (kh);
1406       return err;
1407     }
1408
1409   err = keydb_search_fpr (ctrl, kh, fpr);
1410   if (err)
1411     {
1412       if (err == -1)
1413         err = gpg_error (GPG_ERR_NOT_FOUND);
1414       else
1415         log_error (_("problem re-searching certificate: %s\n"),
1416                    gpg_strerror (err));
1417       keydb_release (kh);
1418       return err;
1419     }
1420
1421   err = keydb_get_flags (kh, which, idx, &old_value);
1422   if (err)
1423     {
1424       log_error (_("error getting stored flags: %s\n"), gpg_strerror (err));
1425       keydb_release (kh);
1426       return err;
1427     }
1428
1429   value = ((old_value & ~mask) | (value & mask));
1430
1431   if (value != old_value)
1432     {
1433       err = keydb_set_flags (kh, which, idx, value);
1434       if (err)
1435         {
1436           log_error (_("error storing flags: %s\n"), gpg_strerror (err));
1437           keydb_release (kh);
1438           return err;
1439         }
1440     }
1441
1442   keydb_release (kh);
1443   return 0;
1444 }
1445
1446
1447 /* Reset all the certificate flags we have stored with the certificates
1448    for performance reasons. */
1449 void
1450 keydb_clear_some_cert_flags (ctrl_t ctrl, strlist_t names)
1451 {
1452   gpg_error_t err;
1453   KEYDB_HANDLE hd = NULL;
1454   KEYDB_SEARCH_DESC *desc = NULL;
1455   int ndesc;
1456   strlist_t sl;
1457   int rc=0;
1458   unsigned int old_value, value;
1459
1460   (void)ctrl;
1461
1462   hd = keydb_new ();
1463   if (!hd)
1464     {
1465       log_error ("keydb_new failed\n");
1466       goto leave;
1467     }
1468
1469   if (!names)
1470     ndesc = 1;
1471   else
1472     {
1473       for (sl=names, ndesc=0; sl; sl = sl->next, ndesc++)
1474         ;
1475     }
1476
1477   desc = xtrycalloc (ndesc, sizeof *desc);
1478   if (!ndesc)
1479     {
1480       log_error ("allocating memory failed: %s\n",
1481                  gpg_strerror (out_of_core ()));
1482       goto leave;
1483     }
1484
1485   if (!names)
1486     desc[0].mode = KEYDB_SEARCH_MODE_FIRST;
1487   else
1488     {
1489       for (ndesc=0, sl=names; sl; sl = sl->next)
1490         {
1491           rc = classify_user_id (sl->d, desc+ndesc, 0);
1492           if (rc)
1493             log_error ("key '%s' not found: %s\n", sl->d, gpg_strerror (rc));
1494           else
1495             ndesc++;
1496         }
1497     }
1498
1499   err = keydb_lock (hd);
1500   if (err)
1501     {
1502       log_error (_("error locking keybox: %s\n"), gpg_strerror (err));
1503       goto leave;
1504     }
1505
1506   while (!(rc = keydb_search (ctrl, hd, desc, ndesc)))
1507     {
1508       if (!names)
1509         desc[0].mode = KEYDB_SEARCH_MODE_NEXT;
1510
1511       err = keydb_get_flags (hd, KEYBOX_FLAG_VALIDITY, 0, &old_value);
1512       if (err)
1513         {
1514           log_error (_("error getting stored flags: %s\n"),
1515                      gpg_strerror (err));
1516           goto leave;
1517         }
1518
1519       value = (old_value & ~VALIDITY_REVOKED);
1520       if (value != old_value)
1521         {
1522           err = keydb_set_flags (hd, KEYBOX_FLAG_VALIDITY, 0, value);
1523           if (err)
1524             {
1525               log_error (_("error storing flags: %s\n"), gpg_strerror (err));
1526               goto leave;
1527             }
1528         }
1529     }
1530   if (rc && rc != -1)
1531     log_error ("keydb_search failed: %s\n", gpg_strerror (rc));
1532
1533  leave:
1534   xfree (desc);
1535   keydb_release (hd);
1536 }