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