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