f76904b0a7285f6f2f63b0178400d4f0c42b0680
[gpgme.git] / src / keylist.c
1 /* keylist.c - Listing keys.
2    Copyright (C) 2000 Werner Koch (dd9jn)
3    Copyright (C) 2001, 2002, 2003, 2004, 2006, 2007,
4                  2008, 2009  g10 Code GmbH
5
6    This file is part of GPGME.
7  
8    GPGME is free software; you can redistribute it and/or modify it
9    under the terms of the GNU Lesser General Public License as
10    published by the Free Software Foundation; either version 2.1 of
11    the License, or (at your option) any later version.
12    
13    GPGME is distributed in the hope that it will be useful, but
14    WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16    Lesser General Public License for more details.
17    
18    You should have received a copy of the GNU Lesser General Public
19    License along with this program; if not, see <http://www.gnu.org/licenses/>.
20  */
21
22 #if HAVE_CONFIG_H
23 #include <config.h>
24 #endif
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28 /* Solaris 8 needs sys/types.h before time.h.  */
29 #include <sys/types.h>
30 #include <time.h>
31 #include <assert.h>
32 #include <ctype.h>
33 #include <errno.h>
34
35 /* Suppress warning for accessing deprecated member "class".  */
36 #define _GPGME_IN_GPGME
37 #include "gpgme.h"
38 #include "util.h"
39 #include "context.h"
40 #include "ops.h"
41 #include "debug.h"
42
43 \f
44 struct key_queue_item_s
45 {
46   struct key_queue_item_s *next;
47   gpgme_key_t key;
48 };
49
50 typedef struct
51 {
52   struct _gpgme_op_keylist_result result;
53
54   gpgme_key_t tmp_key;
55
56   /* This points to the last uid in tmp_key.  */
57   gpgme_user_id_t tmp_uid;
58
59   /* This points to the last sig in tmp_uid.  */
60   gpgme_key_sig_t tmp_keysig;
61
62   /* Something new is available.  */
63   int key_cond;
64   struct key_queue_item_s *key_queue;
65 } *op_data_t;
66
67
68 static void
69 release_op_data (void *hook)
70 {
71   op_data_t opd = (op_data_t) hook;
72   struct key_queue_item_s *key = opd->key_queue;
73
74   if (opd->tmp_key)
75     gpgme_key_unref (opd->tmp_key);
76
77   /* opd->tmp_uid and opd->tmp_keysig are actually part of opd->tmp_key,
78      so we do not need to release them here.  */
79
80   while (key)
81     {
82       struct key_queue_item_s *next = key->next;
83
84       gpgme_key_unref (key->key);
85       key = next;
86     }
87 }
88
89
90 gpgme_keylist_result_t
91 gpgme_op_keylist_result (gpgme_ctx_t ctx)
92 {
93   void *hook;
94   op_data_t opd;
95   gpgme_error_t err;
96
97   TRACE_BEG (DEBUG_CTX, "gpgme_op_keylist_result", ctx);
98
99   err = _gpgme_op_data_lookup (ctx, OPDATA_KEYLIST, &hook, -1, NULL);
100   opd = hook;
101   if (err || !opd)
102     {
103       TRACE_SUC0 ("result=(null)");
104       return NULL;
105     }
106
107   TRACE_LOG1 ("truncated = %i", opd->result.truncated);
108
109   TRACE_SUC1 ("result=%p", &opd->result);
110   return &opd->result;
111 }
112
113 \f
114 static gpgme_error_t
115 keylist_status_handler (void *priv, gpgme_status_code_t code, char *args)
116 {
117   gpgme_ctx_t ctx = (gpgme_ctx_t) priv;
118   gpgme_error_t err;
119   void *hook;
120   op_data_t opd;
121
122   err = _gpgme_op_data_lookup (ctx, OPDATA_KEYLIST, &hook, -1, NULL);
123   opd = hook;
124   if (err)
125     return err;
126
127   switch (code)
128     {
129     case GPGME_STATUS_TRUNCATED:
130       opd->result.truncated = 1;
131       break;
132
133     default:
134       break;
135     }
136   return 0;
137 }
138
139 \f
140 static void
141 set_subkey_trust_info (gpgme_subkey_t subkey, const char *src)
142 {
143   while (*src && !isdigit (*src))
144     {
145       switch (*src)
146         {
147         case 'e':
148           subkey->expired = 1;
149           break;
150
151         case 'r':
152           subkey->revoked = 1;
153           break;
154
155         case 'd':
156           /* Note that gpg 1.3 won't print that anymore but only uses
157              the capabilities field. */
158           subkey->disabled = 1;
159           break;
160
161         case 'i':
162           subkey->invalid = 1;
163           break;
164         }
165       src++;
166     }
167 }
168
169
170 static void
171 set_mainkey_trust_info (gpgme_key_t key, const char *src)
172 {
173   /* First set the trust info of the main key (the first subkey).  */
174   set_subkey_trust_info (key->subkeys, src);
175
176   /* Now set the summarized trust info.  */
177   while (*src && !isdigit (*src))
178     {
179       switch (*src)
180         {
181         case 'e':
182           key->expired = 1;
183           break;
184
185         case 'r':
186           key->revoked = 1;
187           break;
188
189         case 'd':
190           /* Note that gpg 1.3 won't print that anymore but only uses
191              the capabilities field.  However, it is still used for
192              external key listings.  */
193           key->disabled = 1;
194           break;
195
196         case 'i':
197           key->invalid = 1;
198           break;
199         }
200       src++;
201     }
202 }
203
204
205 static void
206 set_userid_flags (gpgme_key_t key, const char *src)
207 {
208   gpgme_user_id_t uid = key->_last_uid;
209
210   assert (uid);
211   /* Look at letters and stop at the first digit.  */
212   while (*src && !isdigit (*src))
213     {
214       switch (*src)
215         {
216         case 'r':
217           uid->revoked = 1;
218           break;
219           
220         case 'i':
221           uid->invalid = 1;
222           break;
223
224         case 'n':
225           uid->validity = GPGME_VALIDITY_NEVER;
226           break;
227
228         case 'm':
229           uid->validity = GPGME_VALIDITY_MARGINAL;
230           break;
231
232         case 'f':
233           uid->validity = GPGME_VALIDITY_FULL;
234           break;
235
236         case 'u':
237           uid->validity = GPGME_VALIDITY_ULTIMATE;
238           break;
239         }
240       src++;
241     }
242 }
243
244
245 static void
246 set_subkey_capability (gpgme_subkey_t subkey, const char *src)
247 {
248   while (*src)
249     {
250       switch (*src)
251         {
252         case 'e':
253           subkey->can_encrypt = 1;
254           break;
255
256         case 's':
257           subkey->can_sign = 1;
258           break;
259
260         case 'c':
261           subkey->can_certify = 1;
262           break;
263
264         case 'a':
265           subkey->can_authenticate = 1;
266           break;
267
268         case 'q':
269           subkey->is_qualified = 1;
270           break;
271
272         case 'd':
273           subkey->disabled = 1;
274           break;
275         }
276       src++;
277     }
278 }
279
280
281 static void
282 set_mainkey_capability (gpgme_key_t key, const char *src)
283 {
284   /* First set the capabilities of the main key (the first subkey).  */
285   set_subkey_capability (key->subkeys, src);
286
287   while (*src)
288     {
289       switch (*src)
290         {
291         case 'd':
292         case 'D':
293           /* Note, that this flag is also set using the key validity
294              field for backward compatibility with gpg 1.2.  We use d
295              and D, so that a future gpg version will be able to
296              disable certain subkeys. Currently it is expected that
297              gpg sets this for the primary key. */
298           key->disabled = 1;
299           break;
300
301         case 'e':
302         case 'E':
303           key->can_encrypt = 1;
304           break;
305
306         case 's':
307         case 'S':
308           key->can_sign = 1;
309           break;
310
311         case 'c':
312         case 'C':
313           key->can_certify = 1;
314           break;
315
316         case 'a':
317         case 'A':
318           key->can_authenticate = 1;
319           break;
320
321         case 'q':
322         case 'Q':
323           key->is_qualified = 1;
324           break;
325         }
326       src++;
327     }
328 }
329
330
331 static void
332 set_ownertrust (gpgme_key_t key, const char *src)
333 {
334   /* Look at letters and stop at the first digit.  */
335   while (*src && !isdigit (*src))
336     {
337       switch (*src)
338         {
339         case 'n':
340           key->owner_trust = GPGME_VALIDITY_NEVER;
341           break;
342
343         case 'm':
344           key->owner_trust = GPGME_VALIDITY_MARGINAL;
345           break;
346
347         case 'f':
348           key->owner_trust = GPGME_VALIDITY_FULL;
349           break;
350
351         case 'u':
352           key->owner_trust = GPGME_VALIDITY_ULTIMATE;
353           break;
354
355         default:
356           key->owner_trust = GPGME_VALIDITY_UNKNOWN;
357           break;
358         }
359       src++;
360     }
361 }
362
363
364 /* Parse field 15 of a secret key or subkey.  This fields holds a
365    reference to smartcards.  FIELD is the content of the field and we
366    are allowed to modify it.  */
367 static gpg_error_t
368 parse_sec_field15 (gpgme_subkey_t subkey, char *field)
369 {
370   if (!*field)
371     ; /* Empty.  */
372   else if (*field == '#')
373     {
374       /* This is a stub for an offline key.  We reset the SECRET flag
375          of the subkey here.  Note that the secret flag of the entire
376          key will be true even then.  */
377       subkey->secret = 0;
378     }
379   else if (strchr ("01234567890ABCDEFabcdef", *field))
380     {
381       /* Fields starts with a hex digit; thus it is a serial number.  */
382       subkey->is_cardkey = 1;
383       subkey->card_number = strdup (field);
384       if (!subkey->card_number)
385         return gpg_error_from_syserror ();
386     }
387   else
388     {
389       /* RFU.  */
390     }
391
392   return 0;
393 }
394
395
396 /* We have read an entire key into tmp_key and should now finish it.
397    It is assumed that this releases tmp_key.  */
398 static void
399 finish_key (gpgme_ctx_t ctx, op_data_t opd)
400 {
401   gpgme_key_t key = opd->tmp_key;
402
403   opd->tmp_key = NULL;
404   opd->tmp_uid = NULL;
405   opd->tmp_keysig = NULL;
406
407   if (key)
408     _gpgme_engine_io_event (ctx->engine, GPGME_EVENT_NEXT_KEY, key);
409 }
410
411
412 /* Note: We are allowed to modify LINE.  */
413 static gpgme_error_t
414 keylist_colon_handler (void *priv, char *line)
415 {
416   gpgme_ctx_t ctx = (gpgme_ctx_t) priv;
417   enum
418     {
419       RT_NONE, RT_SIG, RT_UID, RT_SUB, RT_PUB, RT_FPR,
420       RT_SSB, RT_SEC, RT_CRT, RT_CRS, RT_REV, RT_SPK
421     }
422   rectype = RT_NONE;
423 #define NR_FIELDS 16
424   char *field[NR_FIELDS];
425   int fields = 0;
426   void *hook;
427   op_data_t opd;
428   gpgme_error_t err;
429   gpgme_key_t key;
430   gpgme_subkey_t subkey = NULL;
431   gpgme_key_sig_t keysig = NULL;
432
433   err = _gpgme_op_data_lookup (ctx, OPDATA_KEYLIST, &hook, -1, NULL);
434   opd = hook;
435   if (err)
436     return err;
437
438   key = opd->tmp_key;
439
440   TRACE2 (DEBUG_CTX, "gpgme:keylist_colon_handler", ctx,
441           "key = %p, line = %s", key, line ? line : "(null)");
442
443   if (!line)
444     {
445       /* End Of File.  */
446       finish_key (ctx, opd);
447       return 0;
448     }
449
450   while (line && fields < NR_FIELDS)
451     {
452       field[fields++] = line;
453       line = strchr (line, ':');
454       if (line)
455         *(line++) = '\0';
456     }
457
458   if (!strcmp (field[0], "sig"))
459     rectype = RT_SIG;
460   else if (!strcmp (field[0], "rev"))
461     rectype = RT_REV;
462   else if (!strcmp (field[0], "pub"))
463     rectype = RT_PUB;
464   else if (!strcmp (field[0], "sec"))
465     rectype = RT_SEC;
466   else if (!strcmp (field[0], "crt"))
467     rectype = RT_CRT;
468   else if (!strcmp (field[0], "crs"))
469     rectype = RT_CRS;
470   else if (!strcmp (field[0], "fpr") && key) 
471     rectype = RT_FPR;
472   else if (!strcmp (field[0], "uid") && key)
473     rectype = RT_UID;
474   else if (!strcmp (field[0], "sub") && key)
475     rectype = RT_SUB; 
476   else if (!strcmp (field[0], "ssb") && key)
477     rectype = RT_SSB;
478   else if (!strcmp (field[0], "spk") && key)
479     rectype = RT_SPK;
480   else 
481     rectype = RT_NONE;
482
483   /* Only look at signatures immediately following a user ID.  For
484      this, clear the user ID pointer when encountering anything but a
485      signature.  */
486   if (rectype != RT_SIG && rectype != RT_REV)
487     opd->tmp_uid = NULL;
488
489   /* Only look at subpackets immediately following a signature.  For
490      this, clear the signature pointer when encountering anything but
491      a subpacket.  */
492   if (rectype != RT_SPK)
493     opd->tmp_keysig = NULL;
494
495   switch (rectype)
496     {
497     case RT_PUB:
498     case RT_SEC:
499     case RT_CRT:
500     case RT_CRS:
501       /* Start a new keyblock.  */
502       err = _gpgme_key_new (&key);
503       if (err)
504         return err;
505       key->keylist_mode = ctx->keylist_mode;
506       err = _gpgme_key_add_subkey (key, &subkey);
507       if (err)
508         {
509           gpgme_key_unref (key);
510           return err;
511         }
512
513       if (rectype == RT_SEC || rectype == RT_CRS)
514         key->secret = subkey->secret = 1;
515       if (rectype == RT_CRT || rectype == RT_CRS)
516         key->protocol = GPGME_PROTOCOL_CMS;
517       finish_key (ctx, opd);
518       opd->tmp_key = key;
519
520       /* Field 2 has the trust info.  */
521       if (fields >= 2)
522         set_mainkey_trust_info (key, field[1]);
523
524       /* Field 3 has the key length.  */
525       if (fields >= 3)
526         {
527           int i = atoi (field[2]);
528           /* Ignore invalid values.  */
529           if (i > 1)
530             subkey->length = i; 
531         }
532
533       /* Field 4 has the public key algorithm.  */
534       if (fields >= 4)
535         {
536           int i = atoi (field[3]);
537           if (i >= 1 && i < 128)
538             subkey->pubkey_algo = i;
539         }
540
541       /* Field 5 has the long keyid.  Allow short key IDs for the
542          output of an external keyserver listing.  */
543       if (fields >= 5 && strlen (field[4]) <= DIM(subkey->_keyid) - 1)
544         strcpy (subkey->_keyid, field[4]);
545
546       /* Field 6 has the timestamp (seconds).  */
547       if (fields >= 6)
548         subkey->timestamp = _gpgme_parse_timestamp (field[5], NULL);
549
550       /* Field 7 has the expiration time (seconds).  */
551       if (fields >= 7)
552         subkey->expires = _gpgme_parse_timestamp (field[6], NULL);
553
554       /* Field 8 has the X.509 serial number.  */
555       if (fields >= 8 && (rectype == RT_CRT || rectype == RT_CRS))
556         {
557           key->issuer_serial = strdup (field[7]);
558           if (!key->issuer_serial)
559             return gpg_error_from_errno (errno);
560         }
561           
562       /* Field 9 has the ownertrust.  */
563       if (fields >= 9)
564         set_ownertrust (key, field[8]);
565
566       /* Field 10 is not used for gpg due to --fixed-list-mode option
567          but GPGSM stores the issuer name.  */
568       if (fields >= 10 && (rectype == RT_CRT || rectype == RT_CRS))
569         if (_gpgme_decode_c_string (field[9], &key->issuer_name, 0))
570           return gpg_error (GPG_ERR_ENOMEM);    /* FIXME */
571
572       /* Field 11 has the signature class.  */
573
574       /* Field 12 has the capabilities.  */
575       if (fields >= 12)
576         set_mainkey_capability (key, field[11]);
577
578       /* Field 15 carries special flags of a secret key.  */
579       if (fields >= 15 && key->secret)
580         {
581           err = parse_sec_field15 (subkey, field[14]);
582           if (err)
583             return err;
584         }
585       break;
586
587     case RT_SUB:
588     case RT_SSB:
589       /* Start a new subkey.  */
590       err = _gpgme_key_add_subkey (key, &subkey);
591       if (err)
592         return err;
593
594       if (rectype == RT_SSB)
595         subkey->secret = 1;
596
597       /* Field 2 has the trust info.  */
598       if (fields >= 2)
599         set_subkey_trust_info (subkey, field[1]);
600
601       /* Field 3 has the key length.  */
602       if (fields >= 3)
603         {
604           int i = atoi (field[2]);
605           /* Ignore invalid values.  */
606           if (i > 1)
607             subkey->length = i;
608         }
609
610       /* Field 4 has the public key algorithm.  */
611       if (fields >= 4)
612         {
613           int i = atoi (field[3]);
614           if (i >= 1 && i < 128)
615             subkey->pubkey_algo = i;
616         }
617
618       /* Field 5 has the long keyid.  */
619       if (fields >= 5 && strlen (field[4]) == DIM(subkey->_keyid) - 1)
620         strcpy (subkey->_keyid, field[4]);
621
622       /* Field 6 has the timestamp (seconds).  */
623       if (fields >= 6)
624         subkey->timestamp = _gpgme_parse_timestamp (field[5], NULL);
625
626       /* Field 7 has the expiration time (seconds).  */
627       if (fields >= 7)
628         subkey->expires = _gpgme_parse_timestamp (field[6], NULL);
629
630       /* Field 8 is reserved (LID).  */
631       /* Field 9 has the ownertrust.  */
632       /* Field 10, the user ID, is n/a for a subkey.  */
633       
634       /* Field 11 has the signature class.  */
635
636       /* Field 12 has the capabilities.  */
637       if (fields >= 12)
638         set_subkey_capability (subkey, field[11]);
639
640       /* Field 15 carries special flags of a secret key. */
641       if (fields >= 15 && key->secret)
642         {
643           err = parse_sec_field15 (subkey, field[14]);
644           if (err)
645             return err;
646         }
647       break;
648
649     case RT_UID:
650       /* Field 2 has the trust info, and field 10 has the user ID.  */
651       if (fields >= 10)
652         {
653           if (_gpgme_key_append_name (key, field[9], 1))
654             return gpg_error_from_errno (GPG_ERR_ENOMEM);       /* FIXME */
655           else
656             {
657               if (field[1])
658                 set_userid_flags (key, field[1]);
659               opd->tmp_uid = key->_last_uid;
660             }
661         }
662       break;
663
664     case RT_FPR:
665       /* Field 10 has the fingerprint (take only the first one).  */
666       if (fields >= 10 && field[9] && *field[9])
667         {
668           /* Need to apply it to the last subkey because all subkeys
669              do have fingerprints. */
670           subkey = key->_last_subkey;
671           if (!subkey->fpr)
672             {
673               subkey->fpr = strdup (field[9]);
674               if (!subkey->fpr)
675                 return gpg_error_from_errno (errno);
676             }
677         }
678
679       /* Field 13 has the gpgsm chain ID (take only the first one).  */
680       if (fields >= 13 && !key->chain_id && *field[12])
681         {
682           key->chain_id = strdup (field[12]);
683           if (!key->chain_id)
684             return gpg_error_from_errno (errno);
685         }
686       break;
687
688     case RT_SIG:
689     case RT_REV:
690       if (!opd->tmp_uid)
691         return 0;
692
693       /* Start a new (revoked) signature.  */
694       assert (opd->tmp_uid == key->_last_uid);
695       keysig = _gpgme_key_add_sig (key, (fields >= 10) ? field[9] : NULL);
696       if (!keysig)
697         return gpg_error (GPG_ERR_ENOMEM);      /* FIXME */
698
699       /* Field 2 has the calculated trust ('!', '-', '?', '%').  */
700       if (fields >= 2)
701         switch (field[1][0])
702           {
703           case '!':
704             keysig->status = gpg_error (GPG_ERR_NO_ERROR);
705             break;
706
707           case '-':
708             keysig->status = gpg_error (GPG_ERR_BAD_SIGNATURE);
709             break;
710
711           case '?':
712             keysig->status = gpg_error (GPG_ERR_NO_PUBKEY);
713             break;
714
715           case '%':
716             keysig->status = gpg_error (GPG_ERR_GENERAL);
717             break;
718
719           default:
720             keysig->status = gpg_error (GPG_ERR_NO_ERROR);
721             break;
722           }
723
724       /* Field 4 has the public key algorithm.  */
725       if (fields >= 4)
726         {
727           int i = atoi (field[3]);
728           if (i >= 1 && i < 128)
729             keysig->pubkey_algo = i;
730         }
731       
732       /* Field 5 has the long keyid.  */
733       if (fields >= 5 && strlen (field[4]) == DIM(keysig->_keyid) - 1)
734         strcpy (keysig->_keyid, field[4]);
735       
736       /* Field 6 has the timestamp (seconds).  */
737       if (fields >= 6)
738         keysig->timestamp = _gpgme_parse_timestamp (field[5], NULL);
739
740       /* Field 7 has the expiration time (seconds).  */
741       if (fields >= 7)
742         keysig->expires = _gpgme_parse_timestamp (field[6], NULL);
743
744       /* Field 11 has the signature class (eg, 0x30 means revoked).  */
745       if (fields >= 11)
746         if (field[10][0] && field[10][1])
747           {
748             int sig_class = _gpgme_hextobyte (field[10]);
749             if (sig_class >= 0)
750               {
751                 keysig->sig_class = sig_class;
752                 keysig->class = keysig->sig_class;
753                 if (sig_class == 0x30)
754                   keysig->revoked = 1;
755               }
756             if (field[10][2] == 'x')
757               keysig->exportable = 1;
758           }
759
760       opd->tmp_keysig = keysig;
761       break;
762
763     case RT_SPK:
764       if (!opd->tmp_keysig)
765         return 0;
766       assert (opd->tmp_keysig == key->_last_uid->_last_keysig);
767
768       if (fields >= 4)
769         {
770           /* Field 2 has the subpacket type.  */
771           int type = atoi (field[1]);
772
773           /* Field 3 has the flags.  */
774           int flags = atoi (field[2]);
775
776           /* Field 4 has the length.  */
777           int len = atoi (field[3]);
778
779           /* Field 5 has the data.  */
780           char *data = field[4];
781
782           /* Type 20: Notation data.  */
783           /* Type 26: Policy URL.  */
784           if (type == 20 || type == 26)
785             {
786               gpgme_sig_notation_t notation;
787
788               keysig = opd->tmp_keysig;
789
790               /* At this time, any error is serious.  */
791               err = _gpgme_parse_notation (&notation, type, flags, len, data);
792               if (err)
793                 return err;
794
795               /* Add a new notation.  FIXME: Could be factored out.  */
796               if (!keysig->notations)
797                 keysig->notations = notation;
798               if (keysig->_last_notation)
799                 keysig->_last_notation->next = notation;
800               keysig->_last_notation = notation;
801             }
802         }
803     
804     case RT_NONE:
805       /* Unknown record.  */
806       break;
807     }
808   return 0;
809 }
810
811
812 void
813 _gpgme_op_keylist_event_cb (void *data, gpgme_event_io_t type, void *type_data)
814 {
815   gpgme_error_t err;
816   gpgme_ctx_t ctx = (gpgme_ctx_t) data;
817   gpgme_key_t key = (gpgme_key_t) type_data;
818   void *hook;
819   op_data_t opd;
820   struct key_queue_item_s *q, *q2;
821
822   assert (type == GPGME_EVENT_NEXT_KEY);
823
824   err = _gpgme_op_data_lookup (ctx, OPDATA_KEYLIST, &hook, -1, NULL);
825   opd = hook;
826   if (err)
827     return;
828
829   q = malloc (sizeof *q);
830   if (!q)
831     {
832       gpgme_key_unref (key);
833       /* FIXME       return GPGME_Out_Of_Core; */
834       return;
835     }
836   q->key = key;
837   q->next = NULL;
838   /* FIXME: Use a tail pointer?  */
839   if (!(q2 = opd->key_queue))
840     opd->key_queue = q;
841   else
842     {
843       for (; q2->next; q2 = q2->next)
844         ;
845       q2->next = q;
846     }
847   opd->key_cond = 1;
848 }
849
850
851 /* Start a keylist operation within CTX, searching for keys which
852    match PATTERN.  If SECRET_ONLY is true, only secret keys are
853    returned.  */
854 gpgme_error_t
855 gpgme_op_keylist_start (gpgme_ctx_t ctx, const char *pattern, int secret_only)
856 {
857   gpgme_error_t err;
858   void *hook;
859   op_data_t opd;
860
861   TRACE_BEG2 (DEBUG_CTX, "gpgme_op_keylist_start", ctx,
862               "pattern=%s, secret_only=%i", pattern, secret_only);
863
864   err = _gpgme_op_reset (ctx, 2);
865   if (err)
866     return TRACE_ERR (err);
867
868   err = _gpgme_op_data_lookup (ctx, OPDATA_KEYLIST, &hook,
869                                sizeof (*opd), release_op_data);
870   opd = hook;
871   if (err)
872     return TRACE_ERR (err);
873
874   _gpgme_engine_set_status_handler (ctx->engine, keylist_status_handler, ctx);
875
876   err = _gpgme_engine_set_colon_line_handler (ctx->engine,
877                                               keylist_colon_handler, ctx);
878   if (err)
879     return TRACE_ERR (err);
880
881   err = _gpgme_engine_op_keylist (ctx->engine, pattern, secret_only,
882                                   ctx->keylist_mode);
883   return TRACE_ERR (err);
884 }
885
886
887 /* Start a keylist operation within CTX, searching for keys which
888    match PATTERN.  If SECRET_ONLY is true, only secret keys are
889    returned.  */
890 gpgme_error_t
891 gpgme_op_keylist_ext_start (gpgme_ctx_t ctx, const char *pattern[],
892                             int secret_only, int reserved)
893 {
894   gpgme_error_t err;
895   void *hook;
896   op_data_t opd;
897
898   TRACE_BEG2 (DEBUG_CTX, "gpgme_op_keylist_ext_start", ctx,
899               "secret_only=%i, reserved=0x%x", secret_only, reserved);
900
901   err = _gpgme_op_reset (ctx, 2);
902   if (err)
903     return TRACE_ERR (err);
904
905   err = _gpgme_op_data_lookup (ctx, OPDATA_KEYLIST, &hook,
906                                sizeof (*opd), release_op_data);
907   opd = hook;
908   if (err)
909     return TRACE_ERR (err);
910
911   _gpgme_engine_set_status_handler (ctx->engine, keylist_status_handler, ctx);
912   err = _gpgme_engine_set_colon_line_handler (ctx->engine,
913                                               keylist_colon_handler, ctx);
914   if (err)
915     return TRACE_ERR (err);
916
917   err = _gpgme_engine_op_keylist_ext (ctx->engine, pattern, secret_only,
918                                       reserved, ctx->keylist_mode);
919   return TRACE_ERR (err);
920 }
921
922
923 /* Return the next key from the keylist in R_KEY.  */
924 gpgme_error_t
925 gpgme_op_keylist_next (gpgme_ctx_t ctx, gpgme_key_t *r_key)
926 {
927   gpgme_error_t err;
928   struct key_queue_item_s *queue_item;
929   void *hook;
930   op_data_t opd;
931
932   TRACE_BEG (DEBUG_CTX, "gpgme_op_keylist_next", ctx);
933
934   if (!ctx || !r_key)
935     return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
936   *r_key = NULL;
937   if (!ctx)
938     return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
939
940   err = _gpgme_op_data_lookup (ctx, OPDATA_KEYLIST, &hook, -1, NULL);
941   opd = hook;
942   if (err)
943     return TRACE_ERR (err);
944   if (opd == NULL)
945     return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
946
947   if (!opd->key_queue)
948     {
949       err = _gpgme_wait_on_condition (ctx, &opd->key_cond, NULL);
950       if (err)
951         return TRACE_ERR (err);
952
953       if (!opd->key_cond)
954         return TRACE_ERR (gpg_error (GPG_ERR_EOF));
955
956       opd->key_cond = 0; 
957       assert (opd->key_queue);
958     }
959   queue_item = opd->key_queue;
960   opd->key_queue = queue_item->next;
961   if (!opd->key_queue)
962     opd->key_cond = 0;
963   
964   *r_key = queue_item->key;
965   free (queue_item);
966
967   return TRACE_SUC2 ("key=%p (%s)", *r_key,
968                      ((*r_key)->subkeys && (*r_key)->subkeys->fpr) ? 
969                      (*r_key)->subkeys->fpr : "invalid");
970 }
971
972
973 /* Terminate a pending keylist operation within CTX.  */
974 gpgme_error_t
975 gpgme_op_keylist_end (gpgme_ctx_t ctx)
976 {
977   TRACE (DEBUG_CTX, "gpgme_op_keylist_end", ctx);
978   
979   if (!ctx)
980     return gpg_error (GPG_ERR_INV_VALUE);
981
982   return 0;
983 }
984
985 \f
986 /* Get the key with the fingerprint FPR from the crypto backend.  If
987    SECRET is true, get the secret key.  */
988 gpgme_error_t
989 gpgme_get_key (gpgme_ctx_t ctx, const char *fpr, gpgme_key_t *r_key,
990                int secret)
991 {
992   gpgme_ctx_t listctx;
993   gpgme_error_t err;
994   gpgme_key_t key;
995
996   TRACE_BEG2 (DEBUG_CTX, "gpgme_get_key", ctx,
997               "fpr=%s, secret=%i", fpr, secret);
998
999   if (!ctx || !r_key || !fpr)
1000     return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
1001   
1002   if (strlen (fpr) < 8) /* We have at least a key ID.  */
1003     return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
1004
1005   /* FIXME: We use our own context because we have to avoid the user's
1006      I/O callback handlers.  */
1007   err = gpgme_new (&listctx);
1008   if (err)
1009     return TRACE_ERR (err);
1010   {
1011     gpgme_protocol_t proto;
1012     gpgme_engine_info_t info;
1013
1014     /* Clone the relevant state.  */
1015     proto = gpgme_get_protocol (ctx);
1016     gpgme_set_protocol (listctx, proto);
1017     gpgme_set_keylist_mode (listctx, gpgme_get_keylist_mode (ctx));
1018     info = gpgme_ctx_get_engine_info (ctx);
1019     while (info && info->protocol != proto)
1020       info = info->next;
1021     if (info)
1022       gpgme_ctx_set_engine_info (listctx, proto,
1023                                  info->file_name, info->home_dir);
1024   }
1025
1026   err = gpgme_op_keylist_start (listctx, fpr, secret);
1027   if (!err)
1028     err = gpgme_op_keylist_next (listctx, r_key);
1029   if (!err)
1030     {
1031     try_next_key:
1032       err = gpgme_op_keylist_next (listctx, &key);
1033       if (gpgme_err_code (err) == GPG_ERR_EOF)
1034         err = 0;
1035       else
1036         {
1037           if (!err
1038               && *r_key && (*r_key)->subkeys && (*r_key)->subkeys->fpr
1039               && key && key->subkeys && key->subkeys->fpr
1040               && !strcmp ((*r_key)->subkeys->fpr, key->subkeys->fpr))
1041             {
1042               /* The fingerprint is identical.  We assume that this is
1043                  the same key and don't mark it as an ambiguous.  This
1044                  problem may occur with corrupted keyrings and has
1045                  been noticed often with gpgsm.  In fact gpgsm uses a
1046                  similar hack to sort out such duplicates but it can't
1047                  do that while listing keys.  */
1048               gpgme_key_unref (key);
1049               goto try_next_key;
1050             }
1051           if (!err)
1052             {
1053               gpgme_key_unref (key);
1054               err = gpg_error (GPG_ERR_AMBIGUOUS_NAME);
1055             }
1056           gpgme_key_unref (*r_key);
1057         }
1058     }
1059   gpgme_release (listctx);
1060   if (! err)
1061     {
1062       TRACE_LOG2 ("key=%p (%s)", *r_key,
1063                   ((*r_key)->subkeys && (*r_key)->subkeys->fpr) ? 
1064                   (*r_key)->subkeys->fpr : "invalid");
1065     }
1066   return TRACE_ERR (err);
1067 }