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