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