Move new mailbox.c source file to common/.
[gnupg.git] / g10 / keylist.c
1 /* keylist.c - Print information about OpenPGP keys
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
3  *               2008, 2010, 2012 Free Software Foundation, Inc.
4  * Copyright (C) 2013, 2014  Werner Koch
5  *
6  * This file is part of GnuPG.
7  *
8  * GnuPG is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 3 of the License, or
11  * (at your option) any later version.
12  *
13  * GnuPG is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, see <http://www.gnu.org/licenses/>.
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <errno.h>
27 #include <assert.h>
28 #ifdef HAVE_DOSISH_SYSTEM
29 #include <fcntl.h>              /* for setmode() */
30 #endif
31
32 #include "gpg.h"
33 #include "options.h"
34 #include "packet.h"
35 #include "status.h"
36 #include "keydb.h"
37 #include "photoid.h"
38 #include "util.h"
39 #include "ttyio.h"
40 #include "trustdb.h"
41 #include "main.h"
42 #include "i18n.h"
43 #include "status.h"
44 #include "call-agent.h"
45 #include "mbox-util.h"
46
47
48 static void list_all (int, int);
49 static void list_one (strlist_t names, int secret, int mark_secret);
50 static void locate_one (ctrl_t ctrl, strlist_t names);
51 static void print_card_serialno (const char *serialno);
52
53 struct sig_stats
54 {
55   int inv_sigs;
56   int no_key;
57   int oth_err;
58 };
59
60 /* The stream used to write attribute packets to.  */
61 static estream_t attrib_fp;
62
63
64 /* List the keys.  If list is NULL, all available keys are listed.
65    With LOCATE_MODE set the locate algorithm is used to find a
66    key.  */
67 void
68 public_key_list (ctrl_t ctrl, strlist_t list, int locate_mode)
69 {
70 #ifndef NO_TRUST_MODELS
71   if (opt.with_colons)
72     {
73       byte trust_model, marginals, completes, cert_depth, min_cert_level;
74       ulong created, nextcheck;
75
76       read_trust_options (&trust_model, &created, &nextcheck,
77                           &marginals, &completes, &cert_depth, &min_cert_level);
78
79       es_fprintf (es_stdout, "tru:");
80
81       if (nextcheck && nextcheck <= make_timestamp ())
82         es_fprintf (es_stdout, "o");
83       if (trust_model != opt.trust_model)
84         es_fprintf (es_stdout, "t");
85       if (opt.trust_model == TM_PGP || opt.trust_model == TM_CLASSIC)
86         {
87           if (marginals != opt.marginals_needed)
88             es_fprintf (es_stdout, "m");
89           if (completes != opt.completes_needed)
90             es_fprintf (es_stdout, "c");
91           if (cert_depth != opt.max_cert_depth)
92             es_fprintf (es_stdout, "d");
93           if (min_cert_level != opt.min_cert_level)
94             es_fprintf (es_stdout, "l");
95         }
96
97       es_fprintf (es_stdout, ":%d:%lu:%lu", trust_model, created, nextcheck);
98
99       /* Only show marginals, completes, and cert_depth in the classic
100          or PGP trust models since they are not meaningful
101          otherwise. */
102
103       if (trust_model == TM_PGP || trust_model == TM_CLASSIC)
104         es_fprintf (es_stdout, ":%d:%d:%d", marginals, completes, cert_depth);
105       es_fprintf (es_stdout, "\n");
106     }
107 #endif /*!NO_TRUST_MODELS*/
108
109   /* We need to do the stale check right here because it might need to
110      update the keyring while we already have the keyring open.  This
111      is very bad for W32 because of a sharing violation. For real OSes
112      it might lead to false results if we are later listing a keyring
113      which is associated with the inode of a deleted file.  */
114   check_trustdb_stale ();
115
116   if (locate_mode)
117     locate_one (ctrl, list);
118   else if (!list)
119     list_all (0, opt.with_secret);
120   else
121     list_one (list, 0, opt.with_secret);
122 }
123
124
125 void
126 secret_key_list (ctrl_t ctrl, strlist_t list)
127 {
128   (void)ctrl;
129
130   check_trustdb_stale ();
131
132   if (!list)
133     list_all (1, 0);
134   else                          /* List by user id */
135     list_one (list, 1, 0);
136 }
137
138 void
139 print_seckey_info (PKT_public_key *pk)
140 {
141   u32 keyid[2];
142   char *p;
143   char pkstrbuf[PUBKEY_STRING_SIZE];
144
145   keyid_from_pk (pk, keyid);
146   p = get_user_id_native (keyid);
147
148   tty_printf ("\nsec  %s/%s %s %s\n",
149               pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
150               keystr (keyid), datestr_from_pk (pk), p);
151
152   xfree (p);
153 }
154
155 /* Print information about the public key.  With FP passed as NULL,
156    the tty output interface is used, otherwise output is directted to
157    the given stream.  */
158 void
159 print_pubkey_info (estream_t fp, PKT_public_key * pk)
160 {
161   u32 keyid[2];
162   char *p;
163   char pkstrbuf[PUBKEY_STRING_SIZE];
164
165   keyid_from_pk (pk, keyid);
166
167   /* If the pk was chosen by a particular user ID, that is the one to
168      print.  */
169   if (pk->user_id)
170     p = utf8_to_native (pk->user_id->name, pk->user_id->len, 0);
171   else
172     p = get_user_id_native (keyid);
173
174   if (fp)
175     tty_printf ("\n");
176   tty_fprintf (fp, "pub  %s/%s %s %s\n",
177                pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
178                keystr (keyid), datestr_from_pk (pk), p);
179   xfree (p);
180 }
181
182
183 /* Print basic information of a secret key including the card serial
184    number information.  */
185 #ifdef ENABLE_CARD_SUPPORT
186 void
187 print_card_key_info (estream_t fp, kbnode_t keyblock)
188 {
189   kbnode_t node;
190   char *hexgrip;
191   char *serialno;
192   int s2k_char;
193   char pkstrbuf[PUBKEY_STRING_SIZE];
194
195   for (node = keyblock; node; node = node->next)
196     {
197       if (node->pkt->pkttype == PKT_PUBLIC_KEY
198           || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
199         {
200           int rc;
201           PKT_public_key *pk = node->pkt->pkt.public_key;
202
203           serialno = NULL;
204           rc = hexkeygrip_from_pk (pk, &hexgrip);
205           if (rc)
206             {
207               log_error ("error computing a keygrip: %s\n", gpg_strerror (rc));
208               s2k_char = '?';
209             }
210           else if (!agent_get_keyinfo (NULL, hexgrip, &serialno))
211             s2k_char = serialno? '>':' ';
212           else
213             s2k_char = '#';  /* Key not found.  */
214
215           tty_fprintf (fp, "%s%c  %s/%s  ",
216                        node->pkt->pkttype == PKT_PUBLIC_KEY ? "sec" : "ssb",
217                        s2k_char,
218                        pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
219                        keystr_from_pk (pk));
220           tty_fprintf (fp, _("created: %s"), datestr_from_pk (pk));
221           tty_fprintf (fp, "  ");
222           tty_fprintf (fp, _("expires: %s"), expirestr_from_pk (pk));
223           if (serialno)
224             {
225               tty_fprintf (fp, "\n                      ");
226               tty_fprintf (fp, _("card-no: "));
227               if (strlen (serialno) == 32
228                   && !strncmp (serialno, "D27600012401", 12))
229                 {
230                   /* This is an OpenPGP card.  Print the relevant part.  */
231                   /* Example: D2760001240101010001000003470000 */
232                   /*                          xxxxyyyyyyyy     */
233                   tty_fprintf (fp, "%.*s %.*s", 4, serialno+16, 8, serialno+20);
234                 }
235               else
236                 tty_fprintf (fp, "%s", serialno);
237             }
238           tty_fprintf (fp, "\n");
239           xfree (hexgrip);
240           xfree (serialno);
241         }
242     }
243 }
244 #endif /*ENABLE_CARD_SUPPORT*/
245
246
247 /* Flags = 0x01 hashed 0x02 critical.  */
248 static void
249 status_one_subpacket (sigsubpkttype_t type, size_t len, int flags,
250                       const byte * buf)
251 {
252   char status[40];
253
254   /* Don't print these. */
255   if (len > 256)
256     return;
257
258   snprintf (status, sizeof status,
259             "%d %u %u ", type, flags, (unsigned int) len);
260
261   write_status_text_and_buffer (STATUS_SIG_SUBPACKET, status, buf, len, 0);
262 }
263
264
265 /* Print a policy URL.  Allowed values for MODE are:
266  *   0 - print to stdout.
267  *   1 - use log_info and emit status messages.
268  *   2 - emit only status messages.
269  */
270 void
271 show_policy_url (PKT_signature * sig, int indent, int mode)
272 {
273   const byte *p;
274   size_t len;
275   int seq = 0, crit;
276   estream_t fp = mode ? log_get_stream () : es_stdout;
277
278   while ((p =
279           enum_sig_subpkt (sig->hashed, SIGSUBPKT_POLICY, &len, &seq, &crit)))
280     {
281       if (mode != 2)
282         {
283           int i;
284           const char *str;
285
286           for (i = 0; i < indent; i++)
287             es_putc (' ', fp);
288
289           if (crit)
290             str = _("Critical signature policy: ");
291           else
292             str = _("Signature policy: ");
293           if (mode)
294             log_info ("%s", str);
295           else
296             es_fprintf (fp, "%s", str);
297           print_utf8_buffer (fp, p, len);
298           es_fprintf (fp, "\n");
299         }
300
301       if (mode)
302         write_status_buffer (STATUS_POLICY_URL, p, len, 0);
303     }
304 }
305
306
307 /*
308   mode=0 for stdout.
309   mode=1 for log_info + status messages
310   mode=2 for status messages only
311 */
312 /* TODO: use this */
313 void
314 show_keyserver_url (PKT_signature * sig, int indent, int mode)
315 {
316   const byte *p;
317   size_t len;
318   int seq = 0, crit;
319   estream_t fp = mode ? log_get_stream () : es_stdout;
320
321   while ((p =
322           enum_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_KS, &len, &seq,
323                            &crit)))
324     {
325       if (mode != 2)
326         {
327           int i;
328           const char *str;
329
330           for (i = 0; i < indent; i++)
331             es_putc (' ', es_stdout);
332
333           if (crit)
334             str = _("Critical preferred keyserver: ");
335           else
336             str = _("Preferred keyserver: ");
337           if (mode)
338             log_info ("%s", str);
339           else
340             es_fprintf (es_stdout, "%s", str);
341           print_utf8_buffer (fp, p, len);
342           es_fprintf (fp, "\n");
343         }
344
345       if (mode)
346         status_one_subpacket (SIGSUBPKT_PREF_KS, len,
347                               (crit ? 0x02 : 0) | 0x01, p);
348     }
349 }
350
351 /*
352   mode=0 for stdout.
353   mode=1 for log_info + status messages
354   mode=2 for status messages only
355
356   Defined bits in WHICH:
357     1 == standard notations
358     2 == user notations
359 */
360 void
361 show_notation (PKT_signature * sig, int indent, int mode, int which)
362 {
363   estream_t fp = mode ? log_get_stream () : es_stdout;
364   struct notation *nd, *notations;
365
366   if (which == 0)
367     which = 3;
368
369   notations = sig_to_notation (sig);
370
371   /* There may be multiple notations in the same sig. */
372   for (nd = notations; nd; nd = nd->next)
373     {
374       if (mode != 2)
375         {
376           int has_at = !!strchr (nd->name, '@');
377
378           if ((which & 1 && !has_at) || (which & 2 && has_at))
379             {
380               int i;
381               const char *str;
382
383               for (i = 0; i < indent; i++)
384                 es_putc (' ', es_stdout);
385
386               if (nd->flags.critical)
387                 str = _("Critical signature notation: ");
388               else
389                 str = _("Signature notation: ");
390               if (mode)
391                 log_info ("%s", str);
392               else
393                 es_fprintf (es_stdout, "%s", str);
394               /* This is all UTF8 */
395               print_utf8_buffer (fp, nd->name, strlen (nd->name));
396               es_fprintf (fp, "=");
397               print_utf8_buffer (fp, nd->value, strlen (nd->value));
398               /* (We need to use log_printf so that the next call to a
399                   log function does not insert an extra LF.)  */
400               if (mode)
401                 log_printf ("\n");
402               else
403                 es_putc ('\n', fp);
404             }
405         }
406
407       if (mode)
408         {
409           write_status_buffer (STATUS_NOTATION_NAME,
410                                nd->name, strlen (nd->name), 0);
411           write_status_buffer (STATUS_NOTATION_DATA,
412                                nd->value, strlen (nd->value), 50);
413         }
414     }
415
416   free_notation (notations);
417 }
418
419 static void
420 print_signature_stats (struct sig_stats *s)
421 {
422   if (s->inv_sigs == 1)
423     tty_printf (_("1 bad signature\n"));
424   else if (s->inv_sigs)
425     tty_printf (_("%d bad signatures\n"), s->inv_sigs);
426   if (s->no_key == 1)
427     tty_printf (_("1 signature not checked due to a missing key\n"));
428   else if (s->no_key)
429     tty_printf (_("%d signatures not checked due to missing keys\n"),
430                 s->no_key);
431   if (s->oth_err == 1)
432     tty_printf (_("1 signature not checked due to an error\n"));
433   else if (s->oth_err)
434     tty_printf (_("%d signatures not checked due to errors\n"), s->oth_err);
435 }
436
437
438 /* List all keys.  If SECRET is true only secret keys are listed.  If
439    MARK_SECRET is true secret keys are indicated in a public key
440    listing.  */
441 static void
442 list_all (int secret, int mark_secret)
443 {
444   KEYDB_HANDLE hd;
445   KBNODE keyblock = NULL;
446   int rc = 0;
447   int any_secret;
448   const char *lastresname, *resname;
449   struct sig_stats stats;
450
451   memset (&stats, 0, sizeof (stats));
452
453   hd = keydb_new ();
454   if (!hd)
455     rc = gpg_error (GPG_ERR_GENERAL);
456   else
457     rc = keydb_search_first (hd);
458   if (rc)
459     {
460       if (gpg_err_code (rc) != GPG_ERR_NOT_FOUND)
461         log_error ("keydb_search_first failed: %s\n", gpg_strerror (rc));
462       goto leave;
463     }
464
465   lastresname = NULL;
466   do
467     {
468       rc = keydb_get_keyblock (hd, &keyblock);
469       if (rc)
470         {
471           if (gpg_err_code (rc) == GPG_ERR_LEGACY_KEY)
472             continue;  /* Skip legacy keys.  */
473           log_error ("keydb_get_keyblock failed: %s\n", gpg_strerror (rc));
474           goto leave;
475         }
476
477       if (secret || mark_secret)
478         any_secret = !agent_probe_any_secret_key (NULL, keyblock);
479       else
480         any_secret = 0;
481
482       if (secret && !any_secret)
483         ; /* Secret key listing requested but this isn't one.  */
484       else
485         {
486           if (!opt.with_colons)
487             {
488               resname = keydb_get_resource_name (hd);
489               if (lastresname != resname)
490                 {
491                   int i;
492
493                   es_fprintf (es_stdout, "%s\n", resname);
494                   for (i = strlen (resname); i; i--)
495                     es_putc ('-', es_stdout);
496                   es_putc ('\n', es_stdout);
497                   lastresname = resname;
498                 }
499             }
500           merge_keys_and_selfsig (keyblock);
501           list_keyblock (keyblock, secret, any_secret, opt.fingerprint,
502                          opt.check_sigs ? &stats : NULL);
503         }
504       release_kbnode (keyblock);
505       keyblock = NULL;
506     }
507   while (!(rc = keydb_search_next (hd)));
508   es_fflush (es_stdout);
509   if (rc && gpg_err_code (rc) != GPG_ERR_NOT_FOUND)
510     log_error ("keydb_search_next failed: %s\n", gpg_strerror (rc));
511   if (keydb_get_skipped_counter (hd))
512     log_info (_("Warning: %lu key(s) skipped due to their large size\n"),
513               keydb_get_skipped_counter (hd));
514
515   if (opt.check_sigs && !opt.with_colons)
516     print_signature_stats (&stats);
517
518 leave:
519   release_kbnode (keyblock);
520   keydb_release (hd);
521 }
522
523
524 static void
525 list_one (strlist_t names, int secret, int mark_secret)
526 {
527   int rc = 0;
528   KBNODE keyblock = NULL;
529   GETKEY_CTX ctx;
530   const char *resname;
531   const char *keyring_str = _("Keyring");
532   int i;
533   struct sig_stats stats;
534
535   memset (&stats, 0, sizeof (stats));
536
537   /* fixme: using the bynames function has the disadvantage that we
538    * don't know wether one of the names given was not found.  OTOH,
539    * this function has the advantage to list the names in the
540    * sequence as defined by the keyDB and does not duplicate
541    * outputs.  A solution could be do test whether all given have
542    * been listed (this needs a way to use the keyDB search
543    * functions) or to have the search function return indicators for
544    * found names.  Yet another way is to use the keydb search
545    * facilities directly. */
546   rc = getkey_bynames (&ctx, NULL, names, secret, &keyblock);
547   if (rc)
548     {
549       log_error ("error reading key: %s\n", gpg_strerror (rc));
550       get_pubkey_end (ctx);
551       return;
552     }
553
554   do
555     {
556       if ((opt.list_options & LIST_SHOW_KEYRING) && !opt.with_colons)
557         {
558           resname = keydb_get_resource_name (get_ctx_handle (ctx));
559           es_fprintf (es_stdout, "%s: %s\n", keyring_str, resname);
560           for (i = strlen (resname) + strlen (keyring_str) + 2; i; i--)
561             es_putc ('-', es_stdout);
562           es_putc ('\n', es_stdout);
563         }
564       list_keyblock (keyblock, secret, mark_secret, opt.fingerprint,
565                      (!secret && opt.check_sigs)? &stats : NULL);
566       release_kbnode (keyblock);
567     }
568   while (!getkey_next (ctx, NULL, &keyblock));
569   getkey_end (ctx);
570
571   if (opt.check_sigs && !opt.with_colons)
572     print_signature_stats (&stats);
573 }
574
575
576 static void
577 locate_one (ctrl_t ctrl, strlist_t names)
578 {
579   int rc = 0;
580   strlist_t sl;
581   GETKEY_CTX ctx = NULL;
582   KBNODE keyblock = NULL;
583   struct sig_stats stats;
584
585   memset (&stats, 0, sizeof (stats));
586
587   for (sl = names; sl; sl = sl->next)
588     {
589       rc = get_pubkey_byname (ctrl, &ctx, NULL, sl->d, &keyblock, NULL, 1, 0);
590       if (rc)
591         {
592           if (gpg_err_code (rc) != GPG_ERR_NO_PUBKEY)
593             log_error ("error reading key: %s\n", gpg_strerror (rc));
594         }
595       else
596         {
597           do
598             {
599               list_keyblock (keyblock, 0, 0, opt.fingerprint,
600                              opt.check_sigs ? &stats : NULL);
601               release_kbnode (keyblock);
602             }
603           while (ctx && !get_pubkey_next (ctx, NULL, &keyblock));
604           get_pubkey_end (ctx);
605           ctx = NULL;
606         }
607     }
608
609   if (opt.check_sigs && !opt.with_colons)
610     print_signature_stats (&stats);
611 }
612
613
614 static void
615 print_key_data (PKT_public_key * pk)
616 {
617   int n = pk ? pubkey_get_npkey (pk->pubkey_algo) : 0;
618   int i;
619
620   for (i = 0; i < n; i++)
621     {
622       es_fprintf (es_stdout, "pkd:%d:%u:", i, mpi_get_nbits (pk->pkey[i]));
623       mpi_print (es_stdout, pk->pkey[i], 1);
624       es_putc (':', es_stdout);
625       es_putc ('\n', es_stdout);
626     }
627 }
628
629 static void
630 print_capabilities (PKT_public_key *pk, KBNODE keyblock)
631 {
632   unsigned int use = pk->pubkey_usage;
633   int c_printed = 0;
634
635   if (use & PUBKEY_USAGE_ENC)
636     es_putc ('e', es_stdout);
637
638   if (use & PUBKEY_USAGE_SIG)
639     {
640       es_putc ('s', es_stdout);
641       if (pk->flags.primary)
642         {
643           es_putc ('c', es_stdout);
644           /* The PUBKEY_USAGE_CERT flag was introduced later and we
645              used to always print 'c' for a primary key.  To avoid any
646              regression here we better track whether we printed 'c'
647              already.  */
648           c_printed = 1;
649         }
650     }
651
652   if ((use & PUBKEY_USAGE_CERT) && !c_printed)
653     es_putc ('c', es_stdout);
654
655   if ((use & PUBKEY_USAGE_AUTH))
656     es_putc ('a', es_stdout);
657
658   if ((use & PUBKEY_USAGE_UNKNOWN))
659     es_putc ('?', es_stdout);
660
661   if (keyblock)
662     {
663       /* Figure out the usable capabilities.  */
664       KBNODE k;
665       int enc = 0, sign = 0, cert = 0, auth = 0, disabled = 0;
666
667       for (k = keyblock; k; k = k->next)
668         {
669           if (k->pkt->pkttype == PKT_PUBLIC_KEY
670               || k->pkt->pkttype == PKT_PUBLIC_SUBKEY)
671             {
672               pk = k->pkt->pkt.public_key;
673
674               if (pk->flags.primary)
675                 disabled = pk_is_disabled (pk);
676
677               if (pk->flags.valid && !pk->flags.revoked && !pk->has_expired)
678                 {
679                   if (pk->pubkey_usage & PUBKEY_USAGE_ENC)
680                     enc = 1;
681                   if (pk->pubkey_usage & PUBKEY_USAGE_SIG)
682                     {
683                       sign = 1;
684                       if (pk->flags.primary)
685                         cert = 1;
686                     }
687                   if (pk->pubkey_usage & PUBKEY_USAGE_CERT)
688                     cert = 1;
689                   if ((pk->pubkey_usage & PUBKEY_USAGE_AUTH))
690                     auth = 1;
691                 }
692             }
693         }
694       if (enc)
695         es_putc ('E', es_stdout);
696       if (sign)
697         es_putc ('S', es_stdout);
698       if (cert)
699         es_putc ('C', es_stdout);
700       if (auth)
701         es_putc ('A', es_stdout);
702       if (disabled)
703         es_putc ('D', es_stdout);
704     }
705
706   es_putc (':', es_stdout);
707 }
708
709
710 /* FLAGS: 0x01 hashed
711           0x02 critical  */
712 static void
713 print_one_subpacket (sigsubpkttype_t type, size_t len, int flags,
714                      const byte * buf)
715 {
716   size_t i;
717
718   es_fprintf (es_stdout, "spk:%d:%u:%u:", type, flags, (unsigned int) len);
719
720   for (i = 0; i < len; i++)
721     {
722       /* printable ascii other than : and % */
723       if (buf[i] >= 32 && buf[i] <= 126 && buf[i] != ':' && buf[i] != '%')
724         es_fprintf (es_stdout, "%c", buf[i]);
725       else
726         es_fprintf (es_stdout, "%%%02X", buf[i]);
727     }
728
729   es_fprintf (es_stdout, "\n");
730 }
731
732
733 void
734 print_subpackets_colon (PKT_signature * sig)
735 {
736   byte *i;
737
738   assert (opt.show_subpackets);
739
740   for (i = opt.show_subpackets; *i; i++)
741     {
742       const byte *p;
743       size_t len;
744       int seq, crit;
745
746       seq = 0;
747
748       while ((p = enum_sig_subpkt (sig->hashed, *i, &len, &seq, &crit)))
749         print_one_subpacket (*i, len, 0x01 | (crit ? 0x02 : 0), p);
750
751       seq = 0;
752
753       while ((p = enum_sig_subpkt (sig->unhashed, *i, &len, &seq, &crit)))
754         print_one_subpacket (*i, len, 0x00 | (crit ? 0x02 : 0), p);
755     }
756 }
757
758
759 void
760 dump_attribs (const PKT_user_id *uid, PKT_public_key *pk)
761 {
762   int i;
763
764   if (!attrib_fp)
765     return;
766
767   for (i = 0; i < uid->numattribs; i++)
768     {
769       if (is_status_enabled ())
770         {
771           byte array[MAX_FINGERPRINT_LEN], *p;
772           char buf[(MAX_FINGERPRINT_LEN * 2) + 90];
773           size_t j, n;
774
775           if (!pk)
776             BUG ();
777           fingerprint_from_pk (pk, array, &n);
778
779           p = array;
780           for (j = 0; j < n; j++, p++)
781             sprintf (buf + 2 * j, "%02X", *p);
782
783           sprintf (buf + strlen (buf), " %lu %u %u %u %lu %lu %u",
784                    (ulong) uid->attribs[i].len, uid->attribs[i].type, i + 1,
785                    uid->numattribs, (ulong) uid->created,
786                    (ulong) uid->expiredate,
787                    ((uid->is_primary ? 0x01 : 0) | (uid->
788                                                     is_revoked ? 0x02 : 0) |
789                     (uid->is_expired ? 0x04 : 0)));
790           write_status_text (STATUS_ATTRIBUTE, buf);
791         }
792
793       es_fwrite (uid->attribs[i].data, uid->attribs[i].len, 1, attrib_fp);
794       es_fflush (attrib_fp);
795     }
796 }
797
798
799 /* Print IPGP cert records instead of a standard key listing.  */
800 static void
801 list_keyblock_pka (kbnode_t keyblock)
802 {
803   kbnode_t kbctx;
804   kbnode_t node;
805   PKT_public_key *pk;
806   char pkstrbuf[PUBKEY_STRING_SIZE];
807   char *hexfpr;
808
809   /* Get the keyid from the keyblock.  */
810   node = find_kbnode (keyblock, PKT_PUBLIC_KEY);
811   if (!node)
812     {
813       log_error ("Oops; key lost!\n");
814       dump_kbnode (keyblock);
815       return;
816     }
817
818   pk = node->pkt->pkt.public_key;
819
820   es_fprintf (es_stdout, ";; pub  %s/%s %s\n;; ",
821               pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
822               keystr_from_pk (pk), datestr_from_pk (pk));
823   print_fingerprint (NULL, pk, 10);
824   hexfpr = hexfingerprint (pk);
825
826   for (kbctx = NULL; (node = walk_kbnode (keyblock, &kbctx, 0));)
827     {
828       if (node->pkt->pkttype == PKT_USER_ID)
829         {
830           PKT_user_id *uid = node->pkt->pkt.user_id;
831           char *mbox;
832           char *p;
833
834           if (pk && (uid->is_expired || uid->is_revoked)
835               && !(opt.list_options & LIST_SHOW_UNUSABLE_UIDS))
836             continue;
837
838           es_fputs (";; uid  ", es_stdout);
839           print_utf8_buffer (es_stdout, uid->name, uid->len);
840           es_putc ('\n', es_stdout);
841           mbox = mailbox_from_userid (uid->name);
842           if (mbox && (p = strchr (mbox, '@')))
843             {
844               char hashbuf[20];
845               char *hash;
846               unsigned int len;
847
848               *p++ = 0;
849               es_fprintf (es_stdout, "$ORIGIN _pka.%s.\n", p);
850               gcry_md_hash_buffer (GCRY_MD_SHA1, hashbuf, mbox, strlen (mbox));
851               hash = zb32_encode (hashbuf, 8*20);
852               if (hash)
853                 {
854                   len = strlen (hexfpr)/2;
855                   es_fprintf (es_stdout,
856                               "%s TYPE37 \\# %u 0006 0000 00 %02X %s\n",
857                               hash, 6 + len, len, hexfpr);
858                   xfree (hash);
859                 }
860             }
861           xfree (mbox);
862         }
863
864     }
865   es_putc ('\n', es_stdout);
866
867   xfree (hexfpr);
868 }
869
870
871 static void
872 list_keyblock_print (KBNODE keyblock, int secret, int fpr, void *opaque)
873 {
874   int rc;
875   KBNODE kbctx;
876   KBNODE node;
877   PKT_public_key *pk;
878   struct sig_stats *stats = opaque;
879   int skip_sigs = 0;
880   int s2k_char;
881   char *hexgrip = NULL;
882   char *serialno = NULL;
883   char pkstrbuf[PUBKEY_STRING_SIZE];
884
885   /* Get the keyid from the keyblock.  */
886   node = find_kbnode (keyblock, PKT_PUBLIC_KEY);
887   if (!node)
888     {
889       log_error ("Oops; key lost!\n");
890       dump_kbnode (keyblock);
891       return;
892     }
893
894   pk = node->pkt->pkt.public_key;
895
896   if (secret || opt.with_keygrip)
897     {
898       rc = hexkeygrip_from_pk (pk, &hexgrip);
899       if (rc)
900         log_error ("error computing a keygrip: %s\n", gpg_strerror (rc));
901     }
902
903   if (secret)
904     {
905       if (!agent_get_keyinfo (NULL, hexgrip, &serialno))
906         s2k_char = serialno? '>':' ';
907       else
908         s2k_char = '#';  /* Key not found.  */
909     }
910   else
911     s2k_char = ' ';
912
913   check_trustdb_stale ();
914
915
916   es_fprintf (es_stdout, "%s%c  %s/%s %s",
917               secret? "sec":"pub",
918               s2k_char,
919               pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
920               keystr_from_pk (pk), datestr_from_pk (pk));
921
922   if ((opt.list_options & LIST_SHOW_USAGE))
923     {
924       es_fprintf (es_stdout, " [%s]", usagestr_from_pk (pk, 0));
925     }
926   if (pk->flags.revoked)
927     {
928       es_fprintf (es_stdout, " [");
929       es_fprintf (es_stdout, _("revoked: %s"), revokestr_from_pk (pk));
930       es_fprintf (es_stdout, "]");
931     }
932   else if (pk->has_expired)
933     {
934       es_fprintf (es_stdout, " [");
935       es_fprintf (es_stdout, _("expired: %s"), expirestr_from_pk (pk));
936       es_fprintf (es_stdout, "]");
937     }
938   else if (pk->expiredate)
939     {
940       es_fprintf (es_stdout, " [");
941       es_fprintf (es_stdout, _("expires: %s"), expirestr_from_pk (pk));
942       es_fprintf (es_stdout, "]");
943     }
944
945 #if 0
946   /* I need to think about this some more.  It's easy enough to
947      include, but it looks sort of confusing in the listing... */
948   if (opt.list_options & LIST_SHOW_VALIDITY)
949     {
950       int validity = get_validity (pk, NULL);
951       es_fprintf (es_stdout, " [%s]", trust_value_to_string (validity));
952     }
953 #endif
954
955   if (pk->pubkey_algo >= 100)
956     es_fprintf (es_stdout, " [experimental algorithm %d]", pk->pubkey_algo);
957
958   es_fprintf (es_stdout, "\n");
959
960   if (fpr)
961     print_fingerprint (NULL, pk, 0);
962
963   if (opt.with_keygrip && hexgrip)
964     es_fprintf (es_stdout, "      Keygrip = %s\n", hexgrip);
965
966   if (serialno)
967     print_card_serialno (serialno);
968
969   if (opt.with_key_data)
970     print_key_data (pk);
971
972   for (kbctx = NULL; (node = walk_kbnode (keyblock, &kbctx, 0));)
973     {
974       if (node->pkt->pkttype == PKT_USER_ID && !opt.fast_list_mode)
975         {
976           PKT_user_id *uid = node->pkt->pkt.user_id;
977
978           if (pk && (uid->is_expired || uid->is_revoked)
979               && !(opt.list_options & LIST_SHOW_UNUSABLE_UIDS))
980             {
981               skip_sigs = 1;
982               continue;
983             }
984           else
985             skip_sigs = 0;
986
987           if (attrib_fp && uid->attrib_data != NULL)
988             dump_attribs (uid, pk);
989
990           if ((uid->is_revoked || uid->is_expired)
991               || ((opt.list_options & LIST_SHOW_UID_VALIDITY) && pk))
992             {
993               const char *validity;
994               int indent;
995
996               validity = uid_trust_string_fixed (pk, uid);
997               indent =
998                 (keystrlen () + 9) -
999                 atoi (uid_trust_string_fixed (NULL, NULL));
1000
1001               if (indent < 0 || indent > 40)
1002                 indent = 0;
1003
1004               es_fprintf (es_stdout, "uid%*s%s ", indent, "", validity);
1005             }
1006           else
1007             es_fprintf (es_stdout, "uid%*s", (int) keystrlen () + 10, "");
1008
1009           print_utf8_buffer (es_stdout, uid->name, uid->len);
1010           es_putc ('\n', es_stdout);
1011
1012           if ((opt.list_options & LIST_SHOW_PHOTOS) && uid->attribs != NULL)
1013             show_photos (uid->attribs, uid->numattribs, pk, uid);
1014         }
1015       else if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1016         {
1017           PKT_public_key *pk2 = node->pkt->pkt.public_key;
1018
1019           if ((pk2->flags.revoked || pk2->has_expired)
1020               && !(opt.list_options & LIST_SHOW_UNUSABLE_SUBKEYS))
1021             {
1022               skip_sigs = 1;
1023               continue;
1024             }
1025           else
1026             skip_sigs = 0;
1027
1028           xfree (serialno); serialno = NULL;
1029           xfree (hexgrip); hexgrip = NULL;
1030           if (secret || opt.with_keygrip)
1031             {
1032               rc = hexkeygrip_from_pk (pk2, &hexgrip);
1033               if (rc)
1034                 log_error ("error computing a keygrip: %s\n",
1035                            gpg_strerror (rc));
1036             }
1037           if (secret)
1038             {
1039               if (!agent_get_keyinfo (NULL, hexgrip, &serialno))
1040                 s2k_char = serialno? '>':' ';
1041               else
1042                 s2k_char = '#';  /* Key not found.  */
1043             }
1044           else
1045             s2k_char = ' ';
1046
1047           es_fprintf (es_stdout, "%s%c  %s/%s %s",
1048                   secret? "ssb":"sub",
1049                   s2k_char,
1050                   pubkey_string (pk2, pkstrbuf, sizeof pkstrbuf),
1051                   keystr_from_pk (pk2), datestr_from_pk (pk2));
1052
1053           if (pk2->pubkey_algo == PUBKEY_ALGO_ECDSA
1054               || pk2->pubkey_algo == PUBKEY_ALGO_EDDSA
1055               || pk2->pubkey_algo == PUBKEY_ALGO_ECDH)
1056             {
1057               char *curve = openpgp_oid_to_str (pk2->pkey[0]);
1058               const char *name = openpgp_oid_to_curve (curve);
1059               if (!*name || *name == '?')
1060                 name = curve;
1061               es_fprintf (es_stdout, " %s", name);
1062               xfree (curve);
1063             }
1064
1065           if ((opt.list_options & LIST_SHOW_USAGE))
1066             {
1067               es_fprintf (es_stdout, " [%s]", usagestr_from_pk (pk2, 0));
1068             }
1069           if (pk2->flags.revoked)
1070             {
1071               es_fprintf (es_stdout, " [");
1072               es_fprintf (es_stdout, _("revoked: %s"), revokestr_from_pk (pk2));
1073               es_fprintf (es_stdout, "]");
1074             }
1075           else if (pk2->has_expired)
1076             {
1077               es_fprintf (es_stdout, " [");
1078               es_fprintf (es_stdout, _("expired: %s"), expirestr_from_pk (pk2));
1079               es_fprintf (es_stdout, "]");
1080             }
1081           else if (pk2->expiredate)
1082             {
1083               es_fprintf (es_stdout, " [");
1084               es_fprintf (es_stdout, _("expires: %s"), expirestr_from_pk (pk2));
1085               es_fprintf (es_stdout, "]");
1086             }
1087           es_putc ('\n', es_stdout);
1088           if (fpr > 1)
1089             {
1090               print_fingerprint (NULL, pk2, 0);
1091               if (serialno)
1092                 print_card_serialno (serialno);
1093             }
1094           if (opt.with_keygrip && hexgrip)
1095             es_fprintf (es_stdout, "      Keygrip = %s\n", hexgrip);
1096           if (opt.with_key_data)
1097             print_key_data (pk2);
1098         }
1099       else if (opt.list_sigs
1100                && node->pkt->pkttype == PKT_SIGNATURE && !skip_sigs)
1101         {
1102           PKT_signature *sig = node->pkt->pkt.signature;
1103           int sigrc;
1104           char *sigstr;
1105
1106           if (stats)
1107             {
1108               rc = check_key_signature (keyblock, node, NULL);
1109               switch (gpg_err_code (rc))
1110                 {
1111                 case 0:
1112                   sigrc = '!';
1113                   break;
1114                 case GPG_ERR_BAD_SIGNATURE:
1115                   stats->inv_sigs++;
1116                   sigrc = '-';
1117                   break;
1118                 case GPG_ERR_NO_PUBKEY:
1119                 case GPG_ERR_UNUSABLE_PUBKEY:
1120                   stats->no_key++;
1121                   continue;
1122                 default:
1123                   stats->oth_err++;
1124                   sigrc = '%';
1125                   break;
1126                 }
1127
1128               /* TODO: Make sure a cached sig record here still has
1129                  the pk that issued it.  See also
1130                  keyedit.c:print_and_check_one_sig */
1131             }
1132           else
1133             {
1134               rc = 0;
1135               sigrc = ' ';
1136             }
1137
1138           if (sig->sig_class == 0x20 || sig->sig_class == 0x28
1139               || sig->sig_class == 0x30)
1140             sigstr = "rev";
1141           else if ((sig->sig_class & ~3) == 0x10)
1142             sigstr = "sig";
1143           else if (sig->sig_class == 0x18)
1144             sigstr = "sig";
1145           else if (sig->sig_class == 0x1F)
1146             sigstr = "sig";
1147           else
1148             {
1149               es_fprintf (es_stdout, "sig                             "
1150                       "[unexpected signature class 0x%02x]\n",
1151                       sig->sig_class);
1152               continue;
1153             }
1154
1155           es_fputs (sigstr, es_stdout);
1156           es_fprintf (es_stdout, "%c%c %c%c%c%c%c%c %s %s",
1157                   sigrc, (sig->sig_class - 0x10 > 0 &&
1158                           sig->sig_class - 0x10 <
1159                           4) ? '0' + sig->sig_class - 0x10 : ' ',
1160                   sig->flags.exportable ? ' ' : 'L',
1161                   sig->flags.revocable ? ' ' : 'R',
1162                   sig->flags.policy_url ? 'P' : ' ',
1163                   sig->flags.notation ? 'N' : ' ',
1164                   sig->flags.expired ? 'X' : ' ',
1165                   (sig->trust_depth > 9) ? 'T' : (sig->trust_depth >
1166                                                   0) ? '0' +
1167                   sig->trust_depth : ' ', keystr (sig->keyid),
1168                   datestr_from_sig (sig));
1169           if (opt.list_options & LIST_SHOW_SIG_EXPIRE)
1170             es_fprintf (es_stdout, " %s", expirestr_from_sig (sig));
1171           es_fprintf (es_stdout, "  ");
1172           if (sigrc == '%')
1173             es_fprintf (es_stdout, "[%s] ", gpg_strerror (rc));
1174           else if (sigrc == '?')
1175             ;
1176           else if (!opt.fast_list_mode)
1177             {
1178               size_t n;
1179               char *p = get_user_id (sig->keyid, &n);
1180               print_utf8_buffer (es_stdout, p, n);
1181               xfree (p);
1182             }
1183           es_putc ('\n', es_stdout);
1184
1185           if (sig->flags.policy_url
1186               && (opt.list_options & LIST_SHOW_POLICY_URLS))
1187             show_policy_url (sig, 3, 0);
1188
1189           if (sig->flags.notation && (opt.list_options & LIST_SHOW_NOTATIONS))
1190             show_notation (sig, 3, 0,
1191                            ((opt.
1192                              list_options & LIST_SHOW_STD_NOTATIONS) ? 1 : 0)
1193                            +
1194                            ((opt.
1195                              list_options & LIST_SHOW_USER_NOTATIONS) ? 2 :
1196                             0));
1197
1198           if (sig->flags.pref_ks
1199               && (opt.list_options & LIST_SHOW_KEYSERVER_URLS))
1200             show_keyserver_url (sig, 3, 0);
1201
1202           /* fixme: check or list other sigs here */
1203         }
1204     }
1205   es_putc ('\n', es_stdout);
1206   xfree (serialno);
1207   xfree (hexgrip);
1208 }
1209
1210 void
1211 print_revokers (estream_t fp, PKT_public_key * pk)
1212 {
1213   /* print the revoker record */
1214   if (!pk->revkey && pk->numrevkeys)
1215     BUG ();
1216   else
1217     {
1218       int i, j;
1219
1220       for (i = 0; i < pk->numrevkeys; i++)
1221         {
1222           byte *p;
1223
1224           es_fprintf (fp, "rvk:::%d::::::", pk->revkey[i].algid);
1225           p = pk->revkey[i].fpr;
1226           for (j = 0; j < 20; j++, p++)
1227             es_fprintf (fp, "%02X", *p);
1228           es_fprintf (fp, ":%02x%s:\n",
1229                       pk->revkey[i].class,
1230                       (pk->revkey[i].class & 0x40) ? "s" : "");
1231         }
1232     }
1233 }
1234
1235
1236 /* List a key in colon mode.  If SECRET is true this is a secret key
1237    record (i.e. requested via --list-secret-key).  If HAS_SECRET a
1238    secret key is available even if SECRET is not set.  */
1239 static void
1240 list_keyblock_colon (KBNODE keyblock, int secret, int has_secret, int fpr)
1241 {
1242   int rc;
1243   KBNODE kbctx;
1244   KBNODE node;
1245   PKT_public_key *pk;
1246   u32 keyid[2];
1247   int trustletter = 0;
1248   int ulti_hack = 0;
1249   int i;
1250   char *p;
1251   char *hexgrip = NULL;
1252   char *serialno = NULL;
1253   int stubkey;
1254
1255   /* Get the keyid from the keyblock.  */
1256   node = find_kbnode (keyblock, PKT_PUBLIC_KEY);
1257   if (!node)
1258     {
1259       log_error ("Oops; key lost!\n");
1260       dump_kbnode (keyblock);
1261       return;
1262     }
1263
1264   pk = node->pkt->pkt.public_key;
1265   if (secret || has_secret || opt.with_keygrip || opt.with_key_data)
1266     {
1267       rc = hexkeygrip_from_pk (pk, &hexgrip);
1268       if (rc)
1269         log_error ("error computing a keygrip: %s\n", gpg_strerror (rc));
1270     }
1271   stubkey = 0;
1272   if ((secret||has_secret) && agent_get_keyinfo (NULL, hexgrip, &serialno))
1273     stubkey = 1;  /* Key not found.  */
1274
1275   keyid_from_pk (pk, keyid);
1276   es_fputs (secret? "sec:":"pub:", es_stdout);
1277   if (!pk->flags.valid)
1278     es_putc ('i', es_stdout);
1279   else if (pk->flags.revoked)
1280     es_putc ('r', es_stdout);
1281   else if (pk->has_expired)
1282     es_putc ('e', es_stdout);
1283   else if (opt.fast_list_mode || opt.no_expensive_trust_checks)
1284     ;
1285   else
1286     {
1287       trustletter = get_validity_info (pk, NULL);
1288       if (trustletter == 'u')
1289         ulti_hack = 1;
1290       es_putc (trustletter, es_stdout);
1291     }
1292
1293   es_fprintf (es_stdout, ":%u:%d:%08lX%08lX:%s:%s::",
1294           nbits_from_pk (pk),
1295           pk->pubkey_algo,
1296           (ulong) keyid[0], (ulong) keyid[1],
1297           colon_datestr_from_pk (pk), colon_strtime (pk->expiredate));
1298
1299   if (!opt.fast_list_mode && !opt.no_expensive_trust_checks)
1300     es_putc (get_ownertrust_info (pk), es_stdout);
1301   es_putc (':', es_stdout);
1302
1303   es_putc (':', es_stdout);
1304   es_putc (':', es_stdout);
1305   print_capabilities (pk, keyblock);
1306   es_putc (':', es_stdout);             /* End of field 13. */
1307   es_putc (':', es_stdout);             /* End of field 14. */
1308   if (secret || has_secret)
1309     {
1310       if (stubkey)
1311         es_putc ('#', es_stdout);
1312       else if (serialno)
1313         es_fputs (serialno, es_stdout);
1314       else if (has_secret)
1315         es_putc ('+', es_stdout);
1316     }
1317   es_putc (':', es_stdout);             /* End of field 15. */
1318   es_putc (':', es_stdout);             /* End of field 16. */
1319   if (pk->pubkey_algo == PUBKEY_ALGO_ECDSA
1320       || pk->pubkey_algo == PUBKEY_ALGO_EDDSA
1321       || pk->pubkey_algo == PUBKEY_ALGO_ECDH)
1322     {
1323       char *curve = openpgp_oid_to_str (pk->pkey[0]);
1324       const char *name = openpgp_oid_to_curve (curve);
1325       if (!*name || *name == '?')
1326         name = curve;
1327       es_fputs (name, es_stdout);
1328       xfree (curve);
1329     }
1330   es_putc (':', es_stdout);             /* End of field 17. */
1331   es_putc ('\n', es_stdout);
1332
1333   print_revokers (es_stdout, pk);
1334   if (fpr)
1335     print_fingerprint (NULL, pk, 0);
1336   if (opt.with_key_data || opt.with_keygrip)
1337     {
1338       if (hexgrip)
1339         es_fprintf (es_stdout, "grp:::::::::%s:\n", hexgrip);
1340       if (opt.with_key_data)
1341         print_key_data (pk);
1342     }
1343
1344   for (kbctx = NULL; (node = walk_kbnode (keyblock, &kbctx, 0));)
1345     {
1346       if (node->pkt->pkttype == PKT_USER_ID && !opt.fast_list_mode)
1347         {
1348           char *str;
1349           PKT_user_id *uid = node->pkt->pkt.user_id;
1350
1351           if (attrib_fp && node->pkt->pkt.user_id->attrib_data != NULL)
1352             dump_attribs (node->pkt->pkt.user_id, pk);
1353           /*
1354            * Fixme: We need a valid flag here too
1355            */
1356           str = uid->attrib_data ? "uat" : "uid";
1357           if (uid->is_revoked)
1358             es_fprintf (es_stdout, "%s:r::::", str);
1359           else if (uid->is_expired)
1360             es_fprintf (es_stdout, "%s:e::::", str);
1361           else if (opt.no_expensive_trust_checks)
1362             es_fprintf (es_stdout, "%s:::::", str);
1363           else
1364             {
1365               int uid_validity;
1366
1367               if (pk && !ulti_hack)
1368                 uid_validity = get_validity_info (pk, uid);
1369               else
1370                 uid_validity = 'u';
1371               es_fprintf (es_stdout, "%s:%c::::", str, uid_validity);
1372             }
1373
1374           es_fprintf (es_stdout, "%s:", colon_strtime (uid->created));
1375           es_fprintf (es_stdout, "%s:", colon_strtime (uid->expiredate));
1376
1377           namehash_from_uid (uid);
1378
1379           for (i = 0; i < 20; i++)
1380             es_fprintf (es_stdout, "%02X", uid->namehash[i]);
1381
1382           es_fprintf (es_stdout, "::");
1383
1384           if (uid->attrib_data)
1385             es_fprintf (es_stdout, "%u %lu", uid->numattribs, uid->attrib_len);
1386           else
1387             es_write_sanitized (es_stdout, uid->name, uid->len, ":", NULL);
1388           es_putc (':', es_stdout);
1389           es_putc ('\n', es_stdout);
1390         }
1391       else if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1392         {
1393           u32 keyid2[2];
1394           PKT_public_key *pk2;
1395
1396           pk2 = node->pkt->pkt.public_key;
1397           xfree (hexgrip); hexgrip = NULL;
1398           xfree (serialno); serialno = NULL;
1399           if (secret || has_secret || opt.with_keygrip || opt.with_key_data)
1400             {
1401               rc = hexkeygrip_from_pk (pk2, &hexgrip);
1402               if (rc)
1403                 log_error ("error computing a keygrip: %s\n",
1404                            gpg_strerror (rc));
1405             }
1406           stubkey = 0;
1407           if ((secret||has_secret)
1408               && agent_get_keyinfo (NULL, hexgrip, &serialno))
1409             stubkey = 1;  /* Key not found.  */
1410
1411           keyid_from_pk (pk2, keyid2);
1412           es_fputs (secret? "ssb:":"sub:", es_stdout);
1413           if (!pk2->flags.valid)
1414             es_putc ('i', es_stdout);
1415           else if (pk2->flags.revoked)
1416             es_putc ('r', es_stdout);
1417           else if (pk2->has_expired)
1418             es_putc ('e', es_stdout);
1419           else if (opt.fast_list_mode || opt.no_expensive_trust_checks)
1420             ;
1421           else
1422             {
1423               /* TRUSTLETTER should always be defined here. */
1424               if (trustletter)
1425                 es_fprintf (es_stdout, "%c", trustletter);
1426             }
1427           es_fprintf (es_stdout, ":%u:%d:%08lX%08lX:%s:%s:::::",
1428                   nbits_from_pk (pk2),
1429                   pk2->pubkey_algo,
1430                   (ulong) keyid2[0], (ulong) keyid2[1],
1431                   colon_datestr_from_pk (pk2), colon_strtime (pk2->expiredate)
1432                   /* fixme: add LID and ownertrust here */
1433             );
1434           print_capabilities (pk2, NULL);
1435           es_putc (':', es_stdout);     /* End of field 13. */
1436           es_putc (':', es_stdout);     /* End of field 14. */
1437           if (secret || has_secret)
1438             {
1439               if (stubkey)
1440                 es_putc ('#', es_stdout);
1441               else if (serialno)
1442                 es_fputs (serialno, es_stdout);
1443               else if (has_secret)
1444                 es_putc ('+', es_stdout);
1445             }
1446           es_putc (':', es_stdout);     /* End of field 15. */
1447           es_putc (':', es_stdout);     /* End of field 16. */
1448           if (pk->pubkey_algo == PUBKEY_ALGO_ECDSA
1449               || pk->pubkey_algo == PUBKEY_ALGO_EDDSA
1450               || pk->pubkey_algo == PUBKEY_ALGO_ECDH)
1451             {
1452               char *curve = openpgp_oid_to_str (pk->pkey[0]);
1453               const char *name = openpgp_oid_to_curve (curve);
1454               if (!*name || *name == '?')
1455                 name = curve;
1456               es_fputs (name, es_stdout);
1457               xfree (curve);
1458             }
1459           es_putc (':', es_stdout);     /* End of field 17. */
1460           es_putc ('\n', es_stdout);
1461           if (fpr > 1)
1462             print_fingerprint (NULL, pk2, 0);
1463           if (opt.with_key_data || opt.with_keygrip)
1464             {
1465               if (hexgrip)
1466                 es_fprintf (es_stdout, "grp:::::::::%s:\n", hexgrip);
1467               if (opt.with_key_data)
1468                 print_key_data (pk2);
1469             }
1470         }
1471       else if (opt.list_sigs && node->pkt->pkttype == PKT_SIGNATURE)
1472         {
1473           PKT_signature *sig = node->pkt->pkt.signature;
1474           int sigrc, fprokay = 0;
1475           char *sigstr;
1476           size_t fplen;
1477           byte fparray[MAX_FINGERPRINT_LEN];
1478
1479           if (sig->sig_class == 0x20 || sig->sig_class == 0x28
1480               || sig->sig_class == 0x30)
1481             sigstr = "rev";
1482           else if ((sig->sig_class & ~3) == 0x10)
1483             sigstr = "sig";
1484           else if (sig->sig_class == 0x18)
1485             sigstr = "sig";
1486           else if (sig->sig_class == 0x1F)
1487             sigstr = "sig";
1488           else
1489             {
1490               es_fprintf (es_stdout, "sig::::::::::%02x%c:\n",
1491                       sig->sig_class, sig->flags.exportable ? 'x' : 'l');
1492               continue;
1493             }
1494
1495           if (opt.check_sigs)
1496             {
1497               PKT_public_key *signer_pk = NULL;
1498
1499               fflush (stdout);
1500               if (opt.no_sig_cache)
1501                 signer_pk = xmalloc_clear (sizeof (PKT_public_key));
1502
1503               rc = check_key_signature2 (keyblock, node, NULL, signer_pk,
1504                                          NULL, NULL, NULL);
1505               switch (gpg_err_code (rc))
1506                 {
1507                 case 0:
1508                   sigrc = '!';
1509                   break;
1510                 case GPG_ERR_BAD_SIGNATURE:
1511                   sigrc = '-';
1512                   break;
1513                 case GPG_ERR_NO_PUBKEY:
1514                 case GPG_ERR_UNUSABLE_PUBKEY:
1515                   sigrc = '?';
1516                   break;
1517                 default:
1518                   sigrc = '%';
1519                   break;
1520                 }
1521
1522               if (opt.no_sig_cache)
1523                 {
1524                   if (!rc)
1525                     {
1526                       fingerprint_from_pk (signer_pk, fparray, &fplen);
1527                       fprokay = 1;
1528                     }
1529                   free_public_key (signer_pk);
1530                 }
1531             }
1532           else
1533             {
1534               rc = 0;
1535               sigrc = ' ';
1536             }
1537           es_fputs (sigstr, es_stdout);
1538           es_putc (':', es_stdout);
1539           if (sigrc != ' ')
1540             es_putc (sigrc, es_stdout);
1541           es_fprintf (es_stdout, "::%d:%08lX%08lX:%s:%s:", sig->pubkey_algo,
1542                   (ulong) sig->keyid[0], (ulong) sig->keyid[1],
1543                   colon_datestr_from_sig (sig),
1544                   colon_expirestr_from_sig (sig));
1545
1546           if (sig->trust_depth || sig->trust_value)
1547             es_fprintf (es_stdout, "%d %d", sig->trust_depth, sig->trust_value);
1548           es_fprintf (es_stdout, ":");
1549
1550           if (sig->trust_regexp)
1551             es_write_sanitized (es_stdout, sig->trust_regexp,
1552                                 strlen (sig->trust_regexp), ":", NULL);
1553           es_fprintf (es_stdout, ":");
1554
1555           if (sigrc == '%')
1556             es_fprintf (es_stdout, "[%s] ", gpg_strerror (rc));
1557           else if (sigrc == '?')
1558             ;
1559           else if (!opt.fast_list_mode)
1560             {
1561               size_t n;
1562               p = get_user_id (sig->keyid, &n);
1563               es_write_sanitized (es_stdout, p, n, ":", NULL);
1564               xfree (p);
1565             }
1566           es_fprintf (es_stdout, ":%02x%c::", sig->sig_class,
1567                   sig->flags.exportable ? 'x' : 'l');
1568
1569           if (opt.no_sig_cache && opt.check_sigs && fprokay)
1570             {
1571               for (i = 0; i < fplen; i++)
1572                 es_fprintf (es_stdout, "%02X", fparray[i]);
1573             }
1574
1575           es_fprintf (es_stdout, ":::%d:\n", sig->digest_algo);
1576
1577           if (opt.show_subpackets)
1578             print_subpackets_colon (sig);
1579
1580           /* fixme: check or list other sigs here */
1581         }
1582     }
1583
1584   xfree (hexgrip);
1585   xfree (serialno);
1586 }
1587
1588 /*
1589  * Reorder the keyblock so that the primary user ID (and not attribute
1590  * packet) comes first.  Fixme: Replace this by a generic sort
1591  * function.  */
1592 static void
1593 do_reorder_keyblock (KBNODE keyblock, int attr)
1594 {
1595   KBNODE primary = NULL, primary0 = NULL, primary2 = NULL;
1596   KBNODE last, node;
1597
1598   for (node = keyblock; node; primary0 = node, node = node->next)
1599     {
1600       if (node->pkt->pkttype == PKT_USER_ID &&
1601           ((attr && node->pkt->pkt.user_id->attrib_data) ||
1602            (!attr && !node->pkt->pkt.user_id->attrib_data)) &&
1603           node->pkt->pkt.user_id->is_primary)
1604         {
1605           primary = primary2 = node;
1606           for (node = node->next; node; primary2 = node, node = node->next)
1607             {
1608               if (node->pkt->pkttype == PKT_USER_ID
1609                   || node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1610                   || node->pkt->pkttype == PKT_SECRET_SUBKEY)
1611                 {
1612                   break;
1613                 }
1614             }
1615           break;
1616         }
1617     }
1618   if (!primary)
1619     return; /* No primary key flag found (should not happen).  */
1620
1621   for (last = NULL, node = keyblock; node; last = node, node = node->next)
1622     {
1623       if (node->pkt->pkttype == PKT_USER_ID)
1624         break;
1625     }
1626   assert (node);
1627   assert (last);         /* The user ID is never the first packet.  */
1628   assert (primary0);     /* Ditto (this is the node before primary).  */
1629   if (node == primary)
1630     return; /* Already the first one.  */
1631
1632   last->next = primary;
1633   primary0->next = primary2->next;
1634   primary2->next = node;
1635 }
1636
1637 void
1638 reorder_keyblock (KBNODE keyblock)
1639 {
1640   do_reorder_keyblock (keyblock, 1);
1641   do_reorder_keyblock (keyblock, 0);
1642 }
1643
1644 void
1645 list_keyblock (KBNODE keyblock, int secret, int has_secret, int fpr,
1646                void *opaque)
1647 {
1648   reorder_keyblock (keyblock);
1649   if (opt.print_pka_records)
1650     {
1651       if (!secret)
1652         list_keyblock_pka (keyblock);
1653     }
1654   else if (opt.with_colons)
1655     list_keyblock_colon (keyblock, secret, has_secret, fpr);
1656   else
1657     list_keyblock_print (keyblock, secret, fpr, opaque);
1658   if (secret)
1659     es_fflush (es_stdout);
1660 }
1661
1662
1663 /* Print an hex digit in ICAO spelling.  */
1664 static void
1665 print_icao_hexdigit (estream_t fp, int c)
1666 {
1667   static const char *list[16] = {
1668     "Zero", "One", "Two", "Three", "Four", "Five", "Six", "Seven",
1669     "Eight", "Niner", "Alfa", "Bravo", "Charlie", "Delta", "Echo", "Foxtrot"
1670   };
1671
1672   tty_fprintf (fp, "%s", list[c&15]);
1673 }
1674
1675
1676 /*
1677  * Function to print the finperprint.
1678  * mode 0: as used in key listings, opt.with_colons is honored
1679  *      1: print using log_info ()
1680  *      2: direct use of tty
1681  *      3: direct use of tty but only primary key.
1682  *     10: Same as 0 but with_colons etc is ignored.
1683  *
1684  * Modes 1 and 2 will try and print both subkey and primary key
1685  * fingerprints.  A MODE with bit 7 set is used internally.  If
1686  * OVERRIDE_FP is not NULL that stream will be used in  0 instead
1687  * of es_stdout or instead of the TTY in modes 2 and 3.
1688  */
1689 void
1690 print_fingerprint (estream_t override_fp, PKT_public_key *pk, int mode)
1691 {
1692   byte array[MAX_FINGERPRINT_LEN], *p;
1693   size_t i, n;
1694   estream_t fp;
1695   const char *text;
1696   int primary = 0;
1697   int with_colons = opt.with_colons;
1698   int with_icao   = opt.with_icao_spelling;
1699
1700   if (mode == 10)
1701     {
1702       mode = 0;
1703       with_colons = 0;
1704       with_icao = 0;
1705     }
1706
1707   if (pk->main_keyid[0] == pk->keyid[0]
1708       && pk->main_keyid[1] == pk->keyid[1])
1709     primary = 1;
1710
1711   /* Just to be safe */
1712   if ((mode & 0x80) && !primary)
1713     {
1714       log_error ("primary key is not really primary!\n");
1715       return;
1716     }
1717
1718   mode &= ~0x80;
1719
1720   if (!primary && (mode == 1 || mode == 2))
1721     {
1722       PKT_public_key *primary_pk = xmalloc_clear (sizeof (*primary_pk));
1723       get_pubkey (primary_pk, pk->main_keyid);
1724       print_fingerprint (override_fp, primary_pk, (mode | 0x80));
1725       free_public_key (primary_pk);
1726     }
1727
1728   if (mode == 1)
1729     {
1730       fp = log_get_stream ();
1731       if (primary)
1732         text = _("Primary key fingerprint:");
1733       else
1734         text = _("     Subkey fingerprint:");
1735     }
1736   else if (mode == 2)
1737     {
1738       fp = override_fp; /* Use tty or given stream.  */
1739       if (primary)
1740         /* TRANSLATORS: this should fit into 24 bytes to that the
1741          * fingerprint data is properly aligned with the user ID */
1742         text = _(" Primary key fingerprint:");
1743       else
1744         text = _("      Subkey fingerprint:");
1745     }
1746   else if (mode == 3)
1747     {
1748       fp = override_fp; /* Use tty or given stream.  */
1749       text = _("      Key fingerprint =");
1750     }
1751   else
1752     {
1753       fp = override_fp? override_fp : es_stdout;
1754       text = _("      Key fingerprint =");
1755     }
1756
1757   fingerprint_from_pk (pk, array, &n);
1758   p = array;
1759   if (with_colons && !mode)
1760     {
1761       es_fprintf (fp, "fpr:::::::::");
1762       for (i = 0; i < n; i++, p++)
1763         es_fprintf (fp, "%02X", *p);
1764       es_putc (':', fp);
1765     }
1766   else
1767     {
1768       tty_fprintf (fp, "%s", text);
1769       if (n == 20)
1770         {
1771           for (i = 0; i < n; i++, i++, p += 2)
1772             tty_fprintf (fp, "%s %02X%02X", i==10? " ":"", *p, p[1]);
1773         }
1774       else
1775         {
1776           for (i = 0; i < n; i++, p++)
1777             tty_fprintf (fp, "%s %02X", (i && !(i % 8))? " ":"", *p);
1778         }
1779     }
1780   tty_fprintf (fp, "\n");
1781   if (!with_colons && with_icao)
1782     {
1783       p = array;
1784       tty_fprintf (fp, "%*s\"", (int)strlen(text)+1, "");
1785       for (i = 0; i < n; i++, p++)
1786         {
1787           if (!i)
1788             ;
1789           else if (!(i%4))
1790             tty_fprintf (fp, "\n%*s ", (int)strlen(text)+1, "");
1791           else if (!(i%2))
1792             tty_fprintf (fp, "  ");
1793           else
1794             tty_fprintf (fp, " ");
1795           print_icao_hexdigit (fp, *p >> 4);
1796           tty_fprintf (fp, " ");
1797           print_icao_hexdigit (fp, *p & 15);
1798         }
1799       tty_fprintf (fp, "\"\n");
1800     }
1801 }
1802
1803 /* Print the serial number of an OpenPGP card if available.  */
1804 static void
1805 print_card_serialno (const char *serialno)
1806 {
1807   if (!serialno)
1808     return;
1809   if (opt.with_colons)
1810     return; /* Handled elsewhere. */
1811
1812   es_fputs (_("      Card serial no. ="), es_stdout);
1813   es_putc (' ', es_stdout);
1814   if (strlen (serialno) == 32 && !strncmp (serialno, "D27600012401", 12))
1815     {
1816       /* This is an OpenPGP card.  Print the relevant part.  */
1817       /* Example: D2760001240101010001000003470000 */
1818       /*                          xxxxyyyyyyyy     */
1819       es_fprintf (es_stdout, "%.*s %.*s", 4, serialno+16, 8, serialno+20);
1820     }
1821  else
1822    es_fputs (serialno, es_stdout);
1823   es_putc ('\n', es_stdout);
1824 }
1825
1826
1827
1828 void
1829 set_attrib_fd (int fd)
1830 {
1831   static int last_fd = -1;
1832
1833   if (fd != -1 && last_fd == fd)
1834     return;
1835
1836   /* Fixme: Do we need to check for the log stream here?  */
1837   if (attrib_fp && attrib_fp != log_get_stream ())
1838     es_fclose (attrib_fp);
1839   attrib_fp = NULL;
1840   if (fd == -1)
1841     return;
1842
1843 #ifdef HAVE_DOSISH_SYSTEM
1844   setmode (fd, O_BINARY);
1845 #endif
1846   if (fd == 1)
1847     attrib_fp = es_stdout;
1848   else if (fd == 2)
1849     attrib_fp = es_stderr;
1850   else
1851     attrib_fp = es_fdopen (fd, "wb");
1852   if (!attrib_fp)
1853     {
1854       log_fatal ("can't open fd %d for attribute output: %s\n",
1855                  fd, strerror (errno));
1856     }
1857
1858   last_fd = fd;
1859 }