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