card: Support factory reset for Yubikey PIV application.
[gnupg.git] / tools / gpg-card-tool.c
1 /* gpg-card-tool.c - An interactive tool to work with cards.
2  * Copyright (C) 2019 g10 Code GmbH
3  *
4  * This file is part of GnuPG.
5  *
6  * This file is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 3 of the License, or
9  * (at your option) any later version.
10  *
11  * This file is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, see <https://gnu.org/licenses/>.
18  * SPDX-License-Identifier: GPL-3.0-or-later
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #ifdef HAVE_LIBREADLINE
26 # define GNUPG_LIBREADLINE_H_INCLUDED
27 # include <readline/readline.h>
28 #endif /*HAVE_LIBREADLINE*/
29
30 #include "../common/util.h"
31 #include "../common/status.h"
32 #include "../common/i18n.h"
33 #include "../common/init.h"
34 #include "../common/sysutils.h"
35 #include "../common/asshelp.h"
36 #include "../common/userids.h"
37 #include "../common/ccparray.h"
38 #include "../common/exectool.h"
39 #include "../common/ttyio.h"
40 #include "../common/server-help.h"
41 #include "../common/openpgpdefs.h"
42
43 #include "card-tool.h"
44
45
46 #define CONTROL_D ('D' - 'A' + 1)
47
48 /* Constants to identify the commands and options. */
49 enum cmd_and_opt_values
50   {
51     aNull = 0,
52
53     oQuiet      = 'q',
54     oVerbose    = 'v',
55
56     oDebug      = 500,
57
58     oGpgProgram,
59     oGpgsmProgram,
60     oStatusFD,
61     oWithColons,
62     oNoAutostart,
63     oAgentProgram,
64
65     oDisplay,
66     oTTYname,
67     oTTYtype,
68     oXauthority,
69     oLCctype,
70     oLCmessages,
71
72     oDummy
73   };
74
75
76 /* The list of commands and options. */
77 static ARGPARSE_OPTS opts[] = {
78   ARGPARSE_group (300, ("@Commands:\n ")),
79
80   ARGPARSE_group (301, ("@\nOptions:\n ")),
81
82   ARGPARSE_s_n (oVerbose, "verbose", ("verbose")),
83   ARGPARSE_s_n (oQuiet, "quiet",  ("be somewhat more quiet")),
84   ARGPARSE_s_s (oDebug, "debug", "@"),
85   ARGPARSE_s_s (oGpgProgram, "gpg", "@"),
86   ARGPARSE_s_s (oGpgsmProgram, "gpgsm", "@"),
87   ARGPARSE_s_i (oStatusFD, "status-fd", N_("|FD|write status info to this FD")),
88   ARGPARSE_s_n (oWithColons, "with-colons", "@"),
89   ARGPARSE_s_n (oNoAutostart, "no-autostart", "@"),
90   ARGPARSE_s_s (oAgentProgram, "agent-program", "@"),
91   ARGPARSE_s_s (oDisplay,    "display",    "@"),
92   ARGPARSE_s_s (oTTYname,    "ttyname",    "@"),
93   ARGPARSE_s_s (oTTYtype,    "ttytype",    "@"),
94   ARGPARSE_s_s (oXauthority, "xauthority", "@"),
95   ARGPARSE_s_s (oLCctype,    "lc-ctype",   "@"),
96   ARGPARSE_s_s (oLCmessages, "lc-messages","@"),
97
98   ARGPARSE_end ()
99 };
100
101 /* The list of supported debug flags.  */
102 static struct debug_flags_s debug_flags [] =
103   {
104     { DBG_IPC_VALUE    , "ipc"     },
105     { DBG_EXTPROG_VALUE, "extprog" },
106     { 0, NULL }
107   };
108
109
110 /* An object to create lists of labels and keyrefs.  */
111 struct keyinfolabel_s
112 {
113   const char *label;
114   const char *keyref;
115 };
116 typedef struct keyinfolabel_s *keyinfolabel_t;
117
118
119 /* Limit of size of data we read from a file for certain commands.  */
120 #define MAX_GET_DATA_FROM_FILE 16384
121
122 /* Constants for OpenPGP cards.  */
123 #define OPENPGP_USER_PIN_DEFAULT  "123456"
124 #define OPENPGP_ADMIN_PIN_DEFAULT "12345678"
125 #define OPENPGP_KDF_DATA_LENGTH_MIN  90
126 #define OPENPGP_KDF_DATA_LENGTH_MAX 110
127
128
129
130
131 /* Local prototypes.  */
132 static void wrong_args (const char *text) GPGRT_ATTR_NORETURN;
133 static void interactive_loop (void);
134 #ifdef HAVE_LIBREADLINE
135 static char **command_completion (const char *text, int start, int end);
136 #endif /*HAVE_LIBREADLINE*/
137
138
139 \f
140 /* Print usage information and provide strings for help. */
141 static const char *
142 my_strusage( int level )
143 {
144   const char *p;
145
146   switch (level)
147     {
148     case 11: p = "gpg-card-tool"; break;
149     case 12: p = "@GNUPG@"; break;
150     case 13: p = VERSION; break;
151     case 17: p = PRINTABLE_OS_NAME; break;
152     case 19: p = ("Please report bugs to <@EMAIL@>.\n"); break;
153
154     case 1:
155     case 40:
156       p = ("Usage: gpg-card-tool [command] [options] [args] (-h for help)");
157       break;
158     case 41:
159       p = ("Syntax: gpg-card-tool [command] [options] [args]\n"
160            "Tool to configure cards and tokens\n");
161       break;
162
163     default: p = NULL; break;
164     }
165   return p;
166 }
167
168
169 static void
170 wrong_args (const char *text)
171 {
172   es_fprintf (es_stderr, _("usage: %s [options] %s\n"), strusage (11), text);
173   exit (2);
174 }
175
176
177 static void
178 set_opt_session_env (const char *name, const char *value)
179 {
180   gpg_error_t err;
181
182   err = session_env_setenv (opt.session_env, name, value);
183   if (err)
184     log_fatal ("error setting session environment: %s\n",
185                gpg_strerror (err));
186 }
187
188
189 \f
190 /* Command line parsing.  */
191 static enum cmd_and_opt_values
192 parse_arguments (ARGPARSE_ARGS *pargs, ARGPARSE_OPTS *popts)
193 {
194   enum cmd_and_opt_values cmd = 0;
195   int no_more_options = 0;
196
197   while (!no_more_options && optfile_parse (NULL, NULL, NULL, pargs, popts))
198     {
199       switch (pargs->r_opt)
200         {
201         case oQuiet:     opt.quiet = 1; break;
202         case oVerbose:   opt.verbose++; break;
203         case oDebug:
204           if (parse_debug_flag (pargs->r.ret_str, &opt.debug, debug_flags))
205             {
206               pargs->r_opt = ARGPARSE_INVALID_ARG;
207               pargs->err = ARGPARSE_PRINT_ERROR;
208             }
209           break;
210
211         case oGpgProgram:   opt.gpg_program = pargs->r.ret_str; break;
212         case oGpgsmProgram: opt.gpgsm_program = pargs->r.ret_str; break;
213         case oAgentProgram: opt.agent_program = pargs->r.ret_str; break;
214
215         case oStatusFD:
216           gnupg_set_status_fd (translate_sys2libc_fd_int (pargs->r.ret_int, 1));
217           break;
218
219         case oWithColons:  opt.with_colons = 1; break;
220         case oNoAutostart: opt.autostart = 0; break;
221
222         case oDisplay: set_opt_session_env ("DISPLAY", pargs->r.ret_str); break;
223         case oTTYname: set_opt_session_env ("GPG_TTY", pargs->r.ret_str); break;
224         case oTTYtype: set_opt_session_env ("TERM", pargs->r.ret_str); break;
225         case oXauthority: set_opt_session_env ("XAUTHORITY",
226                                                pargs->r.ret_str); break;
227         case oLCctype:     opt.lc_ctype = pargs->r.ret_str; break;
228         case oLCmessages:  opt.lc_messages = pargs->r.ret_str; break;
229
230         default: pargs->err = 2; break;
231         }
232     }
233
234   return cmd;
235 }
236
237
238 \f
239 /* gpg-card-tool main. */
240 int
241 main (int argc, char **argv)
242 {
243   gpg_error_t err;
244   ARGPARSE_ARGS pargs;
245   enum cmd_and_opt_values cmd;
246
247   gnupg_reopen_std ("gpg-card-tool");
248   set_strusage (my_strusage);
249   gnupg_rl_initialize ();
250   log_set_prefix ("gpg-card-tool", GPGRT_LOG_WITH_PREFIX);
251
252   /* Make sure that our subsystems are ready.  */
253   i18n_init();
254   init_common_subsystems (&argc, &argv);
255
256   assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
257   setup_libassuan_logging (&opt.debug, NULL);
258
259   /* Setup default options.  */
260   opt.autostart = 1;
261   opt.session_env = session_env_new ();
262   if (!opt.session_env)
263     log_fatal ("error allocating session environment block: %s\n",
264                gpg_strerror (gpg_error_from_syserror ()));
265
266
267   /* Parse the command line. */
268   pargs.argc  = &argc;
269   pargs.argv  = &argv;
270   pargs.flags = ARGPARSE_FLAG_KEEP;
271   cmd = parse_arguments (&pargs, opts);
272
273   if (log_get_errorcount (0))
274     exit (2);
275
276   /* Print a warning if an argument looks like an option.  */
277   if (!opt.quiet && !(pargs.flags & ARGPARSE_FLAG_STOP_SEEN))
278     {
279       int i;
280
281       for (i=0; i < argc; i++)
282         if (argv[i][0] == '-' && argv[i][1] == '-')
283           log_info (("NOTE: '%s' is not considered an option\n"), argv[i]);
284     }
285
286   /* Set defaults for non given options.  */
287   if (!opt.gpg_program)
288     opt.gpg_program = gnupg_module_name (GNUPG_MODULE_NAME_GPG);
289   if (!opt.gpgsm_program)
290     opt.gpgsm_program = gnupg_module_name (GNUPG_MODULE_NAME_GPGSM);
291
292   /* Run the selected command.  */
293   switch (cmd)
294     {
295     default:
296       interactive_loop ();
297       err = 0;
298       break;
299     }
300
301   if (err)
302     gnupg_status_printf (STATUS_FAILURE, "- %u", err);
303   else if (log_get_errorcount (0))
304     gnupg_status_printf (STATUS_FAILURE, "- %u", GPG_ERR_GENERAL);
305   else
306     gnupg_status_printf (STATUS_SUCCESS, NULL);
307   return log_get_errorcount (0)? 1:0;
308 }
309
310
311 /* Read data from file FNAME up to MAX_GET_DATA_FROM_FILE characters.
312  * On error return an error code and stores NULL at R_BUFFER; on
313  * success returns 0, stpres the number of bytes read at R_BUFLEN and
314  * the address of a newly allocated buffer at R_BUFFER. */
315 static gpg_error_t
316 get_data_from_file (const char *fname, char **r_buffer, size_t *r_buflen)
317 {
318   gpg_error_t err;
319   estream_t fp;
320   char *data;
321   int n;
322
323   *r_buffer = NULL;
324   *r_buflen = 0;
325
326   fp = es_fopen (fname, "rb");
327   if (!fp)
328     {
329       err = gpg_error_from_syserror ();
330       log_error (_("can't open '%s': %s\n"), fname, gpg_strerror (err));
331       return err;
332     }
333
334   data = xtrymalloc (MAX_GET_DATA_FROM_FILE);
335   if (!data)
336     {
337       err = gpg_error_from_syserror ();
338       log_error (_("error allocating enough memory: %s\n"), gpg_strerror (err));
339       es_fclose (fp);
340       return err;
341     }
342
343   n = es_fread (data, 1, MAX_GET_DATA_FROM_FILE, fp);
344   es_fclose (fp);
345   if (n < 0)
346     {
347       err = gpg_error_from_syserror ();
348       tty_printf (_("error reading '%s': %s\n"), fname, gpg_strerror (err));
349       xfree (data);
350       return err;
351     }
352   *r_buffer = data;
353   *r_buflen = n;
354   return 0;
355 }
356
357
358 /* Write LENGTH bytes from BUFFER to file FNAME.  Return 0 on
359  * success.  */
360 static gpg_error_t
361 put_data_to_file (const char *fname, const void *buffer, size_t length)
362 {
363   gpg_error_t err;
364   estream_t fp;
365
366   fp = es_fopen (fname, "wb");
367   if (!fp)
368     {
369       err = gpg_error_from_syserror ();
370       log_error (_("can't create '%s': %s\n"), fname, gpg_strerror (err));
371       return err;
372     }
373
374   if (length && es_fwrite (buffer, length, 1, fp) != 1)
375     {
376       err = gpg_error_from_syserror ();
377       log_error (_("error writing '%s': %s\n"), fname, gpg_strerror (err));
378       es_fclose (fp);
379       return err;
380     }
381   if (es_fclose (fp))
382     {
383       err = gpg_error_from_syserror ();
384       log_error (_("error writing '%s': %s\n"), fname, gpg_strerror (err));
385       return err;
386     }
387   return 0;
388 }
389
390
391 \f
392 /* Simply prints TEXT to the output.  Returns 0 as a convenience.
393  * This is a separate fucntion so that it can be extended to run
394  * less(1) or so.  The extra arguments are int values terminated by a
395  * 0 to indicate card application types supported with this command.
396  * If none are given (just teh final 0), this is a general
397  * command.  */
398 static gpg_error_t
399 print_help (const char *text, ...)
400 {
401   va_list arg_ptr;
402   int value;
403   int any = 0;
404
405   tty_fprintf (NULL, "%s\n", text);
406
407   va_start (arg_ptr, text);
408   while ((value = va_arg (arg_ptr, int)))
409     {
410       if (!any)
411         tty_fprintf (NULL, "[Supported by: ");
412       tty_fprintf (NULL, "%s%s", any?", ":"", app_type_string (value));
413       any = 1;
414     }
415   if (any)
416     tty_fprintf (NULL, "]\n");
417
418   va_end (arg_ptr);
419   return 0;
420 }
421
422
423 /* Return the OpenPGP card manufacturer name.  */
424 static const char *
425 get_manufacturer (unsigned int no)
426 {
427   /* Note:  Make sure that there is no colon or linefeed in the string. */
428   switch (no)
429     {
430     case 0x0001: return "PPC Card Systems";
431     case 0x0002: return "Prism";
432     case 0x0003: return "OpenFortress";
433     case 0x0004: return "Wewid";
434     case 0x0005: return "ZeitControl";
435     case 0x0006: return "Yubico";
436     case 0x0007: return "OpenKMS";
437     case 0x0008: return "LogoEmail";
438     case 0x0009: return "Fidesmo";
439     case 0x000A: return "Dangerous Things";
440
441     case 0x002A: return "Magrathea";
442     case 0x0042: return "GnuPG e.V.";
443
444     case 0x1337: return "Warsaw Hackerspace";
445     case 0x2342: return "warpzone"; /* hackerspace Muenster.  */
446     case 0x4354: return "Confidential Technologies";   /* cotech.de */
447     case 0x63AF: return "Trustica";
448     case 0xBD0E: return "Paranoidlabs";
449     case 0xF517: return "FSIJ";
450
451       /* 0x0000 and 0xFFFF are defined as test cards per spec,
452        * 0xFF00 to 0xFFFE are assigned for use with randomly created
453        * serial numbers.  */
454     case 0x0000:
455     case 0xffff: return "test card";
456     default: return (no & 0xff00) == 0xff00? "unmanaged S/N range":"unknown";
457     }
458 }
459
460 /* Print an (OpenPGP) fingerprint.  */
461 static void
462 print_shax_fpr (estream_t fp, const unsigned char *fpr, unsigned int fprlen)
463 {
464   int i;
465
466   if (fpr)
467     {
468       /* FIXME: Fix formatting for FPRLEN != 20 */
469       for (i=0; i < fprlen ; i+=2, fpr += 2 )
470         {
471           if (i == 10 )
472             tty_fprintf (fp, " ");
473           tty_fprintf (fp, " %02X%02X", *fpr, fpr[1]);
474         }
475     }
476   else
477     tty_fprintf (fp, " [none]");
478   tty_fprintf (fp, "\n");
479 }
480
481 /* Print the keygrip GRP.  */
482 static void
483 print_keygrip (estream_t fp, const unsigned char *grp)
484 {
485   int i;
486
487   for (i=0; i < 20 ; i++, grp++)
488     tty_fprintf (fp, "%02X", *grp);
489   tty_fprintf (fp, "\n");
490 }
491
492
493 /* Print a string but avoid printing control characters.  */
494 static void
495 print_string (estream_t fp, const char *text, const char *name)
496 {
497   tty_fprintf (fp, "%s", text);
498
499   /* FIXME: tty_printf_utf8_string2 eats everything after and
500      including an @ - e.g. when printing an url. */
501   if (name && *name)
502     {
503       if (fp)
504         print_utf8_buffer2 (fp, name, strlen (name), '\n');
505       else
506         tty_print_utf8_string2 (NULL, name, strlen (name), 0);
507     }
508   else
509     tty_fprintf (fp, _("[not set]"));
510   tty_fprintf (fp, "\n");
511 }
512
513
514 /* Print an ISO formatted name or "[not set]".  */
515 static void
516 print_isoname (estream_t fp, const char *name)
517 {
518   if (name && *name)
519     {
520       char *p, *given, *buf;
521
522       buf = xstrdup (name);
523       given = strstr (buf, "<<");
524       for (p=buf; *p; p++)
525         if (*p == '<')
526           *p = ' ';
527       if (given && given[2])
528         {
529           *given = 0;
530           given += 2;
531           if (fp)
532             print_utf8_buffer2 (fp, given, strlen (given), '\n');
533           else
534             tty_print_utf8_string2 (NULL, given, strlen (given), 0);
535
536           if (*buf)
537             tty_fprintf (fp, " ");
538         }
539
540       if (fp)
541         print_utf8_buffer2 (fp, buf, strlen (buf), '\n');
542       else
543         tty_print_utf8_string2 (NULL, buf, strlen (buf), 0);
544
545       xfree (buf);
546     }
547   else
548     {
549       tty_fprintf (fp, _("[not set]"));
550     }
551
552   tty_fprintf (fp, "\n");
553 }
554
555
556 /* Return true if the buffer MEM of length memlen consists only of zeroes. */
557 static int
558 mem_is_zero (const char *mem, unsigned int memlen)
559 {
560   int i;
561
562   for (i=0; i < memlen && !mem[i]; i++)
563     ;
564   return (i == memlen);
565 }
566
567
568 /* Return true if the buffer MEM or length MEMLEN consists only of 0xFF. */
569 static int
570 mem_is_ff (const char *mem, unsigned int memlen)
571 {
572   int i;
573
574   for (i=0; i < memlen && mem[i] == '\xff'; i++)
575     ;
576   return (i == memlen);
577 }
578
579
580 \f
581 /* Helper to list a single keyref.  */
582 static void
583 list_one_kinfo (key_info_t kinfo, estream_t fp)
584 {
585   if (kinfo)
586     {
587       tty_fprintf (fp, " ");
588       if (mem_is_zero (kinfo->grip, sizeof kinfo->grip))
589         tty_fprintf (fp, "[none]\n");
590       else
591         print_keygrip (fp, kinfo->grip);
592
593       if (kinfo->fprlen && kinfo->created)
594         {
595           tty_fprintf (fp, "      fingerprint :");
596           print_shax_fpr (fp, kinfo->fpr, kinfo->fprlen);
597           tty_fprintf (fp, "      created ....: %s\n",
598                        isotimestamp (kinfo->created));
599         }
600     }
601   else
602     tty_fprintf (fp, " [none]\n");
603 }
604
605
606 /* List all keyinfo in INFO using the list of LABELS.  */
607 static void
608 list_all_kinfo (card_info_t info, keyinfolabel_t labels, estream_t fp)
609 {
610   key_info_t kinfo;
611   int idx, i;
612
613   /* Print the keyinfo.  We first print those we known and then all
614    * remaining item.  */
615   for (kinfo = info->kinfo; kinfo; kinfo = kinfo->next)
616     kinfo->xflag = 0;
617   if (labels)
618     {
619       for (idx=0; labels[idx].label; idx++)
620         {
621           tty_fprintf (fp, "%s", labels[idx].label);
622           kinfo = find_kinfo (info, labels[idx].keyref);
623           list_one_kinfo (kinfo, fp);
624           if (kinfo)
625             kinfo->xflag = 1;
626         }
627     }
628   for (kinfo = info->kinfo; kinfo; kinfo = kinfo->next)
629     {
630       if (kinfo->xflag)
631         continue;
632       tty_fprintf (fp, "Key %s ", kinfo->keyref);
633       for (i=5+strlen (kinfo->keyref); i < 18; i++)
634         tty_fprintf (fp, ".");
635       tty_fprintf (fp, ":");
636       list_one_kinfo (kinfo, fp);
637     }
638 }
639
640
641 /* List OpenPGP card specific data.  */
642 static void
643 list_openpgp (card_info_t info, estream_t fp)
644 {
645   static struct keyinfolabel_s keyinfolabels[] = {
646     { "Signature key ....:", "OPENPGP.1" },
647     { "Encryption key....:", "OPENPGP.2" },
648     { "Authentication key:", "OPENPGP.3" },
649     { NULL, NULL }
650   };
651   int i;
652
653   if (!info->serialno
654       || strncmp (info->serialno, "D27600012401", 12)
655       || strlen (info->serialno) != 32 )
656     {
657       tty_fprintf (fp, "invalid OpenPGP card\n");
658       return;
659     }
660
661   tty_fprintf (fp, "Version ..........: %.1s%c.%.1s%c\n",
662                info->serialno[12] == '0'?"":info->serialno+12,
663                info->serialno[13],
664                info->serialno[14] == '0'?"":info->serialno+14,
665                info->serialno[15]);
666   tty_fprintf (fp, "Manufacturer .....: %s\n",
667                get_manufacturer (xtoi_2(info->serialno+16)*256
668                                  + xtoi_2 (info->serialno+18)));
669   tty_fprintf (fp, "Name of cardholder: ");
670   print_isoname (fp, info->disp_name);
671
672   print_string (fp, "Language prefs ...: ", info->disp_lang);
673   tty_fprintf (fp, "Salutation .......: %s\n",
674                info->disp_sex == 1? _("Mr."):
675                info->disp_sex == 2? _("Mrs.") : "");
676   print_string (fp, "URL of public key : ", info->pubkey_url);
677   print_string (fp, "Login data .......: ", info->login_data);
678   if (info->private_do[0])
679     print_string (fp, "Private DO 1 .....: ", info->private_do[0]);
680   if (info->private_do[1])
681     print_string (fp, "Private DO 2 .....: ", info->private_do[1]);
682   if (info->private_do[2])
683     print_string (fp, "Private DO 3 .....: ", info->private_do[2]);
684   if (info->private_do[3])
685     print_string (fp, "Private DO 4 .....: ", info->private_do[3]);
686   if (info->cafpr1len)
687     {
688       tty_fprintf (fp, "CA fingerprint %d .:", 1);
689       print_shax_fpr (fp, info->cafpr1, info->cafpr1len);
690     }
691   if (info->cafpr2len)
692     {
693       tty_fprintf (fp, "CA fingerprint %d .:", 2);
694       print_shax_fpr (fp, info->cafpr2, info->cafpr2len);
695     }
696   if (info->cafpr3len)
697     {
698       tty_fprintf (fp, "CA fingerprint %d .:", 3);
699       print_shax_fpr (fp, info->cafpr3, info->cafpr3len);
700     }
701   tty_fprintf (fp, "Signature PIN ....: %s\n",
702                info->chv1_cached? _("not forced"): _("forced"));
703   if (info->key_attr[0].algo)
704     {
705       tty_fprintf (fp,    "Key attributes ...:");
706       for (i=0; i < DIM (info->key_attr); i++)
707         if (info->key_attr[i].algo == PUBKEY_ALGO_RSA)
708           tty_fprintf (fp, " rsa%u", info->key_attr[i].nbits);
709         else if (info->key_attr[i].algo == PUBKEY_ALGO_ECDH
710                  || info->key_attr[i].algo == PUBKEY_ALGO_ECDSA
711                  || info->key_attr[i].algo == PUBKEY_ALGO_EDDSA)
712           {
713             const char *curve_for_print = "?";
714             const char *oid;
715
716             if (info->key_attr[i].curve
717                 && (oid = openpgp_curve_to_oid (info->key_attr[i].curve, NULL)))
718               curve_for_print = openpgp_oid_to_curve (oid, 0);
719             tty_fprintf (fp, " %s", curve_for_print);
720           }
721       tty_fprintf (fp, "\n");
722     }
723   tty_fprintf (fp, "Max. PIN lengths .: %d %d %d\n",
724                info->chvmaxlen[0], info->chvmaxlen[1], info->chvmaxlen[2]);
725   tty_fprintf (fp, "PIN retry counter : %d %d %d\n",
726                info->chvinfo[0], info->chvinfo[1], info->chvinfo[2]);
727   tty_fprintf (fp, "Signature counter : %lu\n", info->sig_counter);
728   if (info->extcap.kdf)
729     {
730       tty_fprintf (fp, "KDF setting ......: %s\n",
731                    info->kdf_do_enabled ? "on" : "off");
732     }
733   if (info->extcap.bt)
734     {
735       tty_fprintf (fp, "UIF setting ......: Sign=%s Decrypt=%s Auth=%s\n",
736                    info->uif[0] ? "on" : "off", info->uif[1] ? "on" : "off",
737                    info->uif[2] ? "on" : "off");
738     }
739
740   list_all_kinfo (info, keyinfolabels, fp);
741
742   /* tty_fprintf (fp, "General key info->.: "); */
743   /* thefpr = (info->fpr1len? info->fpr1 : info->fpr2len? info->fpr2 : */
744   /*           info->fpr3len? info->fpr3 : NULL); */
745   /* thefprlen = (info->fpr1len? info->fpr1len : info->fpr2len? info->fpr2len : */
746   /*              info->fpr3len? info->fpr3len : 0); */
747   /* If the fingerprint is all 0xff, the key has no associated
748      OpenPGP certificate.  */
749   /* if ( thefpr && !mem_is_ff (thefpr, thefprlen) */
750   /*      && !get_pubkey_byfprint (ctrl, pk, &keyblock, thefpr, thefprlen)) */
751   /*   { */
752       /* print_pubkey_info (ctrl, fp, pk); */
753       /* if (keyblock) */
754       /*   print_card_key_info (fp, keyblock); */
755   /*   } */
756   /* else */
757   /*   tty_fprintf (fp, "[none]\n"); */
758 }
759
760
761 /* List PIV card specific data.  */
762 static void
763 list_piv (card_info_t info, estream_t fp)
764 {
765   static struct keyinfolabel_s keyinfolabels[] = {
766     { "PIV authentication:", "PIV.9A" },
767     { "Card authenticat. :", "PIV.9E" },
768     { "Digital signature :", "PIV.9C" },
769     { "Key management ...:", "PIV.9D" },
770     { NULL, NULL }
771   };
772   const char *s;
773   int i;
774
775   if (info->chvusage[0] || info->chvusage[1])
776     {
777       tty_fprintf (fp, "PIN usage policy .:");
778       if ((info->chvusage[0] & 0x40))
779           tty_fprintf (fp, " app-pin");
780       if ((info->chvusage[0] & 0x20))
781         tty_fprintf (fp, " global-pin");
782       if ((info->chvusage[0] & 0x10))
783         tty_fprintf (fp, " occ");
784       if ((info->chvusage[0] & 0x08))
785         tty_fprintf (fp, " vci");
786       if ((info->chvusage[0] & 0x08) && !(info->chvusage[0] & 0x04))
787         tty_fprintf (fp, " pairing");
788
789       if (info->chvusage[1] == 0x10)
790         tty_fprintf (fp, " primary:card");
791       else if (info->chvusage[1] == 0x20)
792         tty_fprintf (fp, " primary:global");
793
794       tty_fprintf (fp, "\n");
795     }
796
797   tty_fprintf (fp, "PIN retry counter :");
798   for (i=0; i < DIM (info->chvinfo); i++)
799     {
800       if (info->chvinfo[i] > 0)
801         tty_fprintf (fp, " %d", info->chvinfo[i]);
802       else
803         {
804           switch (info->chvinfo[i])
805             {
806             case -1: s = "[error]"; break;
807             case -2: s = "-"; break;  /* No such PIN */
808             case -3: s = "[blocked]"; break;
809             case -5: s = "[verified]"; break;
810             default: s = "[?]"; break;
811             }
812           tty_fprintf (fp, " %s", s);
813         }
814     }
815   tty_fprintf (fp, "\n");
816   list_all_kinfo (info, keyinfolabels, fp);
817
818 }
819
820
821 /* Print all available information about the current card. */
822 static void
823 list_card (card_info_t info)
824 {
825   estream_t fp = NULL;
826
827   tty_fprintf (fp, "Reader ...........: %s\n",
828                info->reader? info->reader : "[none]");
829   if (info->cardtype)
830     tty_fprintf (fp, "Card type ........: %s\n", info->cardtype);
831   tty_fprintf (fp, "Serial number ....: %s\n",
832                info->serialno? info->serialno : "[none]");
833   tty_fprintf (fp, "Application type .: %s%s%s%s\n",
834                app_type_string (info->apptype),
835                info->apptype == APP_TYPE_UNKNOWN && info->apptypestr? "(":"",
836                info->apptype == APP_TYPE_UNKNOWN && info->apptypestr
837                ? info->apptypestr:"",
838                info->apptype == APP_TYPE_UNKNOWN && info->apptypestr? ")":"");
839   if (info->serialno && info->dispserialno
840       && strcmp (info->serialno, info->dispserialno))
841     tty_fprintf (fp, "Displayed S/N ....: %s\n", info->dispserialno);
842
843   switch (info->apptype)
844     {
845     case APP_TYPE_OPENPGP: list_openpgp (info, fp); break;
846     case APP_TYPE_PIV:     list_piv (info, fp); break;
847     default: break;
848     }
849 }
850
851
852 \f
853 /* The VERIFY command.  */
854 static gpg_error_t
855 cmd_verify (card_info_t info, char *argstr)
856 {
857   gpg_error_t err;
858
859   if (!info)
860     return print_help ("verify [chvid]", 0);
861
862   if (info->apptype == APP_TYPE_OPENPGP)
863     err = scd_checkpin (info->serialno);
864   else
865     err = scd_checkpin (argstr);
866
867   if (err)
868     log_error ("verify failed: %s <%s>\n",
869                gpg_strerror (err), gpg_strsource (err));
870   return err;
871 }
872
873
874 /* Helper for cmd_name to qyery a part of name.  */
875 static char *
876 ask_one_name (const char *prompt)
877 {
878   char *name;
879   int i;
880
881   for (;;)
882     {
883       name = tty_get (prompt);
884       trim_spaces (name);
885       tty_kill_prompt ();
886       if (!*name || *name == CONTROL_D)
887         {
888           if (*name == CONTROL_D)
889             tty_fprintf (NULL, "\n");
890           xfree (name);
891           return NULL;
892         }
893       for (i=0; name[i] && name[i] >= ' ' && name[i] <= 126; i++)
894         ;
895
896       /* The name must be in Latin-1 and not UTF-8 - lacking the code
897        * to ensure this we restrict it to ASCII. */
898       if (name[i])
899         tty_printf (_("Error: Only plain ASCII is currently allowed.\n"));
900       else if (strchr (name, '<'))
901         tty_printf (_("Error: The \"<\" character may not be used.\n"));
902       else if (strstr (name, "  "))
903         tty_printf (_("Error: Double spaces are not allowed.\n"));
904       else
905         return name;
906       xfree (name);
907     }
908 }
909
910
911 /* The NAME command.  */
912 static gpg_error_t
913 cmd_name (card_info_t info, const char *argstr)
914 {
915   gpg_error_t err;
916   char *surname, *givenname;
917   char *isoname, *p;
918
919   if (!info)
920     return print_help
921       ("name [--clear]\n\n"
922        "Set the name field of an OpenPGP card.  With --clear the stored\n"
923        "name is cleared off the card.", APP_TYPE_OPENPGP, APP_TYPE_NKS, 0);
924
925   if (info->apptype != APP_TYPE_OPENPGP)
926     {
927       log_info ("Note: This is an OpenPGP only command.\n");
928       return gpg_error (GPG_ERR_NOT_SUPPORTED);
929     }
930
931  again:
932   if (!strcmp (argstr, "--clear"))
933     isoname = xstrdup (" "); /* No real way to clear; set to space instead. */
934   else
935     {
936       surname = ask_one_name (_("Cardholder's surname: "));
937       givenname = ask_one_name (_("Cardholder's given name: "));
938       if (!surname || !givenname || (!*surname && !*givenname))
939         {
940           xfree (surname);
941           xfree (givenname);
942           return gpg_error (GPG_ERR_CANCELED);
943         }
944
945       isoname = xstrconcat (surname, "<<", givenname, NULL);
946       xfree (surname);
947       xfree (givenname);
948       for (p=isoname; *p; p++)
949         if (*p == ' ')
950           *p = '<';
951
952       if (strlen (isoname) > 39 )
953         {
954           log_info (_("Error: Combined name too long "
955                       "(limit is %d characters).\n"), 39);
956           xfree (isoname);
957           goto again;
958         }
959     }
960
961   err = scd_setattr ("DISP-NAME", isoname, strlen (isoname));
962
963   xfree (isoname);
964   return err;
965 }
966
967
968 static gpg_error_t
969 cmd_url (card_info_t info, const char *argstr)
970 {
971   gpg_error_t err;
972   char *url;
973
974   if (!info)
975     return print_help
976       ("URL [--clear]\n\n"
977        "Set the URL data object.  That data object can be used by\n"
978        "the FETCH command to retrieve the full public key.  The\n"
979        "option --clear deletes the content of that data object.",
980        APP_TYPE_OPENPGP, 0);
981
982   if (info->apptype != APP_TYPE_OPENPGP)
983     {
984       log_info ("Note: This is an OpenPGP only command.\n");
985       return gpg_error (GPG_ERR_NOT_SUPPORTED);
986     }
987
988   if (!strcmp (argstr, "--clear"))
989     url = xstrdup (" "); /* No real way to clear; set to space instead. */
990   else
991     {
992       url = tty_get (_("URL to retrieve public key: "));
993       trim_spaces (url);
994       tty_kill_prompt ();
995       if (!*url || *url == CONTROL_D)
996         {
997           err = gpg_error (GPG_ERR_CANCELED);
998           goto leave;
999         }
1000     }
1001
1002   err = scd_setattr ("PUBKEY-URL", url, strlen (url));
1003
1004  leave:
1005   xfree (url);
1006   return err;
1007 }
1008
1009
1010 /* Fetch the key from the URL given on the card or try to get it from
1011  * the default keyserver.  */
1012 static gpg_error_t
1013 cmd_fetch (card_info_t info)
1014 {
1015   gpg_error_t err;
1016   key_info_t kinfo;
1017
1018   if (!info)
1019     return print_help
1020       ("FETCH\n\n"
1021        "Retrieve a key using the URL data object or if that is missing\n"
1022        "using the fingerprint.", APP_TYPE_OPENPGP, 0);
1023
1024   if (info->pubkey_url && *info->pubkey_url)
1025     {
1026       /* strlist_t sl = NULL; */
1027
1028       /* add_to_strlist (&sl, info.pubkey_url); */
1029       /* err = keyserver_fetch (ctrl, sl, KEYORG_URL); */
1030       /* free_strlist (sl); */
1031       err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);  /* FIXME */
1032     }
1033   else if ((kinfo = find_kinfo (info, "OPENPGP.1")) && kinfo->fprlen)
1034     {
1035       /* rc = keyserver_import_fprint (ctrl, info.fpr1, info.fpr1len, */
1036       /*                               opt.keyserver, 0); */
1037       err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);  /* FIXME */
1038     }
1039   else
1040     err = gpg_error (GPG_ERR_NO_DATA);
1041
1042   return err;
1043 }
1044
1045
1046 static gpg_error_t
1047 cmd_login (card_info_t info, char *argstr)
1048 {
1049   gpg_error_t err;
1050   char *data;
1051   size_t datalen;
1052
1053   if (!info)
1054     return print_help
1055       ("LOGIN [--clear] [< FILE]\n\n"
1056        "Set the login data object.  If FILE is given the data is\n"
1057        "is read from that file.  This allows for binary data.\n"
1058        "The option --clear deletes the login data.",
1059        APP_TYPE_OPENPGP, 0);
1060
1061   if (!strcmp (argstr, "--clear"))
1062     {
1063       data = xstrdup (" "); /* kludge.  */
1064       datalen = 1;
1065     }
1066   else if (*argstr == '<')  /* Read it from a file */
1067     {
1068       for (argstr++; spacep (argstr); argstr++)
1069         ;
1070       err = get_data_from_file (argstr, &data, &datalen);
1071       if (err)
1072         goto leave;
1073     }
1074   else
1075     {
1076       data = tty_get (_("Login data (account name): "));
1077       trim_spaces (data);
1078       tty_kill_prompt ();
1079       if (!*data || *data == CONTROL_D)
1080         {
1081           err = gpg_error (GPG_ERR_CANCELED);
1082           goto leave;
1083         }
1084       datalen = strlen (data);
1085     }
1086
1087   err = scd_setattr ("LOGIN-DATA", data, datalen);
1088
1089  leave:
1090   xfree (data);
1091   return err;
1092 }
1093
1094
1095 static gpg_error_t
1096 cmd_lang (card_info_t info, const char *argstr)
1097 {
1098   gpg_error_t err;
1099   char *data, *p;
1100
1101   if (!info)
1102     return print_help
1103       ("LANG [--clear]\n\n"
1104        "Change the language info for the card.  This info can be used\n"
1105        "by applications for a personalized greeting.  Up to 4 two-digit\n"
1106        "language identifiers can be entered as a preference.  The option\n"
1107        "--clear removes all identifiers.  GnuPG does not use this info.",
1108        APP_TYPE_OPENPGP, 0);
1109
1110   if (!strcmp (argstr, "--clear"))
1111     data = xstrdup ("  "); /* Note that we need two spaces here.  */
1112   else
1113     {
1114     again:
1115       data = tty_get (_("Language preferences: "));
1116       trim_spaces (data);
1117       tty_kill_prompt ();
1118       if (!*data || *data == CONTROL_D)
1119         {
1120           err = gpg_error (GPG_ERR_CANCELED);
1121           goto leave;
1122         }
1123
1124       if (strlen (data) > 8 || (strlen (data) & 1))
1125         {
1126           log_info (_("Error: invalid length of preference string.\n"));
1127           xfree (data);
1128           goto again;
1129         }
1130
1131       for (p=data; *p && *p >= 'a' && *p <= 'z'; p++)
1132         ;
1133       if (*p)
1134         {
1135           log_info (_("Error: invalid characters in preference string.\n"));
1136           xfree (data);
1137           goto again;
1138         }
1139     }
1140
1141   err = scd_setattr ("DISP-LANG", data, strlen (data));
1142
1143  leave:
1144   xfree (data);
1145   return err;
1146 }
1147
1148
1149 static gpg_error_t
1150 cmd_salut (card_info_t info, const char *argstr)
1151 {
1152   gpg_error_t err;
1153   char *data = NULL;
1154   const char *str;
1155
1156   if (!info)
1157     return print_help
1158       ("SALUT [--clear]\n\n"
1159        "Change the salutation info for the card.  This info can be used\n"
1160        "by applications for a personalized greeting.  The option --clear\n"
1161        "removes this data object.  GnuPG does not use this info.",
1162        APP_TYPE_OPENPGP, 0);
1163
1164  again:
1165   if (!strcmp (argstr, "--clear"))
1166     str = "9";
1167   else
1168     {
1169       data = tty_get (_("Salutation (M = Mr., F = Mrs., or space): "));
1170       trim_spaces (data);
1171       tty_kill_prompt ();
1172       if (*data == CONTROL_D)
1173         {
1174           err = gpg_error (GPG_ERR_CANCELED);
1175           goto leave;
1176         }
1177
1178       if (!*data)
1179         str = "9";
1180       else if ((*data == 'M' || *data == 'm') && !data[1])
1181         str = "1";
1182       else if ((*data == 'F' || *data == 'f') && !data[1])
1183         str = "2";
1184       else
1185         {
1186           tty_printf (_("Error: invalid response.\n"));
1187           xfree (data);
1188           goto again;
1189         }
1190     }
1191
1192   err = scd_setattr ("DISP-SEX", str, 1);
1193  leave:
1194   xfree (data);
1195   return err;
1196 }
1197
1198
1199 static gpg_error_t
1200 cmd_cafpr (card_info_t info, char *argstr)
1201 {
1202   gpg_error_t err;
1203   char *data = NULL;
1204   const char *s;
1205   int i, c;
1206   unsigned char fpr[32];
1207   int fprlen;
1208   int fprno;
1209   int opt_clear = 0;
1210
1211   if (!info)
1212     return print_help
1213       ("CAFPR [--clear] N\n\n"
1214        "Change the CA fingerprint number N.  N must be in the\n"
1215        "range 1 to 3.  The option --clear clears the specified\n"
1216        "CA fingerprint N or all of them if N is 0 or not given.",
1217        APP_TYPE_OPENPGP, 0);
1218
1219
1220   opt_clear = has_leading_option (argstr, "--clear");
1221   argstr = skip_options (argstr);
1222
1223   if (digitp (argstr))
1224     {
1225       fprno = atoi (argstr);
1226       while (digitp (argstr))
1227         argstr++;
1228       while (spacep (argstr))
1229         argstr++;
1230     }
1231   else
1232     fprno = 0;
1233
1234   if (opt_clear && !fprno)
1235     ; /* Okay: clear all fprs.  */
1236   else if (fprno < 1 || fprno > 3)
1237     {
1238       err = gpg_error (GPG_ERR_INV_ARG);
1239       goto leave;
1240     }
1241
1242  again:
1243   if (opt_clear)
1244     {
1245       memset (fpr, 0, 20);
1246       fprlen = 20;
1247     }
1248   else
1249     {
1250       xfree (data);
1251       data = tty_get (_("CA fingerprint: "));
1252       trim_spaces (data);
1253       tty_kill_prompt ();
1254       if (!*data || *data == CONTROL_D)
1255         {
1256           err = gpg_error (GPG_ERR_CANCELED);
1257           goto leave;
1258         }
1259
1260       for (i=0, s=data; i < sizeof fpr && *s; )
1261         {
1262           while (spacep(s))
1263             s++;
1264           if (*s == ':')
1265             s++;
1266           while (spacep(s))
1267             s++;
1268           c = hextobyte (s);
1269           if (c == -1)
1270             break;
1271           fpr[i++] = c;
1272           s += 2;
1273         }
1274       fprlen = i;
1275       if ((fprlen != 20 && fprlen != 32) || *s)
1276         {
1277           log_error (_("Error: invalid formatted fingerprint.\n"));
1278           goto again;
1279         }
1280     }
1281
1282   if (!fprno)
1283     {
1284       log_assert (opt_clear);
1285       err = scd_setattr ("CA-FPR-1", fpr, fprlen);
1286       if (!err)
1287         err = scd_setattr ("CA-FPR-2", fpr, fprlen);
1288       if (!err)
1289         err = scd_setattr ("CA-FPR-3", fpr, fprlen);
1290     }
1291   else
1292     err = scd_setattr (fprno==1?"CA-FPR-1":
1293                        fprno==2?"CA-FPR-2":
1294                        fprno==3?"CA-FPR-3":"x", fpr, fprlen);
1295
1296  leave:
1297   xfree (data);
1298   return err;
1299 }
1300
1301
1302 static gpg_error_t
1303 cmd_privatedo (card_info_t info, char *argstr)
1304 {
1305   gpg_error_t err;
1306   int opt_clear;
1307   char *do_name = NULL;
1308   char *data = NULL;
1309   size_t datalen;
1310   int do_no;
1311
1312   if (!info)
1313     return print_help
1314       ("PRIVATEDO [--clear] N [< FILE]\n\n"
1315        "Change the private data object N.  N must be in the\n"
1316        "range 1 to 4.  If FILE is given the data is is read\n"
1317        "from that file.  The option --clear clears the data.",
1318        APP_TYPE_OPENPGP, 0);
1319
1320   opt_clear = has_leading_option (argstr, "--clear");
1321   argstr = skip_options (argstr);
1322
1323   if (digitp (argstr))
1324     {
1325       do_no = atoi (argstr);
1326       while (digitp (argstr))
1327         argstr++;
1328       while (spacep (argstr))
1329         argstr++;
1330     }
1331   else
1332     do_no = 0;
1333
1334   if (do_no < 1 || do_no > 4)
1335     {
1336       err = gpg_error (GPG_ERR_INV_ARG);
1337       goto leave;
1338     }
1339   do_name = xasprintf ("PRIVATE-DO-%d", do_no);
1340
1341   if (opt_clear)
1342     {
1343       data = xstrdup (" ");
1344       datalen = 1;
1345     }
1346   else if (*argstr == '<')  /* Read it from a file */
1347     {
1348       for (argstr++; spacep (argstr); argstr++)
1349         ;
1350       err = get_data_from_file (argstr, &data, &datalen);
1351       if (err)
1352         goto leave;
1353     }
1354   else if (*argstr)
1355     {
1356       err = gpg_error (GPG_ERR_INV_ARG);
1357       goto leave;
1358     }
1359   else
1360     {
1361       data = tty_get (_("Private DO data: "));
1362       trim_spaces (data);
1363       tty_kill_prompt ();
1364       datalen = strlen (data);
1365       if (!*data || *data == CONTROL_D)
1366         {
1367           err = gpg_error (GPG_ERR_CANCELED);
1368           goto leave;
1369         }
1370     }
1371
1372   err = scd_setattr (do_name, data, datalen);
1373
1374  leave:
1375   xfree (do_name);
1376   xfree (data);
1377   return err;
1378 }
1379
1380
1381 static gpg_error_t
1382 cmd_writecert (card_info_t info, char *argstr)
1383 {
1384   gpg_error_t err;
1385   int opt_clear;
1386   int do_no;
1387   char *data = NULL;
1388   size_t datalen;
1389
1390   if (!info)
1391     return print_help
1392       ("WRITECERT [--clear] 3 < FILE\n\n"
1393        "Write a certificate for key 3.  Unless --clear is given\n"
1394        "the file argement is mandatory.  The option --clear removes\n"
1395        "the certificate from the card.",
1396        APP_TYPE_OPENPGP, 0);
1397
1398   opt_clear = has_leading_option (argstr, "--clear");
1399   argstr = skip_options (argstr);
1400
1401   if (digitp (argstr))
1402     {
1403       do_no = atoi (argstr);
1404       while (digitp (argstr))
1405         argstr++;
1406       while (spacep (argstr))
1407         argstr++;
1408     }
1409   else
1410     do_no = 0;
1411
1412   if (do_no != 3)
1413     {
1414       err = gpg_error (GPG_ERR_INV_ARG);
1415       goto leave;
1416     }
1417
1418   if (opt_clear)
1419     {
1420       data = xstrdup (" ");
1421       datalen = 1;
1422     }
1423   else if (*argstr == '<')  /* Read it from a file */
1424     {
1425       for (argstr++; spacep (argstr); argstr++)
1426         ;
1427       err = get_data_from_file (argstr, &data, &datalen);
1428       if (err)
1429         goto leave;
1430     }
1431   else
1432     {
1433       err = gpg_error (GPG_ERR_INV_ARG);
1434       goto leave;
1435     }
1436
1437   err = scd_writecert ("OPENPGP.3", data, datalen);
1438
1439  leave:
1440   xfree (data);
1441   return err;
1442 }
1443
1444
1445 static gpg_error_t
1446 cmd_readcert (card_info_t info, char *argstr)
1447 {
1448   gpg_error_t err;
1449   int do_no;
1450   void *data = NULL;
1451   size_t datalen;
1452   const char *fname;
1453
1454   if (!info)
1455     return print_help
1456       ("READCERT 3 > FILE\n\n"
1457        "Read the certificate for key 3 and store it in FILE.",
1458        APP_TYPE_OPENPGP, 0);
1459
1460   argstr = skip_options (argstr);
1461
1462   if (digitp (argstr))
1463     {
1464       do_no = atoi (argstr);
1465       while (digitp (argstr))
1466         argstr++;
1467       while (spacep (argstr))
1468         argstr++;
1469     }
1470   else
1471     do_no = 0;
1472
1473   if (do_no != 3)
1474     {
1475       err = gpg_error (GPG_ERR_INV_ARG);
1476       goto leave;
1477     }
1478
1479   if (*argstr == '>')  /* Read it from a file */
1480     {
1481       for (argstr++; spacep (argstr); argstr++)
1482         ;
1483       fname = argstr;
1484     }
1485   else
1486     {
1487       err = gpg_error (GPG_ERR_INV_ARG);
1488       goto leave;
1489     }
1490
1491   err = scd_readcert ("OPENPGP.3", &data, &datalen);
1492   if (err)
1493     goto leave;
1494
1495   err = put_data_to_file (fname, data, datalen);
1496
1497  leave:
1498   xfree (data);
1499   return err;
1500 }
1501
1502
1503 static gpg_error_t
1504 cmd_forcesig (card_info_t info)
1505 {
1506   gpg_error_t err;
1507   int newstate;
1508
1509   if (!info)
1510     return print_help
1511       ("FORCESIG\n\n"
1512        "Toggle the forcesig flag of an OpenPGP card.",
1513        APP_TYPE_OPENPGP, 0);
1514
1515   if (info->apptype != APP_TYPE_OPENPGP)
1516     {
1517       log_info ("Note: This is an OpenPGP only command.\n");
1518       return gpg_error (GPG_ERR_NOT_SUPPORTED);
1519     }
1520
1521   newstate = !info->chv1_cached;
1522
1523   err = scd_setattr ("CHV-STATUS-1", newstate? "\x01":"", 1);
1524   if (err)
1525     goto leave;
1526
1527   /* Read it back to be sure we have the right toggle state the next
1528    * time.  */
1529   err = scd_getattr ("CHV-STATUS", info);
1530
1531  leave:
1532   return err;
1533 }
1534
1535
1536 /* Helper for cmd_generate.  Noe that either 0 or 1 is stored at
1537  * FORCED_CHV1. */
1538 static gpg_error_t
1539 check_pin_for_key_operation (card_info_t info, int *forced_chv1)
1540 {
1541   gpg_error_t err = 0;
1542
1543   *forced_chv1 = !info->chv1_cached;
1544   if (*forced_chv1)
1545     { /* Switch off the forced mode so that during key generation we
1546        * don't get bothered with PIN queries for each self-signature. */
1547       err = scd_setattr ("CHV-STATUS-1", "\x01", 1);
1548       if (err)
1549         {
1550           log_error ("error clearing forced signature PIN flag: %s\n",
1551                      gpg_strerror (err));
1552           *forced_chv1 = -1;  /* Not changed.  */
1553           goto leave;
1554         }
1555     }
1556
1557   /* Check the PIN now, so that we won't get asked later for each
1558    * binding signature.  */
1559   err = scd_checkpin (info->serialno);
1560   if (err)
1561     log_error ("error checking the PIN: %s\n", gpg_strerror (err));
1562
1563  leave:
1564   return err;
1565 }
1566
1567
1568 /* Helper for cmd_generate.  */
1569 static void
1570 restore_forced_chv1 (int *forced_chv1)
1571 {
1572   gpg_error_t err;
1573
1574   /* Note the possible values stored at FORCED_CHV1:
1575    *   0 - forcesig was not enabled.
1576    *   1 - forcesig was enabled - enable it again.
1577    *  -1 - We have not changed anything.  */
1578   if (*forced_chv1 == 1)
1579     { /* Switch back to forced state. */
1580       err = scd_setattr ("CHV-STATUS-1", "", 1);
1581       if (err)
1582         log_error ("error setting forced signature PIN flag: %s\n",
1583                    gpg_strerror (err));
1584       *forced_chv1 = 0;
1585     }
1586 }
1587
1588
1589 static gpg_error_t
1590 cmd_generate (card_info_t info)
1591 {
1592   gpg_error_t err;
1593   int forced_chv1 = -1;
1594   int want_backup;
1595   char *answer = NULL;
1596   key_info_t kinfo1, kinfo2, kinfo3;
1597
1598   if (!info)
1599     return print_help
1600       ("GENERATE\n\n"
1601        "Menu to generate a new keys.",
1602        APP_TYPE_OPENPGP, 0);
1603
1604   if (info->apptype != APP_TYPE_OPENPGP)
1605     {
1606       log_info ("Note: This is an OpenPGP only command.\n");
1607       return gpg_error (GPG_ERR_NOT_SUPPORTED);
1608     }
1609
1610   if (info->extcap.ki)
1611     {
1612       xfree (answer);
1613       answer = tty_get (_("Make off-card backup of encryption key? (Y/n) "));
1614       want_backup = answer_is_yes_no_default (answer, 1/*(default to Yes)*/);
1615       tty_kill_prompt ();
1616       if (*answer == CONTROL_D)
1617         {
1618           err = gpg_error (GPG_ERR_CANCELED);
1619           goto leave;
1620         }
1621     }
1622   else
1623     want_backup = 0;
1624
1625
1626   kinfo1 = find_kinfo (info, "OPENPGP.1");
1627   kinfo2 = find_kinfo (info, "OPENPGP.2");
1628   kinfo3 = find_kinfo (info, "OPENPGP.3");
1629
1630   if ((kinfo1 && kinfo1->fprlen && !mem_is_zero (kinfo1->fpr,kinfo1->fprlen))
1631       || (kinfo2 && kinfo2->fprlen && !mem_is_zero (kinfo2->fpr,kinfo2->fprlen))
1632       || (kinfo3 && kinfo3->fprlen && !mem_is_zero (kinfo3->fpr,kinfo3->fprlen))
1633       )
1634     {
1635       tty_printf ("\n");
1636       log_info (_("Note: keys are already stored on the card!\n"));
1637       tty_printf ("\n");
1638       answer = tty_get (_("Replace existing keys? (y/N) "));
1639       tty_kill_prompt ();
1640       if (*answer == CONTROL_D)
1641         {
1642           err = gpg_error (GPG_ERR_CANCELED);
1643           goto leave;
1644         }
1645
1646       if (!answer_is_yes_no_default (answer, 0/*(default to No)*/))
1647         {
1648           err = gpg_error (GPG_ERR_CANCELED);
1649           goto leave;
1650         }
1651     }
1652
1653   /* If no displayed name has been set, we assume that this is a fresh
1654    * card and print a hint about the default PINs.  */
1655   if (!info->disp_name || !*info->disp_name)
1656     {
1657       tty_printf ("\n");
1658       tty_printf (_("Please note that the factory settings of the PINs are\n"
1659                     "   PIN = '%s'     Admin PIN = '%s'\n"
1660                     "You should change them using the command --change-pin\n"),
1661                   OPENPGP_USER_PIN_DEFAULT, OPENPGP_ADMIN_PIN_DEFAULT);
1662       tty_printf ("\n");
1663     }
1664
1665   err = check_pin_for_key_operation (info, &forced_chv1);
1666   if (err)
1667     goto leave;
1668
1669   /* FIXME: We need to divert to a function which spwans gpg which
1670    * will then create the key.  This also requires new features in
1671    * gpg.  We might also first create the keys on the card and then
1672    * tell gpg to use them to create the OpenPGP keyblock. */
1673   /* generate_keypair (ctrl, 1, NULL, info.serialno, want_backup); */
1674   err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1675
1676  leave:
1677   restore_forced_chv1 (&forced_chv1);
1678   xfree (answer);
1679   return err;
1680 }
1681
1682
1683 /* Sub-menu to change a PIN.  The presented options may depend on the
1684  * the ALLOW_ADMIN flag.  */
1685 static gpg_error_t
1686 cmd_passwd (card_info_t info, int allow_admin)
1687 {
1688   gpg_error_t err;
1689   char *answer = NULL;
1690
1691   if (!info)
1692     return print_help
1693       ("PASSWD\n\n"
1694        "Menu to change or unblock the PINs.  Note that the\n"
1695        "presented menu options depend on the type of card\n"
1696        "and whether the admin mode is enabled.",
1697        0);
1698
1699   /* Convenience message because we did this in gpg --card-edit too.  */
1700   if (info->apptype == APP_TYPE_OPENPGP)
1701     log_info (_("OpenPGP card no. %s detected\n"),
1702               info->dispserialno? info->dispserialno : info->serialno);
1703
1704   if (!allow_admin)
1705     {
1706       err = scd_change_pin (1);
1707       if (err)
1708         goto leave;
1709       log_info ("PIN changed.\n");
1710     }
1711   else if (info->apptype == APP_TYPE_OPENPGP)
1712     {
1713       for (;;)
1714         {
1715           tty_printf ("\n");
1716           tty_printf ("1 - change PIN\n"
1717                       "2 - unblock and set new PIN\n"
1718                       "3 - change Admin PIN\n"
1719                       "4 - set the Reset Code\n"
1720                       "Q - quit\n");
1721           tty_printf ("\n");
1722
1723           err = 0;
1724           xfree (answer);
1725           answer = tty_get (_("Your selection? "));
1726           tty_kill_prompt ();
1727           if (*answer == CONTROL_D)
1728             break;  /* Quit.  */
1729           if (strlen (answer) != 1)
1730             continue;
1731           if (*answer == 'q' || *answer == 'Q')
1732             break;  /* Quit.  */
1733
1734           if (*answer == '1')
1735             {
1736               /* Change PIN (same as the direct thing in non-admin mode).  */
1737               err = scd_change_pin (1);
1738               if (err)
1739                 log_error ("Error changing the PIN: %s\n", gpg_strerror (err));
1740               else
1741                 log_info ("PIN changed.\n");
1742             }
1743           else if (*answer == '2')
1744             {
1745               /* Unblock PIN by setting a new PIN.  */
1746               err = scd_change_pin (101);
1747               if (err)
1748                 log_error ("Error unblocking the PIN: %s\n", gpg_strerror(err));
1749               else
1750                 log_info ("PIN unblocked and new PIN set.\n");
1751             }
1752           else if (*answer == '3')
1753             {
1754               /* Change Admin PIN.  */
1755               err = scd_change_pin (3);
1756               if (err)
1757                 log_error ("Error changing the PIN: %s\n", gpg_strerror (err));
1758               else
1759                 log_info ("PIN changed.\n");
1760           }
1761           else if (*answer == '4')
1762             {
1763               /* Set a new Reset Code.  */
1764               err = scd_change_pin (102);
1765               if (err)
1766                 log_error ("Error setting the Reset Code: %s\n",
1767                            gpg_strerror (err));
1768               else
1769                 log_info ("Reset Code set.\n");
1770             }
1771
1772         } /*end for loop*/
1773     }
1774   else
1775     {
1776       log_info ("Admin related passwd options not yet supported for '%s'\n",
1777                 app_type_string (info->apptype));
1778       err = gpg_error (GPG_ERR_NOT_SUPPORTED);
1779     }
1780
1781  leave:
1782   xfree (answer);
1783   return err;
1784 }
1785
1786
1787 static gpg_error_t
1788 cmd_unblock (card_info_t info)
1789 {
1790   gpg_error_t err = 0;
1791
1792   if (!info)
1793     return print_help
1794       ("UNBLOCK\n\n"
1795        "Unblock a PIN using a PUK or Reset Code.  Note that OpenPGP\n"
1796        "cards prior to version 2 can't use this; instead the PASSWD\n"
1797        "command can be used to set a new PIN.",
1798        0);
1799
1800   if (info->apptype == APP_TYPE_OPENPGP)
1801     log_info (_("OpenPGP card no. %s detected\n"),
1802               info->dispserialno? info->dispserialno : info->serialno);
1803
1804   if (info->apptype == APP_TYPE_OPENPGP && !info->is_v2)
1805     log_error (_("This command is only available for version 2 cards\n"));
1806   else if (info->apptype == APP_TYPE_OPENPGP && !info->chvinfo[1])
1807     log_error (_("Reset Code not or not anymore available\n"));
1808   else if (info->apptype == APP_TYPE_OPENPGP)
1809     {
1810       err = scd_change_pin (2);
1811       if (!err)
1812         log_info ("PIN changed.\n");
1813     }
1814   else
1815     log_info ("Unblocking not yet supported for '%s'\n",
1816               app_type_string (info->apptype));
1817
1818   return err;
1819 }
1820
1821
1822 /* Direct sending of an hex encoded APDU with error printing.  */
1823 static gpg_error_t
1824 send_apdu (const char *hexapdu, const char *desc, unsigned int ignore)
1825 {
1826   gpg_error_t err;
1827   unsigned int sw;
1828
1829   err = scd_apdu (hexapdu, &sw);
1830   if (err)
1831     log_error ("sending card command %s failed: %s\n", desc,
1832                gpg_strerror (err));
1833   else if (!hexapdu || !strcmp (hexapdu, "undefined"))
1834     ;
1835   else if (ignore == 0xffff)
1836     ; /* Ignore all status words.  */
1837   else if (sw != 0x9000)
1838     {
1839       switch (sw)
1840         {
1841         case 0x6285: err = gpg_error (GPG_ERR_OBJ_TERM_STATE); break;
1842         case 0x6982: err = gpg_error (GPG_ERR_BAD_PIN); break;
1843         case 0x6985: err = gpg_error (GPG_ERR_USE_CONDITIONS); break;
1844         default: err = gpg_error (GPG_ERR_CARD);
1845         }
1846       if (!(ignore && ignore == sw))
1847         log_error ("card command %s failed: %s (0x%04x)\n", desc,
1848                    gpg_strerror (err),  sw);
1849     }
1850   return err;
1851 }
1852
1853
1854 /* Note: On successful execution a redisplay should be scheduled.  If
1855  * this function fails the card may be in an unknown state. */
1856 static gpg_error_t
1857 cmd_factoryreset (card_info_t info)
1858 {
1859   gpg_error_t err;
1860   char *answer = NULL;
1861   int termstate = 0;
1862   int any_apdu = 0;
1863   int is_yubikey = 0;
1864   int i;
1865
1866
1867   if (!info)
1868     return print_help
1869       ("FACTORY-RESET\n\n"
1870        "Do a complete reset of some OpenPGP and PIV cards.  This\n"
1871        "deletes all data and keys and resets the PINs to their default.\n"
1872        "This is mainly used by developers with scratch cards.  Don't\n"
1873        "worry, you need to confirm before the command proceeds.",
1874        APP_TYPE_OPENPGP, APP_TYPE_PIV, 0);
1875
1876   /* We support the factory reset for most OpenPGP cards and Yubikeys
1877    * with the PIV application.  */
1878   if (info->apptype == APP_TYPE_OPENPGP)
1879     ;
1880   else if (info->apptype == APP_TYPE_PIV
1881            && info->cardtype && !strcmp (info->cardtype, "yubikey"))
1882     is_yubikey = 1;
1883   else
1884
1885     return gpg_error (GPG_ERR_NOT_SUPPORTED);
1886
1887   /* For an OpenPGP card the code below basically does the same what
1888    * this gpg-connect-agent script does:
1889    *
1890    *   scd reset
1891    *   scd serialno undefined
1892    *   scd apdu 00 A4 04 00 06 D2 76 00 01 24 01
1893    *   scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
1894    *   scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
1895    *   scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
1896    *   scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
1897    *   scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
1898    *   scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
1899    *   scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
1900    *   scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
1901    *   scd apdu 00 e6 00 00
1902    *   scd apdu 00 44 00 00
1903    *   scd reset
1904    *   /echo Card has been reset to factory defaults
1905    *
1906    * For a PIV application on a Yubikey it merely issues the Yubikey
1907    * specific resset command.
1908    */
1909
1910   err = scd_learn (info);
1911   if (gpg_err_code (err) == GPG_ERR_OBJ_TERM_STATE
1912       && gpg_err_source (err) == GPG_ERR_SOURCE_SCD)
1913     termstate = 1;
1914   else if (err)
1915     {
1916       log_error (_("OpenPGP card not available: %s\n"), gpg_strerror (err));
1917       goto leave;
1918     }
1919
1920   if (!termstate || is_yubikey)
1921     {
1922       if (is_yubikey)
1923         log_info (_("Yubikey no. %s with PIV application detected\n"),
1924                   info->dispserialno? info->dispserialno : info->serialno);
1925       else
1926         {
1927           log_info (_("OpenPGP card no. %s detected\n"),
1928                     info->dispserialno? info->dispserialno : info->serialno);
1929           if (!(info->status_indicator == 3 || info->status_indicator == 5))
1930             {
1931               /* Note: We won't see status-indicator 3 here because it
1932                * is not possible to select a card application in
1933                * termination state.  */
1934               log_error (_("This command is not supported by this card\n"));
1935               err = gpg_error (GPG_ERR_NOT_SUPPORTED);
1936               goto leave;
1937             }
1938         }
1939
1940       tty_printf ("\n");
1941       log_info
1942         (_("Note: This command destroys all keys stored on the card!\n"));
1943       tty_printf ("\n");
1944       xfree (answer);
1945       answer = tty_get (_("Continue? (y/N) "));
1946       tty_kill_prompt ();
1947       trim_spaces (answer);
1948       if (*answer == CONTROL_D
1949           || !answer_is_yes_no_default (answer, 0/*(default to no)*/))
1950         {
1951           err = gpg_error (GPG_ERR_CANCELED);
1952           goto leave;
1953         }
1954
1955       xfree (answer);
1956       answer = tty_get (_("Really do a factory reset? (enter \"yes\") "));
1957       tty_kill_prompt ();
1958       trim_spaces (answer);
1959       if (strcmp (answer, "yes") && strcmp (answer,_("yes")))
1960         {
1961           err = gpg_error (GPG_ERR_CANCELED);
1962           goto leave;
1963         }
1964
1965
1966       if (is_yubikey)
1967         {
1968           /* The PIV application si already selected, we only need to
1969            * send the special reset APDU after having blocked PIN and
1970            * PUK.  Note that blocking the PUK is done using the
1971            * unblock PIN command.  */
1972           any_apdu = 1;
1973           for (i=0; i < 5; i++)
1974             send_apdu ("0020008008FFFFFFFFFFFFFFFF", "VERIFY", 0xffff);
1975           for (i=0; i < 5; i++)
1976             send_apdu ("002C008010FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",
1977                        "RESET RETRY COUNTER", 0xffff);
1978           err = send_apdu ("00FB000001FF", "YUBIKEY RESET", 0);
1979           if (err)
1980             goto leave;
1981         }
1982       else /* OpenPGP card.  */
1983         {
1984           any_apdu = 1;
1985           /* We need to select a card application before we can send APDUs
1986            * to the card without scdaemon doing anything on its own.  */
1987           err = send_apdu (NULL, "RESET", 0);
1988           if (err)
1989             goto leave;
1990           err = send_apdu ("undefined", "dummy select ", 0);
1991           if (err)
1992             goto leave;
1993           /* Select the OpenPGP application.  */
1994           err = send_apdu ("00A4040006D27600012401", "SELECT AID", 0);
1995           if (err)
1996             goto leave;
1997
1998           /* Do some dummy verifies with wrong PINs to set the retry
1999            * counter to zero.  We can't easily use the card version 2.1
2000            * feature of presenting the admin PIN to allow the terminate
2001            * command because there is no machinery in scdaemon to catch
2002            * the verify command and ask for the PIN when the "APDU"
2003            * command is used.
2004            * Here, the length of dummy wrong PIN is 32-byte, also
2005            * supporting authentication with KDF DO.  */
2006           for (i=0; i < 4; i++)
2007             send_apdu ("0020008120"
2008                        "40404040404040404040404040404040"
2009                        "40404040404040404040404040404040", "VERIFY", 0xffff);
2010           for (i=0; i < 4; i++)
2011             send_apdu ("0020008320"
2012                        "40404040404040404040404040404040"
2013                        "40404040404040404040404040404040", "VERIFY", 0xffff);
2014
2015           /* Send terminate datafile command.  */
2016           err = send_apdu ("00e60000", "TERMINATE DF", 0x6985);
2017           if (err)
2018             goto leave;
2019         }
2020     }
2021
2022   if (!is_yubikey)
2023     {
2024       any_apdu = 1;
2025       /* Send activate datafile command.  This is used without
2026        * confirmation if the card is already in termination state.  */
2027       err = send_apdu ("00440000", "ACTIVATE DF", 0);
2028       if (err)
2029         goto leave;
2030     }
2031
2032   /* Finally we reset the card reader once more.  */
2033   err = send_apdu (NULL, "RESET", 0);
2034   if (err)
2035     goto leave;
2036
2037   /* Then, connect the card again (answer used as a dummy).  */
2038   xfree (answer); answer = NULL;
2039   err = scd_serialno (&answer, NULL);
2040
2041  leave:
2042   if (err && any_apdu && !is_yubikey)
2043     {
2044       log_info ("Due to an error the card might be in an inconsistent state\n"
2045                 "You should run the LIST command to check this.\n");
2046       /* FIXME: We need a better solution in the case that the card is
2047        * in a termination state, i.e. the card was removed before the
2048        * activate was sent.  The best solution I found with v2.1
2049        * Zeitcontrol card was to kill scdaemon and the issue this
2050        * sequence with gpg-connect-agent:
2051        *   scd reset
2052        *   scd serialno undefined
2053        *   scd apdu 00A4040006D27600012401 (returns error)
2054        *   scd apdu 00440000
2055        * Then kill scdaemon again and issue:
2056        *   scd reset
2057        *   scd serialno openpgp
2058        */
2059     }
2060   xfree (answer);
2061   return err;
2062 }
2063
2064
2065 /* Generate KDF data.  This is a helper for cmd_kdfsetup.  */
2066 static gpg_error_t
2067 gen_kdf_data (unsigned char *data, int single_salt)
2068 {
2069   gpg_error_t err;
2070   const unsigned char h0[] = { 0x81, 0x01, 0x03,
2071                                0x82, 0x01, 0x08,
2072                                0x83, 0x04 };
2073   const unsigned char h1[] = { 0x84, 0x08 };
2074   const unsigned char h2[] = { 0x85, 0x08 };
2075   const unsigned char h3[] = { 0x86, 0x08 };
2076   const unsigned char h4[] = { 0x87, 0x20 };
2077   const unsigned char h5[] = { 0x88, 0x20 };
2078   unsigned char *p, *salt_user, *salt_admin;
2079   unsigned char s2k_char;
2080   unsigned int iterations;
2081   unsigned char count_4byte[4];
2082
2083   p = data;
2084
2085   s2k_char = encode_s2k_iterations (agent_get_s2k_count ());
2086   iterations = S2K_DECODE_COUNT (s2k_char);
2087   count_4byte[0] = (iterations >> 24) & 0xff;
2088   count_4byte[1] = (iterations >> 16) & 0xff;
2089   count_4byte[2] = (iterations >>  8) & 0xff;
2090   count_4byte[3] = (iterations & 0xff);
2091
2092   memcpy (p, h0, sizeof h0);
2093   p += sizeof h0;
2094   memcpy (p, count_4byte, sizeof count_4byte);
2095   p += sizeof count_4byte;
2096   memcpy (p, h1, sizeof h1);
2097   salt_user = (p += sizeof h1);
2098   gcry_randomize (p, 8, GCRY_STRONG_RANDOM);
2099   p += 8;
2100
2101   if (single_salt)
2102     salt_admin = salt_user;
2103   else
2104     {
2105       memcpy (p, h2, sizeof h2);
2106       p += sizeof h2;
2107       gcry_randomize (p, 8, GCRY_STRONG_RANDOM);
2108       p += 8;
2109       memcpy (p, h3, sizeof h3);
2110       salt_admin = (p += sizeof h3);
2111       gcry_randomize (p, 8, GCRY_STRONG_RANDOM);
2112       p += 8;
2113     }
2114
2115   memcpy (p, h4, sizeof h4);
2116   p += sizeof h4;
2117   err = gcry_kdf_derive (OPENPGP_USER_PIN_DEFAULT,
2118                          strlen (OPENPGP_USER_PIN_DEFAULT),
2119                          GCRY_KDF_ITERSALTED_S2K, GCRY_MD_SHA256,
2120                          salt_user, 8, iterations, 32, p);
2121   p += 32;
2122   if (!err)
2123     {
2124       memcpy (p, h5, sizeof h5);
2125       p += sizeof h5;
2126       err = gcry_kdf_derive (OPENPGP_ADMIN_PIN_DEFAULT,
2127                              strlen (OPENPGP_ADMIN_PIN_DEFAULT),
2128                              GCRY_KDF_ITERSALTED_S2K, GCRY_MD_SHA256,
2129                              salt_admin, 8, iterations, 32, p);
2130     }
2131
2132   return err;
2133 }
2134
2135
2136 static gpg_error_t
2137 cmd_kdfsetup (card_info_t info, char *argstr)
2138 {
2139   gpg_error_t err;
2140   unsigned char kdf_data[OPENPGP_KDF_DATA_LENGTH_MAX];
2141   int single = (*argstr != 0);
2142
2143   if (!info)
2144     return print_help
2145       ("KDF-SETUP\n\n"
2146        "Prepare the OpenPGP card KDF feature for this card.",
2147        APP_TYPE_OPENPGP, 0);
2148
2149   if (info->apptype != APP_TYPE_OPENPGP)
2150     {
2151       log_info ("Note: This is an OpenPGP only command.\n");
2152       return gpg_error (GPG_ERR_NOT_SUPPORTED);
2153     }
2154
2155   if (!info->extcap.kdf)
2156     {
2157       log_error (_("This command is not supported by this card\n"));
2158       err = gpg_error (GPG_ERR_NOT_SUPPORTED);
2159       goto leave;
2160     }
2161
2162   err = gen_kdf_data (kdf_data, single);
2163   if (err)
2164     goto leave;
2165
2166   err = scd_setattr ("KDF", kdf_data,
2167                      single ? OPENPGP_KDF_DATA_LENGTH_MIN
2168                      /* */  : OPENPGP_KDF_DATA_LENGTH_MAX);
2169   if (err)
2170     goto leave;
2171
2172   err = scd_getattr ("KDF", info);
2173
2174  leave:
2175   return err;
2176 }
2177
2178
2179 \f
2180 static void
2181 show_keysize_warning (void)
2182 {
2183   static int shown;
2184
2185   if (shown)
2186     return;
2187   shown = 1;
2188   tty_printf
2189     (_("Note: There is no guarantee that the card supports the requested\n"
2190        "      key type or size.  If the key generation does not succeed,\n"
2191        "      please check the documentation of your card to see which\n"
2192        "      key types and sizes are supported.\n")
2193      );
2194 }
2195
2196
2197 /* Ask for the size of a card key.  NBITS is the current size
2198  * configured for the card.  Returns 0 on success and stored the
2199  * chosen key size at R_KEYSIZE; 0 is stored to indicate that the
2200  * default size shall be used.  */
2201 static gpg_error_t
2202 ask_card_rsa_keysize (unsigned int nbits, unsigned int *r_keysize)
2203 {
2204   unsigned int min_nbits = 1024;
2205   unsigned int max_nbits = 4096;
2206   char*answer;
2207   unsigned int req_nbits;
2208
2209   for (;;)
2210     {
2211       answer = tty_getf (_("What keysize do you want? (%u) "), nbits);
2212       trim_spaces (answer);
2213       tty_kill_prompt ();
2214       if (*answer == CONTROL_D)
2215         {
2216           xfree (answer);
2217           return gpg_error (GPG_ERR_CANCELED);
2218         }
2219       req_nbits = *answer? atoi (answer): nbits;
2220       xfree (answer);
2221
2222       if (req_nbits != nbits && (req_nbits % 32) )
2223         {
2224           req_nbits = ((req_nbits + 31) / 32) * 32;
2225           tty_printf (_("rounded up to %u bits\n"), req_nbits);
2226         }
2227
2228       if (req_nbits == nbits)
2229         {
2230           /* Use default.  */
2231           *r_keysize = 0;
2232           return 0;
2233         }
2234
2235       if (req_nbits < min_nbits || req_nbits > max_nbits)
2236         {
2237           tty_printf (_("%s keysizes must be in the range %u-%u\n"),
2238                       "RSA", min_nbits, max_nbits);
2239         }
2240       else
2241         {
2242           *r_keysize = req_nbits;
2243           return 0;
2244         }
2245     }
2246 }
2247
2248
2249 /* Ask for the key attribute of a card key.  CURRENT is the current
2250  * attribute configured for the card.  KEYNO is the number of the key
2251  * used to select the prompt.  Stores NULL at result to use the
2252  * default attribute or stores the selected attribute structure at
2253  * RESULT.  On error an error code is returned.  */
2254 static gpg_error_t
2255 ask_card_keyattr (int keyno, const struct key_attr *current,
2256                   struct key_attr **result)
2257 {
2258   gpg_error_t err;
2259   struct key_attr *key_attr = NULL;
2260   char *answer = NULL;
2261   int selection;
2262
2263   *result = NULL;
2264
2265   key_attr = xcalloc (1, sizeof *key_attr);
2266
2267   tty_printf (_("Changing card key attribute for: "));
2268   if (keyno == 0)
2269     tty_printf (_("Signature key\n"));
2270   else if (keyno == 1)
2271     tty_printf (_("Encryption key\n"));
2272   else
2273     tty_printf (_("Authentication key\n"));
2274
2275   tty_printf (_("Please select what kind of key you want:\n"));
2276   tty_printf (_("   (%d) RSA\n"), 1 );
2277   tty_printf (_("   (%d) ECC\n"), 2 );
2278
2279   for (;;)
2280     {
2281       xfree (answer);
2282       answer = tty_get (_("Your selection? "));
2283       trim_spaces (answer);
2284       tty_kill_prompt ();
2285       if (!*answer || *answer == CONTROL_D)
2286         {
2287           err = gpg_error (GPG_ERR_CANCELED);
2288           goto leave;
2289         }
2290       selection = *answer? atoi (answer) : 0;
2291
2292       if (selection == 1 || selection == 2)
2293         break;
2294       else
2295         tty_printf (_("Invalid selection.\n"));
2296     }
2297
2298
2299   if (selection == 1)
2300     {
2301       unsigned int nbits, result_nbits;
2302
2303       if (current->algo == PUBKEY_ALGO_RSA)
2304         nbits = current->nbits;
2305       else
2306         nbits = 2048;
2307
2308       err = ask_card_rsa_keysize (nbits, &result_nbits);
2309       if (err)
2310         goto leave;
2311       if (result_nbits == 0)
2312         {
2313           if (current->algo == PUBKEY_ALGO_RSA)
2314             {
2315               xfree (key_attr);
2316               key_attr = NULL;
2317             }
2318           else
2319             result_nbits = nbits;
2320         }
2321
2322       if (key_attr)
2323         {
2324           key_attr->algo = PUBKEY_ALGO_RSA;
2325           key_attr->nbits = result_nbits;
2326         }
2327     }
2328   else if (selection == 2)
2329     {
2330       const char *curve;
2331       /* const char *oid_str; */
2332       int algo;
2333
2334       if (current->algo == PUBKEY_ALGO_RSA)
2335         {
2336           if (keyno == 1) /* Encryption key */
2337             algo = PUBKEY_ALGO_ECDH;
2338           else /* Signature key or Authentication key */
2339             algo = PUBKEY_ALGO_ECDSA;
2340           curve = NULL;
2341         }
2342       else
2343         {
2344           algo = current->algo;
2345           curve = current->curve;
2346         }
2347
2348       err = GPG_ERR_NOT_IMPLEMENTED;
2349       goto leave;
2350       /* FIXME: We need to mve the ask_cure code out to common or
2351        * provide another sultion.  */
2352       /* curve = ask_curve (&algo, NULL, curve); */
2353       /* if (curve) */
2354       /*   { */
2355       /*     key_attr->algo = algo; */
2356       /*     oid_str = openpgp_curve_to_oid (curve, NULL); */
2357       /*     key_attr->curve = openpgp_oid_to_curve (oid_str, 0); */
2358       /*   } */
2359       /* else */
2360       /*   { */
2361       /*     xfree (key_attr); */
2362       /*     key_attr = NULL; */
2363       /*   } */
2364     }
2365   else
2366     {
2367       err = gpg_error (GPG_ERR_BUG);
2368       goto leave;
2369     }
2370
2371   /* Tell the user what we are going to do.  */
2372   if (key_attr->algo == PUBKEY_ALGO_RSA)
2373     {
2374       tty_printf (_("The card will now be re-configured"
2375                     " to generate a key of %u bits\n"), key_attr->nbits);
2376     }
2377   else if (key_attr->algo == PUBKEY_ALGO_ECDH
2378            || key_attr->algo == PUBKEY_ALGO_ECDSA
2379            || key_attr->algo == PUBKEY_ALGO_EDDSA)
2380     {
2381       tty_printf (_("The card will now be re-configured"
2382                     " to generate a key of type: %s\n"), key_attr->curve);
2383     }
2384   show_keysize_warning ();
2385
2386   *result = key_attr;
2387   key_attr = NULL;
2388
2389  leave:
2390   xfree (key_attr);
2391   xfree (answer);
2392   return err;
2393 }
2394
2395
2396 /* Change the key attribute of key KEYNO (0..2) and show an error
2397  * message if that fails.  */
2398 static gpg_error_t
2399 do_change_keyattr (int keyno, const struct key_attr *key_attr)
2400 {
2401   gpg_error_t err = 0;
2402   char args[100];
2403
2404   if (key_attr->algo == PUBKEY_ALGO_RSA)
2405     snprintf (args, sizeof args, "--force %d 1 rsa%u", keyno+1,
2406               key_attr->nbits);
2407   else if (key_attr->algo == PUBKEY_ALGO_ECDH
2408            || key_attr->algo == PUBKEY_ALGO_ECDSA
2409            || key_attr->algo == PUBKEY_ALGO_EDDSA)
2410     snprintf (args, sizeof args, "--force %d %d %s",
2411               keyno+1, key_attr->algo, key_attr->curve);
2412   else
2413     {
2414       /* FIXME: Above we use opnepgp algo names but in the error
2415        * message we use the gcrypt names.  We should settle for a
2416        * consistent solution. */
2417       log_error (_("public key algorithm %d (%s) is not supported\n"),
2418                  key_attr->algo, gcry_pk_algo_name (key_attr->algo));
2419       err = gpg_error (GPG_ERR_PUBKEY_ALGO);
2420       goto leave;
2421     }
2422
2423   err = scd_setattr ("KEY-ATTR", args, strlen (args));
2424   if (err)
2425     log_error (_("error changing key attribute for key %d: %s\n"),
2426                keyno+1, gpg_strerror (err));
2427  leave:
2428   return err;
2429 }
2430
2431
2432 static gpg_error_t
2433 cmd_keyattr (card_info_t info, char *argstr)
2434 {
2435   gpg_error_t err = 0;
2436   int keyno;
2437   struct key_attr *key_attr = NULL;
2438
2439   (void)argstr;
2440
2441   if (!info)
2442     return print_help
2443       ("KEY-ATTR\n\n"
2444        "Menu to change the key attributes of an OpenPGP card.",
2445        APP_TYPE_OPENPGP, 0);
2446
2447   if (info->apptype != APP_TYPE_OPENPGP)
2448     {
2449       log_info ("Note: This is an OpenPGP only command.\n");
2450       return gpg_error (GPG_ERR_NOT_SUPPORTED);
2451     }
2452
2453   if (!(info->is_v2 && info->extcap.aac))
2454     {
2455       log_error (_("This command is not supported by this card\n"));
2456       err = gpg_error (GPG_ERR_NOT_SUPPORTED);
2457       goto leave;
2458     }
2459
2460   for (keyno = 0; keyno < DIM (info->key_attr); keyno++)
2461     {
2462       xfree (key_attr);
2463       key_attr = NULL;
2464       err = ask_card_keyattr (keyno, &info->key_attr[keyno], &key_attr);
2465       if (err)
2466         goto leave;
2467
2468       err = do_change_keyattr (keyno, key_attr);
2469       if (err)
2470         {
2471           /* Error: Better read the default key attribute again.  */
2472           log_debug ("FIXME\n");
2473           /* Ask again for this key. */
2474           keyno--;
2475         }
2476     }
2477
2478  leave:
2479   xfree (key_attr);
2480   return err;
2481 }
2482
2483
2484 static gpg_error_t
2485 cmd_uif (card_info_t info, char *argstr)
2486 {
2487   gpg_error_t err;
2488   int keyno;
2489
2490   if (!info)
2491     return print_help
2492       ("UIF N [on|off|permanent]\n\n"
2493        "Change the User Interaction Flag.  N must in the range 1 to 3.",
2494        APP_TYPE_OPENPGP, APP_TYPE_PIV, 0);
2495
2496   argstr = skip_options (argstr);
2497
2498   if (digitp (argstr))
2499     {
2500       keyno = atoi (argstr);
2501       while (digitp (argstr))
2502         argstr++;
2503       while (spacep (argstr))
2504         argstr++;
2505     }
2506   else
2507     keyno = 0;
2508
2509   if (keyno < 1 || keyno > 3)
2510     {
2511       err = gpg_error (GPG_ERR_INV_ARG);
2512       goto leave;
2513     }
2514
2515
2516   err = GPG_ERR_NOT_IMPLEMENTED;
2517
2518  leave:
2519   return err;
2520 }
2521
2522
2523 \f
2524 /* Data used by the command parser.  This needs to be outside of the
2525  * function scope to allow readline based command completion.  */
2526 enum cmdids
2527   {
2528     cmdNOP = 0,
2529     cmdQUIT, cmdADMIN, cmdHELP, cmdLIST, cmdRESET, cmdVERIFY,
2530     cmdNAME, cmdURL, cmdFETCH, cmdLOGIN, cmdLANG, cmdSALUT, cmdCAFPR,
2531     cmdFORCESIG, cmdGENERATE, cmdPASSWD, cmdPRIVATEDO, cmdWRITECERT,
2532     cmdREADCERT, cmdUNBLOCK, cmdFACTORYRESET, cmdKDFSETUP,
2533     cmdKEYATTR, cmdUIF,
2534     cmdINVCMD
2535   };
2536
2537 static struct
2538 {
2539   const char *name;
2540   enum cmdids id;
2541   int admin_only;
2542   const char *desc;
2543 } cmds[] = {
2544   { "quit"    , cmdQUIT  , 0, N_("quit this menu")},
2545   { "q"       , cmdQUIT  , 0, NULL },
2546   { "admin"   , cmdADMIN , 0, N_("show admin commands")},
2547   { "help"    , cmdHELP  , 0, N_("show this help")},
2548   { "?"       , cmdHELP  , 0, NULL },
2549   { "list"    , cmdLIST  , 0, N_("list all available data")},
2550   { "l"       , cmdLIST  , 0, NULL },
2551   { "name"    , cmdNAME  , 1, N_("change card holder's name")},
2552   { "url"     , cmdURL   , 1, N_("change URL to retrieve key")},
2553   { "fetch"   , cmdFETCH , 0, N_("fetch the key specified in the card URL")},
2554   { "login"   , cmdLOGIN , 1, N_("change the login name")},
2555   { "lang"    , cmdLANG  , 1, N_("change the language preferences")},
2556   { "salutation",cmdSALUT, 1, N_("change card holder's salutation")},
2557   { "salut"   , cmdSALUT,  1, NULL },
2558   { "cafpr"   , cmdCAFPR , 1, N_("change a CA fingerprint")},
2559   { "forcesig", cmdFORCESIG, 1, N_("toggle the signature force PIN flag")},
2560   { "generate", cmdGENERATE, 1, N_("generate new keys")},
2561   { "passwd"  , cmdPASSWD, 0, N_("menu to change or unblock the PIN")},
2562   { "verify"  , cmdVERIFY, 0, N_("verify the PIN and list all data")},
2563   { "unblock" , cmdUNBLOCK,0, N_("unblock the PIN using a Reset Code")},
2564   { "factory-reset", cmdFACTORYRESET, 1, N_("destroy all keys and data")},
2565   { "kdf-setup", cmdKDFSETUP, 1, N_("setup KDF for PIN authentication")},
2566   { "key-attr", cmdKEYATTR, 1, N_("change the key attribute")},
2567   { "uif", cmdUIF, 1, N_("change the User Interaction Flag")},
2568   /* Note, that we do not announce these command yet. */
2569   { "privatedo", cmdPRIVATEDO, 0, N_("change a private data object")},
2570   { "readcert",  cmdREADCERT,  0, N_("read a certificate from a data object")},
2571   { "writecert", cmdWRITECERT, 1, N_("store a certificate to a data object")},
2572   { NULL, cmdINVCMD, 0, NULL }
2573 };
2574
2575
2576 /* The main loop.  */
2577 static void
2578 interactive_loop (void)
2579 {
2580   gpg_error_t err;
2581   char *answer = NULL;         /* The input line.  */
2582   enum cmdids cmd = cmdNOP;    /* The command.  */
2583   int cmd_admin_only;          /* The command is an admin only command.  */
2584   char *argstr;                /* The argument as a string.  */
2585   int redisplay = 1;           /* Whether to redisplay the main info.  */
2586   int allow_admin = 0;         /* Whether admin commands are allowed.  */
2587   char *help_arg = NULL;       /* Argument of the HELP command.         */
2588   struct card_info_s info_buffer;
2589   card_info_t info = &info_buffer;
2590   char *p;
2591   int i;
2592
2593   /* In the interactive mode we do not want to print the program prefix.  */
2594   log_set_prefix (NULL, 0);
2595
2596   for (;;)
2597     {
2598       if (help_arg)
2599         {
2600           /* Clear info to indicate helpmode */
2601           info = NULL;
2602         }
2603       else if (!info)
2604         {
2605           /* Get out of help.  */
2606           info = &info_buffer;
2607           help_arg = NULL;
2608           redisplay = 0;
2609         }
2610       else if (redisplay)
2611         {
2612           err = scd_learn (info);
2613           if (err)
2614             {
2615               log_error ("Error reading card: %s\n", gpg_strerror (err));
2616             }
2617           else
2618             {
2619               list_card (info);
2620               tty_printf("\n");
2621               redisplay = 0;
2622             }
2623         }
2624
2625       if (!info)
2626         {
2627           /* Copy the pending help arg into our answer.  Noe that
2628            * help_arg points into answer.  */
2629           p = xstrdup (help_arg);
2630           help_arg = NULL;
2631           xfree (answer);
2632           answer = p;
2633         }
2634       else
2635         {
2636           do
2637             {
2638               xfree (answer);
2639               tty_enable_completion (command_completion);
2640               answer = tty_get (_("gpg/card> "));
2641               tty_kill_prompt();
2642               tty_disable_completion ();
2643               trim_spaces(answer);
2644             }
2645           while ( *answer == '#' );
2646         }
2647
2648       argstr = NULL;
2649       cmd_admin_only = 0;
2650       if (!*answer)
2651         cmd = cmdLIST; /* We default to the list command */
2652       else if (*answer == CONTROL_D)
2653         cmd = cmdQUIT;
2654       else
2655         {
2656           if ((argstr = strchr (answer,' ')))
2657             {
2658               *argstr++ = 0;
2659               trim_spaces (answer);
2660               trim_spaces (argstr);
2661             }
2662
2663           for (i=0; cmds[i].name; i++ )
2664             if (!ascii_strcasecmp (answer, cmds[i].name ))
2665               break;
2666
2667           cmd = cmds[i].id;
2668           cmd_admin_only = cmds[i].admin_only;
2669         }
2670
2671       /* Make sure we have valid strings for the args.  They are
2672        * allowed to be modifed and must thus point to a buffer.  */
2673       if (!argstr)
2674         argstr = answer + strlen (answer);
2675
2676       if (!(cmd == cmdNOP || cmd == cmdQUIT || cmd == cmdHELP))
2677         {
2678           /* If redisplay is set we know that there was an error reading
2679            * the card.  In this case we force a LIST command to retry.  */
2680           if (!info)
2681             ; /* In help mode.  */
2682           else if (redisplay)
2683             {
2684               cmd = cmdLIST;
2685               cmd_admin_only = 0;
2686             }
2687           else if (!info->serialno)
2688             {
2689               /* Without a serial number most commands won't work.
2690                * Catch it here.  */
2691               tty_printf ("\n");
2692               tty_printf ("Serial number missing\n");
2693               continue;
2694             }
2695           else if (!allow_admin && cmd_admin_only)
2696             {
2697               tty_printf ("\n");
2698               tty_printf (_("Admin-only command\n"));
2699               continue;
2700             }
2701         }
2702
2703       err = 0;
2704       switch (cmd)
2705         {
2706         case cmdNOP:
2707           if (!info)
2708             print_help ("NOP\n\n"
2709                         "Dummy command.", 0);
2710           break;
2711
2712         case cmdQUIT:
2713           if (!info)
2714             print_help ("QUIT\n\n"
2715                         "Leave this tool.", 0);
2716           else
2717             {
2718               tty_printf ("\n");
2719               goto leave;
2720             }
2721           break;
2722
2723         case cmdHELP:
2724           if (!info)
2725             print_help ("HELP [command]\n\n"
2726                         "Show all commands.  With an argument show help\n"
2727                         "for that command.", 0);
2728           else if (*argstr)
2729             help_arg = argstr; /* Trigger help for a command.  */
2730           else
2731             {
2732               tty_printf
2733                 ("List of commands (\"help <command>\" for details):\n");
2734               for (i=0; cmds[i].name; i++ )
2735                 if(cmds[i].desc
2736                    && (!cmds[i].admin_only
2737                        || (cmds[i].admin_only && allow_admin)))
2738                   tty_printf("%-14s %s\n", cmds[i].name, _(cmds[i].desc) );
2739             }
2740           break;
2741
2742         case cmdLIST:
2743           if (!info)
2744             print_help ("LIST\n\n"
2745                         "Show content of the card.", 0);
2746           else
2747             {
2748               /* Actual work is done by the redisplay code block.  */
2749               redisplay = 1;
2750             }
2751           break;
2752
2753         case cmdRESET:
2754           if (!info)
2755             print_help ("RESET\n\n"
2756                         "Send a RESET to the card daemon.", 0);
2757           else
2758             {
2759               err = scd_apdu (NULL, NULL);
2760             }
2761           break;
2762
2763         case cmdADMIN:
2764           if ( !strcmp (argstr, "on") )
2765             allow_admin = 1;
2766           else if ( !strcmp (argstr, "off") )
2767             allow_admin = 0;
2768           else if ( !strcmp (argstr, "verify") )
2769             {
2770               /* Force verification of the Admin Command.  However,
2771                  this is only done if the retry counter is at initial
2772                  state.  */
2773               /* FIXME: Must depend on the type of the card.  */
2774               /* char *tmp = xmalloc (strlen (serialnobuf) + 6 + 1); */
2775               /* strcpy (stpcpy (tmp, serialnobuf), "[CHV3]"); */
2776               /* allow_admin = !agent_scd_checkpin (tmp); */
2777               /* xfree (tmp); */
2778             }
2779           else /* Toggle. */
2780             allow_admin=!allow_admin;
2781           if(allow_admin)
2782             tty_printf(_("Admin commands are allowed\n"));
2783           else
2784             tty_printf(_("Admin commands are not allowed\n"));
2785           break;
2786
2787         case cmdVERIFY:
2788           err = cmd_verify (info, argstr);
2789           if (!err)
2790             redisplay = 1;
2791           break;
2792         case cmdNAME:      err = cmd_name (info, argstr); break;
2793         case cmdURL:       err = cmd_url (info, argstr);  break;
2794         case cmdFETCH:     err = cmd_fetch (info);  break;
2795         case cmdLOGIN:     err = cmd_login (info, argstr); break;
2796         case cmdLANG:      err = cmd_lang (info, argstr); break;
2797         case cmdSALUT:     err = cmd_salut (info, argstr); break;
2798         case cmdCAFPR:     err = cmd_cafpr (info, argstr); break;
2799         case cmdPRIVATEDO: err = cmd_privatedo (info, argstr); break;
2800         case cmdWRITECERT: err = cmd_writecert (info, argstr); break;
2801         case cmdREADCERT:  err = cmd_readcert (info, argstr); break;
2802         case cmdFORCESIG:  err = cmd_forcesig (info); break;
2803         case cmdGENERATE:  err = cmd_generate (info); break;
2804         case cmdPASSWD:    err = cmd_passwd (info, allow_admin); break;
2805         case cmdUNBLOCK:   err = cmd_unblock (info); break;
2806         case cmdFACTORYRESET:
2807           err = cmd_factoryreset (info);
2808           if (!err)
2809             redisplay = 1;
2810           break;
2811         case cmdKDFSETUP:  err = cmd_kdfsetup (info, argstr); break;
2812         case cmdKEYATTR:   err = cmd_keyattr (info, argstr); break;
2813         case cmdUIF:       err = cmd_uif (info, argstr); break;
2814
2815         case cmdINVCMD:
2816         default:
2817           tty_printf ("\n");
2818           tty_printf (_("Invalid command  (try \"help\")\n"));
2819           break;
2820         } /* End command switch. */
2821
2822       if (gpg_err_code (err) == GPG_ERR_CANCELED)
2823         tty_fprintf (NULL, "\n");
2824       else if (err)
2825         {
2826           const char *s = "?";
2827           for (i=0; cmds[i].name; i++ )
2828             if (cmd == cmds[i].id)
2829               {
2830                 s = cmds[i].name;
2831                 break;
2832               }
2833           log_error ("Command '%s' failed: %s\n", s, gpg_strerror (err));
2834         }
2835
2836     } /* End of main menu loop. */
2837
2838  leave:
2839   release_card_info (info);
2840   xfree (answer);
2841 }
2842
2843 #ifdef HAVE_LIBREADLINE
2844 /* Helper function for readline's command completion. */
2845 static char *
2846 command_generator (const char *text, int state)
2847 {
2848   static int list_index, len;
2849   const char *name;
2850
2851   /* If this is a new word to complete, initialize now.  This includes
2852    * saving the length of TEXT for efficiency, and initializing the
2853    index variable to 0. */
2854   if (!state)
2855     {
2856       list_index = 0;
2857       len = strlen(text);
2858     }
2859
2860   /* Return the next partial match */
2861   while ((name = cmds[list_index].name))
2862     {
2863       /* Only complete commands that have help text. */
2864       if (cmds[list_index++].desc && !strncmp (name, text, len))
2865         return strdup(name);
2866     }
2867
2868   return NULL;
2869 }
2870
2871 /* Second helper function for readline's command completion.  */
2872 static char **
2873 command_completion (const char *text, int start, int end)
2874 {
2875   (void)end;
2876
2877   /* If we are at the start of a line, we try and command-complete.
2878    * If not, just do nothing for now. */
2879   if (!start)
2880     return rl_completion_matches (text, command_generator);
2881
2882   rl_attempted_completion_over = 1;
2883
2884   return NULL;
2885 }
2886 #endif /*HAVE_LIBREADLINE*/