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