gpg: Use only OpenPGP public key algo ids and add the EdDSA algo id.
[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_EDDSA
822       || pk->pubkey_algo == PUBKEY_ALGO_ECDH)
823     {
824       char *curve = openpgp_oid_to_str (pk->pkey[0]);
825       const char *name = openpgp_oid_to_curve (curve);
826       if (!*name || *name == '?')
827         name = curve;
828       es_fprintf (es_stdout, " %s", name);
829       xfree (curve);
830     }
831
832   if (pk->flags.revoked)
833     {
834       es_fprintf (es_stdout, " [");
835       es_fprintf (es_stdout, _("revoked: %s"), revokestr_from_pk (pk));
836       es_fprintf (es_stdout, "]");
837     }
838   else if (pk->has_expired)
839     {
840       es_fprintf (es_stdout, " [");
841       es_fprintf (es_stdout, _("expired: %s"), expirestr_from_pk (pk));
842       es_fprintf (es_stdout, "]");
843     }
844   else if (pk->expiredate)
845     {
846       es_fprintf (es_stdout, " [");
847       es_fprintf (es_stdout, _("expires: %s"), expirestr_from_pk (pk));
848       es_fprintf (es_stdout, "]");
849     }
850
851 #if 0
852   /* I need to think about this some more.  It's easy enough to
853      include, but it looks sort of confusing in the listing... */
854   if (opt.list_options & LIST_SHOW_VALIDITY)
855     {
856       int validity = get_validity (pk, NULL);
857       es_fprintf (es_stdout, " [%s]", trust_value_to_string (validity));
858     }
859 #endif
860
861   es_fprintf (es_stdout, "\n");
862
863   if (fpr)
864     print_fingerprint (pk, 0);
865
866   if (opt.with_keygrip && hexgrip)
867     es_fprintf (es_stdout, "      Keygrip = %s\n", hexgrip);
868
869   if (serialno)
870     print_card_serialno (serialno);
871
872   if (opt.with_key_data)
873     print_key_data (pk);
874
875   for (kbctx = NULL; (node = walk_kbnode (keyblock, &kbctx, 0));)
876     {
877       if (node->pkt->pkttype == PKT_USER_ID && !opt.fast_list_mode)
878         {
879           PKT_user_id *uid = node->pkt->pkt.user_id;
880
881           if (pk && (uid->is_expired || uid->is_revoked)
882               && !(opt.list_options & LIST_SHOW_UNUSABLE_UIDS))
883             {
884               skip_sigs = 1;
885               continue;
886             }
887           else
888             skip_sigs = 0;
889
890           if (attrib_fp && uid->attrib_data != NULL)
891             dump_attribs (uid, pk);
892
893           if ((uid->is_revoked || uid->is_expired)
894               || ((opt.list_options & LIST_SHOW_UID_VALIDITY) && pk))
895             {
896               const char *validity;
897               int indent;
898
899               validity = uid_trust_string_fixed (pk, uid);
900               indent =
901                 (keystrlen () + 9) -
902                 atoi (uid_trust_string_fixed (NULL, NULL));
903
904               if (indent < 0 || indent > 40)
905                 indent = 0;
906
907               es_fprintf (es_stdout, "uid%*s%s ", indent, "", validity);
908             }
909           else
910             es_fprintf (es_stdout, "uid%*s", (int) keystrlen () + 10, "");
911
912           print_utf8_buffer (es_stdout, uid->name, uid->len);
913           es_putc ('\n', es_stdout);
914
915           if ((opt.list_options & LIST_SHOW_PHOTOS) && uid->attribs != NULL)
916             show_photos (uid->attribs, uid->numattribs, pk, uid);
917         }
918       else if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
919         {
920           PKT_public_key *pk2 = node->pkt->pkt.public_key;
921
922           if ((pk2->flags.revoked || pk2->has_expired)
923               && !(opt.list_options & LIST_SHOW_UNUSABLE_SUBKEYS))
924             {
925               skip_sigs = 1;
926               continue;
927             }
928           else
929             skip_sigs = 0;
930
931           xfree (serialno); serialno = NULL;
932           xfree (hexgrip); hexgrip = NULL;
933           if (secret || opt.with_keygrip)
934             {
935               rc = hexkeygrip_from_pk (pk2, &hexgrip);
936               if (rc)
937                 log_error ("error computing a keygrip: %s\n",
938                            gpg_strerror (rc));
939             }
940           if (secret)
941             {
942               if (!agent_get_keyinfo (NULL, hexgrip, &serialno))
943                 s2k_char = serialno? '>':' ';
944               else
945                 s2k_char = '#';  /* Key not found.  */
946             }
947           else
948             s2k_char = ' ';
949
950           es_fprintf (es_stdout, "%s%c  %4u%c/%s %s",
951                   secret? "ssb":"sub",
952                   s2k_char,
953                   nbits_from_pk (pk2), pubkey_letter (pk2->pubkey_algo),
954                   keystr_from_pk (pk2), datestr_from_pk (pk2));
955
956           if (pk2->pubkey_algo == PUBKEY_ALGO_ECDSA
957               || pk2->pubkey_algo == PUBKEY_ALGO_EDDSA
958               || pk2->pubkey_algo == PUBKEY_ALGO_ECDH)
959             {
960               char *curve = openpgp_oid_to_str (pk2->pkey[0]);
961               const char *name = openpgp_oid_to_curve (curve);
962               if (!*name || *name == '?')
963                 name = curve;
964               es_fprintf (es_stdout, " %s", name);
965               xfree (curve);
966             }
967
968           if (pk2->flags.revoked)
969             {
970               es_fprintf (es_stdout, " [");
971               es_fprintf (es_stdout, _("revoked: %s"), revokestr_from_pk (pk2));
972               es_fprintf (es_stdout, "]");
973             }
974           else if (pk2->has_expired)
975             {
976               es_fprintf (es_stdout, " [");
977               es_fprintf (es_stdout, _("expired: %s"), expirestr_from_pk (pk2));
978               es_fprintf (es_stdout, "]");
979             }
980           else if (pk2->expiredate)
981             {
982               es_fprintf (es_stdout, " [");
983               es_fprintf (es_stdout, _("expires: %s"), expirestr_from_pk (pk2));
984               es_fprintf (es_stdout, "]");
985             }
986           es_putc ('\n', es_stdout);
987           if (fpr > 1)
988             {
989               print_fingerprint (pk2, 0);
990               if (serialno)
991                 print_card_serialno (serialno);
992             }
993           if (opt.with_keygrip && hexgrip)
994             es_fprintf (es_stdout, "      Keygrip = %s\n", hexgrip);
995           if (opt.with_key_data)
996             print_key_data (pk2);
997         }
998       else if (opt.list_sigs
999                && node->pkt->pkttype == PKT_SIGNATURE && !skip_sigs)
1000         {
1001           PKT_signature *sig = node->pkt->pkt.signature;
1002           int sigrc;
1003           char *sigstr;
1004
1005           if (stats)
1006             {
1007               rc = check_key_signature (keyblock, node, NULL);
1008               switch (gpg_err_code (rc))
1009                 {
1010                 case 0:
1011                   sigrc = '!';
1012                   break;
1013                 case GPG_ERR_BAD_SIGNATURE:
1014                   stats->inv_sigs++;
1015                   sigrc = '-';
1016                   break;
1017                 case GPG_ERR_NO_PUBKEY:
1018                 case GPG_ERR_UNUSABLE_PUBKEY:
1019                   stats->no_key++;
1020                   continue;
1021                 default:
1022                   stats->oth_err++;
1023                   sigrc = '%';
1024                   break;
1025                 }
1026
1027               /* TODO: Make sure a cached sig record here still has
1028                  the pk that issued it.  See also
1029                  keyedit.c:print_and_check_one_sig */
1030             }
1031           else
1032             {
1033               rc = 0;
1034               sigrc = ' ';
1035             }
1036
1037           if (sig->sig_class == 0x20 || sig->sig_class == 0x28
1038               || sig->sig_class == 0x30)
1039             sigstr = "rev";
1040           else if ((sig->sig_class & ~3) == 0x10)
1041             sigstr = "sig";
1042           else if (sig->sig_class == 0x18)
1043             sigstr = "sig";
1044           else if (sig->sig_class == 0x1F)
1045             sigstr = "sig";
1046           else
1047             {
1048               es_fprintf (es_stdout, "sig                             "
1049                       "[unexpected signature class 0x%02x]\n",
1050                       sig->sig_class);
1051               continue;
1052             }
1053
1054           es_fputs (sigstr, es_stdout);
1055           es_fprintf (es_stdout, "%c%c %c%c%c%c%c%c %s %s",
1056                   sigrc, (sig->sig_class - 0x10 > 0 &&
1057                           sig->sig_class - 0x10 <
1058                           4) ? '0' + sig->sig_class - 0x10 : ' ',
1059                   sig->flags.exportable ? ' ' : 'L',
1060                   sig->flags.revocable ? ' ' : 'R',
1061                   sig->flags.policy_url ? 'P' : ' ',
1062                   sig->flags.notation ? 'N' : ' ',
1063                   sig->flags.expired ? 'X' : ' ',
1064                   (sig->trust_depth > 9) ? 'T' : (sig->trust_depth >
1065                                                   0) ? '0' +
1066                   sig->trust_depth : ' ', keystr (sig->keyid),
1067                   datestr_from_sig (sig));
1068           if (opt.list_options & LIST_SHOW_SIG_EXPIRE)
1069             es_fprintf (es_stdout, " %s", expirestr_from_sig (sig));
1070           es_fprintf (es_stdout, "  ");
1071           if (sigrc == '%')
1072             es_fprintf (es_stdout, "[%s] ", g10_errstr (rc));
1073           else if (sigrc == '?')
1074             ;
1075           else if (!opt.fast_list_mode)
1076             {
1077               size_t n;
1078               char *p = get_user_id (sig->keyid, &n);
1079               print_utf8_buffer (es_stdout, p, n);
1080               xfree (p);
1081             }
1082           es_putc ('\n', es_stdout);
1083
1084           if (sig->flags.policy_url
1085               && (opt.list_options & LIST_SHOW_POLICY_URLS))
1086             show_policy_url (sig, 3, 0);
1087
1088           if (sig->flags.notation && (opt.list_options & LIST_SHOW_NOTATIONS))
1089             show_notation (sig, 3, 0,
1090                            ((opt.
1091                              list_options & LIST_SHOW_STD_NOTATIONS) ? 1 : 0)
1092                            +
1093                            ((opt.
1094                              list_options & LIST_SHOW_USER_NOTATIONS) ? 2 :
1095                             0));
1096
1097           if (sig->flags.pref_ks
1098               && (opt.list_options & LIST_SHOW_KEYSERVER_URLS))
1099             show_keyserver_url (sig, 3, 0);
1100
1101           /* fixme: check or list other sigs here */
1102         }
1103     }
1104   es_putc ('\n', es_stdout);
1105   xfree (serialno);
1106   xfree (hexgrip);
1107 }
1108
1109 void
1110 print_revokers (PKT_public_key * pk)
1111 {
1112   /* print the revoker record */
1113   if (!pk->revkey && pk->numrevkeys)
1114     BUG ();
1115   else
1116     {
1117       int i, j;
1118
1119       for (i = 0; i < pk->numrevkeys; i++)
1120         {
1121           byte *p;
1122
1123           es_fprintf (es_stdout, "rvk:::%d::::::", pk->revkey[i].algid);
1124           p = pk->revkey[i].fpr;
1125           for (j = 0; j < 20; j++, p++)
1126             es_fprintf (es_stdout, "%02X", *p);
1127           es_fprintf (es_stdout, ":%02x%s:\n", pk->revkey[i].class,
1128                   (pk->revkey[i].class & 0x40) ? "s" : "");
1129         }
1130     }
1131 }
1132
1133 static void
1134 list_keyblock_colon (KBNODE keyblock, int secret, int fpr)
1135 {
1136   int rc;
1137   KBNODE kbctx;
1138   KBNODE node;
1139   PKT_public_key *pk;
1140   u32 keyid[2];
1141   int trustletter = 0;
1142   int ulti_hack = 0;
1143   int i;
1144   char *p;
1145   char *hexgrip = NULL;
1146   char *serialno = NULL;
1147   int stubkey;
1148
1149   /* Get the keyid from the keyblock.  */
1150   node = find_kbnode (keyblock, PKT_PUBLIC_KEY);
1151   if (!node)
1152     {
1153       log_error ("Oops; key lost!\n");
1154       dump_kbnode (keyblock);
1155       return;
1156     }
1157
1158   pk = node->pkt->pkt.public_key;
1159   if (secret || opt.with_keygrip || opt.with_key_data)
1160     {
1161       rc = hexkeygrip_from_pk (pk, &hexgrip);
1162       if (rc)
1163         log_error ("error computing a keygrip: %s\n", gpg_strerror (rc));
1164     }
1165   stubkey = 0;
1166   if (secret && agent_get_keyinfo (NULL, hexgrip, &serialno))
1167     stubkey = 1;  /* Key not found.  */
1168
1169   keyid_from_pk (pk, keyid);
1170   es_fputs (secret? "sec:":"pub:", es_stdout);
1171   if (!pk->flags.valid)
1172     es_putc ('i', es_stdout);
1173   else if (pk->flags.revoked)
1174     es_putc ('r', es_stdout);
1175   else if (pk->has_expired)
1176     es_putc ('e', es_stdout);
1177   else if (opt.fast_list_mode || opt.no_expensive_trust_checks)
1178     ;
1179   else
1180     {
1181       trustletter = get_validity_info (pk, NULL);
1182       if (trustletter == 'u')
1183         ulti_hack = 1;
1184       es_putc (trustletter, es_stdout);
1185     }
1186
1187   es_fprintf (es_stdout, ":%u:%d:%08lX%08lX:%s:%s::",
1188           nbits_from_pk (pk),
1189           pk->pubkey_algo,
1190           (ulong) keyid[0], (ulong) keyid[1],
1191           colon_datestr_from_pk (pk), colon_strtime (pk->expiredate));
1192
1193   if (!opt.fast_list_mode && !opt.no_expensive_trust_checks)
1194     es_putc (get_ownertrust_info (pk), es_stdout);
1195   es_putc (':', es_stdout);
1196
1197   es_putc (':', es_stdout);
1198   es_putc (':', es_stdout);
1199   print_capabilities (pk, keyblock);
1200   es_putc (':', es_stdout);             /* End of field 13. */
1201   es_putc (':', es_stdout);             /* End of field 14. */
1202   if (secret)
1203     {
1204       if (stubkey)
1205         es_putc ('#', es_stdout);
1206       else if (serialno)
1207         es_fputs (serialno, es_stdout);
1208     }
1209   es_putc (':', es_stdout);             /* End of field 15. */
1210   es_putc (':', es_stdout);             /* End of field 16. */
1211   if (pk->pubkey_algo == PUBKEY_ALGO_ECDSA
1212       || pk->pubkey_algo == PUBKEY_ALGO_EDDSA
1213       || pk->pubkey_algo == PUBKEY_ALGO_ECDH)
1214     {
1215       char *curve = openpgp_oid_to_str (pk->pkey[0]);
1216       const char *name = openpgp_oid_to_curve (curve);
1217       if (!*name || *name == '?')
1218         name = curve;
1219       es_fputs (name, es_stdout);
1220       xfree (curve);
1221     }
1222   es_putc (':', es_stdout);             /* End of field 17. */
1223   es_putc ('\n', es_stdout);
1224
1225   print_revokers (pk);
1226   if (fpr)
1227     print_fingerprint (pk, 0);
1228   if (opt.with_key_data || opt.with_keygrip)
1229     {
1230       if (hexgrip)
1231         es_fprintf (es_stdout, "grp:::::::::%s:\n", hexgrip);
1232       if (opt.with_key_data)
1233         print_key_data (pk);
1234     }
1235
1236   for (kbctx = NULL; (node = walk_kbnode (keyblock, &kbctx, 0));)
1237     {
1238       if (node->pkt->pkttype == PKT_USER_ID && !opt.fast_list_mode)
1239         {
1240           char *str;
1241           PKT_user_id *uid = node->pkt->pkt.user_id;
1242
1243           if (attrib_fp && node->pkt->pkt.user_id->attrib_data != NULL)
1244             dump_attribs (node->pkt->pkt.user_id, pk);
1245           /*
1246            * Fixme: We need a valid flag here too
1247            */
1248           str = uid->attrib_data ? "uat" : "uid";
1249           if (uid->is_revoked)
1250             es_fprintf (es_stdout, "%s:r::::", str);
1251           else if (uid->is_expired)
1252             es_fprintf (es_stdout, "%s:e::::", str);
1253           else if (opt.no_expensive_trust_checks)
1254             es_fprintf (es_stdout, "%s:::::", str);
1255           else
1256             {
1257               int uid_validity;
1258
1259               if (pk && !ulti_hack)
1260                 uid_validity = get_validity_info (pk, uid);
1261               else
1262                 uid_validity = 'u';
1263               es_fprintf (es_stdout, "%s:%c::::", str, uid_validity);
1264             }
1265
1266           es_fprintf (es_stdout, "%s:", colon_strtime (uid->created));
1267           es_fprintf (es_stdout, "%s:", colon_strtime (uid->expiredate));
1268
1269           namehash_from_uid (uid);
1270
1271           for (i = 0; i < 20; i++)
1272             es_fprintf (es_stdout, "%02X", uid->namehash[i]);
1273
1274           es_fprintf (es_stdout, "::");
1275
1276           if (uid->attrib_data)
1277             es_fprintf (es_stdout, "%u %lu", uid->numattribs, uid->attrib_len);
1278           else
1279             es_write_sanitized (es_stdout, uid->name, uid->len, ":", NULL);
1280           es_putc (':', es_stdout);
1281           es_putc ('\n', es_stdout);
1282         }
1283       else if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1284         {
1285           u32 keyid2[2];
1286           PKT_public_key *pk2;
1287
1288           pk2 = node->pkt->pkt.public_key;
1289           xfree (hexgrip); hexgrip = NULL;
1290           xfree (serialno); serialno = NULL;
1291           if (secret || opt.with_keygrip || opt.with_key_data)
1292             {
1293               rc = hexkeygrip_from_pk (pk2, &hexgrip);
1294               if (rc)
1295                 log_error ("error computing a keygrip: %s\n",
1296                            gpg_strerror (rc));
1297             }
1298           stubkey = 0;
1299           if (secret && agent_get_keyinfo (NULL, hexgrip, &serialno))
1300             stubkey = 1;  /* Key not found.  */
1301
1302           keyid_from_pk (pk2, keyid2);
1303           es_fputs (secret? "ssb:":"sub:", es_stdout);
1304           if (!pk2->flags.valid)
1305             es_putc ('i', es_stdout);
1306           else if (pk2->flags.revoked)
1307             es_putc ('r', es_stdout);
1308           else if (pk2->has_expired)
1309             es_putc ('e', es_stdout);
1310           else if (opt.fast_list_mode || opt.no_expensive_trust_checks)
1311             ;
1312           else
1313             {
1314               /* TRUSTLETTER should always be defined here. */
1315               if (trustletter)
1316                 es_fprintf (es_stdout, "%c", trustletter);
1317             }
1318           es_fprintf (es_stdout, ":%u:%d:%08lX%08lX:%s:%s:::::",
1319                   nbits_from_pk (pk2),
1320                   pk2->pubkey_algo,
1321                   (ulong) keyid2[0], (ulong) keyid2[1],
1322                   colon_datestr_from_pk (pk2), colon_strtime (pk2->expiredate)
1323                   /* fixme: add LID and ownertrust here */
1324             );
1325           print_capabilities (pk2, NULL);
1326           es_putc (':', es_stdout);     /* End of field 13. */
1327           es_putc (':', es_stdout);     /* End of field 14. */
1328           if (secret)
1329             {
1330               if (stubkey)
1331                 es_putc ('#', es_stdout);
1332               else if (serialno)
1333                 es_fputs (serialno, es_stdout);
1334             }
1335           es_putc (':', es_stdout);     /* End of field 15. */
1336           es_putc (':', es_stdout);     /* End of field 16. */
1337           if (pk->pubkey_algo == PUBKEY_ALGO_ECDSA
1338               || pk->pubkey_algo == PUBKEY_ALGO_EDDSA
1339               || pk->pubkey_algo == PUBKEY_ALGO_ECDH)
1340             {
1341               char *curve = openpgp_oid_to_str (pk->pkey[0]);
1342               const char *name = openpgp_oid_to_curve (curve);
1343               if (!*name || *name == '?')
1344                 name = curve;
1345               es_fputs (name, es_stdout);
1346               xfree (curve);
1347             }
1348           es_putc (':', es_stdout);     /* End of field 17. */
1349           es_putc ('\n', es_stdout);
1350           if (fpr > 1)
1351             print_fingerprint (pk2, 0);
1352           if (opt.with_key_data || opt.with_keygrip)
1353             {
1354               if (hexgrip)
1355                 es_fprintf (es_stdout, "grp:::::::::%s:\n", hexgrip);
1356               if (opt.with_key_data)
1357                 print_key_data (pk2);
1358             }
1359         }
1360       else if (opt.list_sigs && node->pkt->pkttype == PKT_SIGNATURE)
1361         {
1362           PKT_signature *sig = node->pkt->pkt.signature;
1363           int sigrc, fprokay = 0;
1364           char *sigstr;
1365           size_t fplen;
1366           byte fparray[MAX_FINGERPRINT_LEN];
1367
1368           if (sig->sig_class == 0x20 || sig->sig_class == 0x28
1369               || sig->sig_class == 0x30)
1370             sigstr = "rev";
1371           else if ((sig->sig_class & ~3) == 0x10)
1372             sigstr = "sig";
1373           else if (sig->sig_class == 0x18)
1374             sigstr = "sig";
1375           else if (sig->sig_class == 0x1F)
1376             sigstr = "sig";
1377           else
1378             {
1379               es_fprintf (es_stdout, "sig::::::::::%02x%c:\n",
1380                       sig->sig_class, sig->flags.exportable ? 'x' : 'l');
1381               continue;
1382             }
1383
1384           if (opt.check_sigs)
1385             {
1386               PKT_public_key *signer_pk = NULL;
1387
1388               fflush (stdout);
1389               if (opt.no_sig_cache)
1390                 signer_pk = xmalloc_clear (sizeof (PKT_public_key));
1391
1392               rc = check_key_signature2 (keyblock, node, NULL, signer_pk,
1393                                          NULL, NULL, NULL);
1394               switch (gpg_err_code (rc))
1395                 {
1396                 case 0:
1397                   sigrc = '!';
1398                   break;
1399                 case GPG_ERR_BAD_SIGNATURE:
1400                   sigrc = '-';
1401                   break;
1402                 case GPG_ERR_NO_PUBKEY:
1403                 case GPG_ERR_UNUSABLE_PUBKEY:
1404                   sigrc = '?';
1405                   break;
1406                 default:
1407                   sigrc = '%';
1408                   break;
1409                 }
1410
1411               if (opt.no_sig_cache)
1412                 {
1413                   if (!rc)
1414                     {
1415                       fingerprint_from_pk (signer_pk, fparray, &fplen);
1416                       fprokay = 1;
1417                     }
1418                   free_public_key (signer_pk);
1419                 }
1420             }
1421           else
1422             {
1423               rc = 0;
1424               sigrc = ' ';
1425             }
1426           es_fputs (sigstr, es_stdout);
1427           es_putc (':', es_stdout);
1428           if (sigrc != ' ')
1429             es_putc (sigrc, es_stdout);
1430           es_fprintf (es_stdout, "::%d:%08lX%08lX:%s:%s:", sig->pubkey_algo,
1431                   (ulong) sig->keyid[0], (ulong) sig->keyid[1],
1432                   colon_datestr_from_sig (sig),
1433                   colon_expirestr_from_sig (sig));
1434
1435           if (sig->trust_depth || sig->trust_value)
1436             es_fprintf (es_stdout, "%d %d", sig->trust_depth, sig->trust_value);
1437           es_fprintf (es_stdout, ":");
1438
1439           if (sig->trust_regexp)
1440             es_write_sanitized (es_stdout, sig->trust_regexp,
1441                                 strlen (sig->trust_regexp), ":", NULL);
1442           es_fprintf (es_stdout, ":");
1443
1444           if (sigrc == '%')
1445             es_fprintf (es_stdout, "[%s] ", g10_errstr (rc));
1446           else if (sigrc == '?')
1447             ;
1448           else if (!opt.fast_list_mode)
1449             {
1450               size_t n;
1451               p = get_user_id (sig->keyid, &n);
1452               es_write_sanitized (es_stdout, p, n, ":", NULL);
1453               xfree (p);
1454             }
1455           es_fprintf (es_stdout, ":%02x%c::", sig->sig_class,
1456                   sig->flags.exportable ? 'x' : 'l');
1457
1458           if (opt.no_sig_cache && opt.check_sigs && fprokay)
1459             {
1460               for (i = 0; i < fplen; i++)
1461                 es_fprintf (es_stdout, "%02X", fparray[i]);
1462             }
1463
1464           es_fprintf (es_stdout, ":::%d:\n", sig->digest_algo);
1465
1466           if (opt.show_subpackets)
1467             print_subpackets_colon (sig);
1468
1469           /* fixme: check or list other sigs here */
1470         }
1471     }
1472
1473   xfree (hexgrip);
1474   xfree (serialno);
1475 }
1476
1477 /*
1478  * Reorder the keyblock so that the primary user ID (and not attribute
1479  * packet) comes first.  Fixme: Replace this by a generic sort
1480  * function.  */
1481 static void
1482 do_reorder_keyblock (KBNODE keyblock, int attr)
1483 {
1484   KBNODE primary = NULL, primary0 = NULL, primary2 = NULL;
1485   KBNODE last, node;
1486
1487   for (node = keyblock; node; primary0 = node, node = node->next)
1488     {
1489       if (node->pkt->pkttype == PKT_USER_ID &&
1490           ((attr && node->pkt->pkt.user_id->attrib_data) ||
1491            (!attr && !node->pkt->pkt.user_id->attrib_data)) &&
1492           node->pkt->pkt.user_id->is_primary)
1493         {
1494           primary = primary2 = node;
1495           for (node = node->next; node; primary2 = node, node = node->next)
1496             {
1497               if (node->pkt->pkttype == PKT_USER_ID
1498                   || node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1499                   || node->pkt->pkttype == PKT_SECRET_SUBKEY)
1500                 {
1501                   break;
1502                 }
1503             }
1504           break;
1505         }
1506     }
1507   if (!primary)
1508     return; /* No primary key flag found (should not happen).  */
1509
1510   for (last = NULL, node = keyblock; node; last = node, node = node->next)
1511     {
1512       if (node->pkt->pkttype == PKT_USER_ID)
1513         break;
1514     }
1515   assert (node);
1516   assert (last);         /* The user ID is never the first packet.  */
1517   assert (primary0);     /* Ditto (this is the node before primary).  */
1518   if (node == primary)
1519     return; /* Already the first one.  */
1520
1521   last->next = primary;
1522   primary0->next = primary2->next;
1523   primary2->next = node;
1524 }
1525
1526 void
1527 reorder_keyblock (KBNODE keyblock)
1528 {
1529   do_reorder_keyblock (keyblock, 1);
1530   do_reorder_keyblock (keyblock, 0);
1531 }
1532
1533 void
1534 list_keyblock (KBNODE keyblock, int secret, int fpr, void *opaque)
1535 {
1536   reorder_keyblock (keyblock);
1537   if (opt.with_colons)
1538     list_keyblock_colon (keyblock, secret, fpr);
1539   else
1540     list_keyblock_print (keyblock, secret, fpr, opaque);
1541 }
1542
1543 /*
1544  * Function to print the finperprint.
1545  * mode 0: as used in key listings, opt.with_colons is honored
1546  *      1: print using log_info ()
1547  *      2: direct use of tty
1548  *      3: direct use of tty but only primary key.
1549  *
1550  * Modes 1 and 2 will try and print both subkey and primary key
1551  * fingerprints.  A MODE with bit 7 set is used internally.
1552  */
1553 void
1554 print_fingerprint (PKT_public_key *pk, int mode)
1555 {
1556   byte array[MAX_FINGERPRINT_LEN], *p;
1557   size_t i, n;
1558   estream_t fp;
1559   const char *text;
1560   int primary = 0;
1561
1562   if (pk->main_keyid[0] == pk->keyid[0]
1563       && pk->main_keyid[1] == pk->keyid[1])
1564     primary = 1;
1565
1566   /* Just to be safe */
1567   if ((mode & 0x80) && !primary)
1568     {
1569       log_error ("primary key is not really primary!\n");
1570       return;
1571     }
1572
1573   mode &= ~0x80;
1574
1575   if (!primary && (mode == 1 || mode == 2))
1576     {
1577       PKT_public_key *primary_pk = xmalloc_clear (sizeof (*primary_pk));
1578       get_pubkey (primary_pk, pk->main_keyid);
1579       print_fingerprint (primary_pk, mode | 0x80);
1580       free_public_key (primary_pk);
1581     }
1582
1583   if (mode == 1)
1584     {
1585       fp = log_get_stream ();
1586       if (primary)
1587         text = _("Primary key fingerprint:");
1588       else
1589         text = _("     Subkey fingerprint:");
1590     }
1591   else if (mode == 2)
1592     {
1593       fp = NULL; /* Use tty.  */
1594       if (primary)
1595         /* TRANSLATORS: this should fit into 24 bytes to that the
1596          * fingerprint data is properly aligned with the user ID */
1597         text = _(" Primary key fingerprint:");
1598       else
1599         text = _("      Subkey fingerprint:");
1600     }
1601   else if (mode == 3)
1602     {
1603       fp = NULL; /* Use tty.  */
1604       text = _("      Key fingerprint =");
1605     }
1606   else
1607     {
1608       fp = es_stdout;
1609       text = _("      Key fingerprint =");
1610     }
1611
1612   fingerprint_from_pk (pk, array, &n);
1613   p = array;
1614   if (opt.with_colons && !mode)
1615     {
1616       es_fprintf (fp, "fpr:::::::::");
1617       for (i = 0; i < n; i++, p++)
1618         es_fprintf (fp, "%02X", *p);
1619       es_putc (':', fp);
1620     }
1621   else
1622     {
1623       tty_fprintf (fp, "%s", text);
1624       if (n == 20)
1625         {
1626           for (i = 0; i < n; i++, i++, p += 2)
1627             tty_fprintf (fp, "%s %02X%02X", i==10? " ":"", *p, p[1]);
1628         }
1629       else
1630         {
1631           for (i = 0; i < n; i++, p++)
1632             tty_fprintf (fp, "%s %02X", (i && !(i % 8))? " ":"", *p);
1633         }
1634     }
1635   tty_fprintf (fp, "\n");
1636 }
1637
1638 /* Print the serial number of an OpenPGP card if available.  */
1639 static void
1640 print_card_serialno (const char *serialno)
1641 {
1642   if (!serialno)
1643     return;
1644   if (opt.with_colons)
1645     return; /* Handled elsewhere. */
1646
1647   es_fputs (_("      Card serial no. ="), es_stdout);
1648   es_putc (' ', es_stdout);
1649   if (strlen (serialno) == 32 && !strncmp (serialno, "D27600012401", 12))
1650     {
1651       /* This is an OpenPGP card.  Print the relevant part.  */
1652       /* Example: D2760001240101010001000003470000 */
1653       /*                          xxxxyyyyyyyy     */
1654       es_fprintf (es_stdout, "%.*s %.*s", 4, serialno+16, 8, serialno+20);
1655     }
1656  else
1657    es_fputs (serialno, es_stdout);
1658   es_putc ('\n', es_stdout);
1659 }
1660
1661
1662
1663 void
1664 set_attrib_fd (int fd)
1665 {
1666   static int last_fd = -1;
1667
1668   if (fd != -1 && last_fd == fd)
1669     return;
1670
1671   /* Fixme: Do we need to check for the log stream here?  */
1672   if (attrib_fp && attrib_fp != log_get_stream ())
1673     es_fclose (attrib_fp);
1674   attrib_fp = NULL;
1675   if (fd == -1)
1676     return;
1677
1678 #ifdef HAVE_DOSISH_SYSTEM
1679   setmode (fd, O_BINARY);
1680 #endif
1681   if (fd == 1)
1682     attrib_fp = es_stdout;
1683   else if (fd == 2)
1684     attrib_fp = es_stderr;
1685   else
1686     attrib_fp = es_fdopen (fd, "wb");
1687   if (!attrib_fp)
1688     {
1689       log_fatal ("can't open fd %d for attribute output: %s\n",
1690                  fd, strerror (errno));
1691     }
1692
1693   last_fd = fd;
1694 }