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