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