Merge branch 'STABLE-BRANCH-2-2'
[gnupg.git] / g10 / card-util.c
1 /* card-util.c - Utility functions for the OpenPGP card.
2  * Copyright (C) 2003-2005, 2009 Free Software Foundation, Inc.
3  * Copyright (C) 2003-2005, 2009 Werner Koch
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <https://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26 #ifdef HAVE_LIBREADLINE
27 # define GNUPG_LIBREADLINE_H_INCLUDED
28 # include <readline/readline.h>
29 #endif /*HAVE_LIBREADLINE*/
30
31 #if GNUPG_MAJOR_VERSION != 1
32 # include "gpg.h"
33 #endif /*GNUPG_MAJOR_VERSION != 1*/
34 #include "../common/util.h"
35 #include "../common/i18n.h"
36 #include "../common/ttyio.h"
37 #include "../common/status.h"
38 #include "options.h"
39 #include "main.h"
40 #include "keyserver-internal.h"
41
42 #if GNUPG_MAJOR_VERSION == 1
43 # include "cardglue.h"
44 #else /*GNUPG_MAJOR_VERSION!=1*/
45 # include "call-agent.h"
46 #endif /*GNUPG_MAJOR_VERSION!=1*/
47
48 #define CONTROL_D ('D' - 'A' + 1)
49
50
51 static void
52 write_sc_op_status (gpg_error_t err)
53 {
54   switch (gpg_err_code (err))
55     {
56     case 0:
57       write_status (STATUS_SC_OP_SUCCESS);
58       break;
59 #if GNUPG_MAJOR_VERSION != 1
60     case GPG_ERR_CANCELED:
61     case GPG_ERR_FULLY_CANCELED:
62       write_status_text (STATUS_SC_OP_FAILURE, "1");
63       break;
64     case GPG_ERR_BAD_PIN:
65       write_status_text (STATUS_SC_OP_FAILURE, "2");
66       break;
67     default:
68       write_status (STATUS_SC_OP_FAILURE);
69       break;
70 #endif /* GNUPG_MAJOR_VERSION != 1 */
71     }
72 }
73
74
75 /* Change the PIN of an OpenPGP card.  This is an interactive
76    function. */
77 void
78 change_pin (int unblock_v2, int allow_admin)
79 {
80   struct agent_card_info_s info;
81   int rc;
82
83   rc = agent_scd_learn (&info, 0);
84   if (rc)
85     {
86       log_error (_("OpenPGP card not available: %s\n"),
87                   gpg_strerror (rc));
88       return;
89     }
90
91   log_info (_("OpenPGP card no. %s detected\n"),
92               info.serialno? info.serialno : "[none]");
93
94   agent_clear_pin_cache (info.serialno);
95
96   if (opt.batch)
97     {
98       agent_release_card_info (&info);
99       log_error (_("can't do this in batch mode\n"));
100       return;
101     }
102
103
104   if (unblock_v2)
105     {
106       if (!info.is_v2)
107         log_error (_("This command is only available for version 2 cards\n"));
108       else if (!info.chvretry[1])
109         log_error (_("Reset Code not or not anymore available\n"));
110       else
111         {
112           rc = agent_scd_change_pin (2, info.serialno);
113           write_sc_op_status (rc);
114           if (rc)
115             tty_printf ("Error changing the PIN: %s\n", gpg_strerror (rc));
116           else
117             tty_printf ("PIN changed.\n");
118         }
119     }
120   else if (!allow_admin)
121     {
122       rc = agent_scd_change_pin (1, info.serialno);
123       write_sc_op_status (rc);
124       if (rc)
125         tty_printf ("Error changing the PIN: %s\n", gpg_strerror (rc));
126       else
127         tty_printf ("PIN changed.\n");
128     }
129   else
130     for (;;)
131       {
132         char *answer;
133
134         tty_printf ("\n");
135         tty_printf ("1 - change PIN\n"
136                     "2 - unblock PIN\n"
137                     "3 - change Admin PIN\n"
138                     "4 - set the Reset Code\n"
139                     "Q - quit\n");
140         tty_printf ("\n");
141
142         answer = cpr_get("cardutil.change_pin.menu",_("Your selection? "));
143         cpr_kill_prompt();
144         if (strlen (answer) != 1)
145           continue;
146
147         if (*answer == '1')
148           {
149             /* Change PIN.  */
150             rc = agent_scd_change_pin (1, info.serialno);
151             write_sc_op_status (rc);
152             if (rc)
153               tty_printf ("Error changing the PIN: %s\n", gpg_strerror (rc));
154             else
155               tty_printf ("PIN changed.\n");
156           }
157         else if (*answer == '2')
158           {
159             /* Unblock PIN.  */
160             rc = agent_scd_change_pin (101, info.serialno);
161             write_sc_op_status (rc);
162             if (rc)
163               tty_printf ("Error unblocking the PIN: %s\n", gpg_strerror (rc));
164             else
165               tty_printf ("PIN unblocked and new PIN set.\n");
166           }
167         else if (*answer == '3')
168           {
169             /* Change Admin PIN.  */
170             rc = agent_scd_change_pin (3, info.serialno);
171             write_sc_op_status (rc);
172             if (rc)
173               tty_printf ("Error changing the PIN: %s\n", gpg_strerror (rc));
174             else
175               tty_printf ("PIN changed.\n");
176           }
177         else if (*answer == '4')
178           {
179             /* Set a new Reset Code.  */
180             rc = agent_scd_change_pin (102, info.serialno);
181             write_sc_op_status (rc);
182             if (rc)
183               tty_printf ("Error setting the Reset Code: %s\n",
184                           gpg_strerror (rc));
185             else
186               tty_printf ("Reset Code set.\n");
187           }
188         else if (*answer == 'q' || *answer == 'Q')
189           {
190             break;
191           }
192       }
193
194   agent_release_card_info (&info);
195 }
196
197 static const char *
198 get_manufacturer (unsigned int no)
199 {
200   /* Note:  Make sure that there is no colon or linefeed in the string. */
201   switch (no)
202     {
203     case 0x0001: return "PPC Card Systems";
204     case 0x0002: return "Prism";
205     case 0x0003: return "OpenFortress";
206     case 0x0004: return "Wewid";
207     case 0x0005: return "ZeitControl";
208     case 0x0006: return "Yubico";
209     case 0x0007: return "OpenKMS";
210     case 0x0008: return "LogoEmail";
211     case 0x0009: return "Fidesmo";
212     case 0x000A: return "Dangerous Things";
213
214     case 0x002A: return "Magrathea";
215     case 0x0042: return "GnuPG e.V.";
216
217     case 0x1337: return "Warsaw Hackerspace";
218     case 0x2342: return "warpzone"; /* hackerspace Muenster.  */
219     case 0xBD0E: return "Paranoidlabs";
220     case 0xF517: return "FSIJ";
221
222       /* 0x0000 and 0xFFFF are defined as test cards per spec,
223          0xFF00 to 0xFFFE are assigned for use with randomly created
224          serial numbers.  */
225     case 0x0000:
226     case 0xffff: return "test card";
227     default: return (no & 0xff00) == 0xff00? "unmanaged S/N range":"unknown";
228     }
229 }
230
231
232 static void
233 print_sha1_fpr (estream_t fp, const unsigned char *fpr)
234 {
235   int i;
236
237   if (fpr)
238     {
239       for (i=0; i < 20 ; i+=2, fpr += 2 )
240         {
241           if (i == 10 )
242             tty_fprintf (fp, " ");
243           tty_fprintf (fp, " %02X%02X", *fpr, fpr[1]);
244         }
245     }
246   else
247     tty_fprintf (fp, " [none]");
248   tty_fprintf (fp, "\n");
249 }
250
251
252 static void
253 print_sha1_fpr_colon (estream_t fp, const unsigned char *fpr)
254 {
255   int i;
256
257   if (fpr)
258     {
259       for (i=0; i < 20 ; i++, fpr++)
260         es_fprintf (fp, "%02X", *fpr);
261     }
262   es_putc (':', fp);
263 }
264
265
266 static void
267 print_name (estream_t fp, const char *text, const char *name)
268 {
269   tty_fprintf (fp, "%s", text);
270
271   /* FIXME: tty_printf_utf8_string2 eats everything after and
272      including an @ - e.g. when printing an url. */
273   if (name && *name)
274     {
275       if (fp)
276         print_utf8_buffer2 (fp, name, strlen (name), '\n');
277       else
278         tty_print_utf8_string2 (NULL, name, strlen (name), 0);
279     }
280   else
281     tty_fprintf (fp, _("[not set]"));
282   tty_fprintf (fp, "\n");
283 }
284
285 static void
286 print_isoname (estream_t fp, const char *text,
287                const char *tag, const char *name)
288 {
289   if (opt.with_colons)
290     es_fprintf (fp, "%s:", tag);
291   else
292     tty_fprintf (fp, "%s", text);
293
294   if (name && *name)
295     {
296       char *p, *given, *buf = xstrdup (name);
297
298       given = strstr (buf, "<<");
299       for (p=buf; *p; p++)
300         if (*p == '<')
301           *p = ' ';
302       if (given && given[2])
303         {
304           *given = 0;
305           given += 2;
306           if (opt.with_colons)
307             es_write_sanitized (fp, given, strlen (given), ":", NULL);
308           else if (fp)
309             print_utf8_buffer2 (fp, given, strlen (given), '\n');
310           else
311             tty_print_utf8_string2 (NULL, given, strlen (given), 0);
312
313           if (opt.with_colons)
314             es_putc (':', fp);
315           else if (*buf)
316             tty_fprintf (fp, " ");
317         }
318
319       if (opt.with_colons)
320         es_write_sanitized (fp, buf, strlen (buf), ":", NULL);
321       else if (fp)
322         print_utf8_buffer2 (fp, buf, strlen (buf), '\n');
323       else
324         tty_print_utf8_string2 (NULL, buf, strlen (buf), 0);
325       xfree (buf);
326     }
327   else
328     {
329       if (opt.with_colons)
330         es_putc (':', fp);
331       else
332         tty_fprintf (fp, _("[not set]"));
333     }
334
335   if (opt.with_colons)
336     es_fputs (":\n", fp);
337   else
338     tty_fprintf (fp, "\n");
339 }
340
341 /* Return true if the SHA1 fingerprint FPR consists only of zeroes. */
342 static int
343 fpr_is_zero (const char *fpr)
344 {
345   int i;
346
347   for (i=0; i < 20 && !fpr[i]; i++)
348     ;
349   return (i == 20);
350 }
351
352
353 /* Return true if the SHA1 fingerprint FPR consists only of 0xFF. */
354 static int
355 fpr_is_ff (const char *fpr)
356 {
357   int i;
358
359   for (i=0; i < 20 && fpr[i] == '\xff'; i++)
360     ;
361   return (i == 20);
362 }
363
364
365 /* Print all available information about the current card. */
366 static void
367 current_card_status (ctrl_t ctrl, estream_t fp,
368                      char *serialno, size_t serialnobuflen)
369 {
370   struct agent_card_info_s info;
371   PKT_public_key *pk = xcalloc (1, sizeof *pk);
372   kbnode_t keyblock = NULL;
373   int rc;
374   unsigned int uval;
375   const unsigned char *thefpr;
376   int i;
377
378   if (serialno && serialnobuflen)
379     *serialno = 0;
380
381   rc = agent_scd_learn (&info, 0);
382   if (rc)
383     {
384       if (opt.with_colons)
385         es_fputs ("AID:::\n", fp);
386       log_error (_("OpenPGP card not available: %s\n"), gpg_strerror (rc));
387       xfree (pk);
388       return;
389     }
390
391   if (opt.with_colons)
392     es_fprintf (fp, "Reader:%s:", info.reader? info.reader : "");
393   else
394     tty_fprintf (fp, "Reader ...........: %s\n",
395                  info.reader? info.reader : "[none]");
396   if (opt.with_colons)
397     es_fprintf (fp, "AID:%s:", info.serialno? info.serialno : "");
398   else
399     tty_fprintf (fp, "Application ID ...: %s\n",
400                  info.serialno? info.serialno : "[none]");
401   if (!info.serialno || strncmp (info.serialno, "D27600012401", 12)
402       || strlen (info.serialno) != 32 )
403     {
404       if (info.apptype && !strcmp (info.apptype, "NKS"))
405         {
406           if (opt.with_colons)
407             es_fputs ("netkey-card:\n", fp);
408           log_info ("this is a NetKey card\n");
409         }
410       else if (info.apptype && !strcmp (info.apptype, "DINSIG"))
411         {
412           if (opt.with_colons)
413             es_fputs ("dinsig-card:\n", fp);
414           log_info ("this is a DINSIG compliant card\n");
415         }
416       else if (info.apptype && !strcmp (info.apptype, "P15"))
417         {
418           if (opt.with_colons)
419             es_fputs ("pkcs15-card:\n", fp);
420           log_info ("this is a PKCS#15 compliant card\n");
421         }
422       else if (info.apptype && !strcmp (info.apptype, "GELDKARTE"))
423         {
424           if (opt.with_colons)
425             es_fputs ("geldkarte-card:\n", fp);
426           log_info ("this is a Geldkarte compliant card\n");
427         }
428       else
429         {
430           if (opt.with_colons)
431             es_fputs ("unknown:\n", fp);
432         }
433       log_info ("not an OpenPGP card\n");
434       agent_release_card_info (&info);
435       xfree (pk);
436       return;
437     }
438
439   if (!serialno)
440     ;
441   else if (strlen (info.serialno)+1 > serialnobuflen)
442     log_error ("serial number longer than expected\n");
443   else
444     strcpy (serialno, info.serialno);
445
446   if (opt.with_colons)
447     es_fputs ("openpgp-card:\n", fp);
448
449
450   if (opt.with_colons)
451     {
452       es_fprintf (fp, "version:%.4s:\n", info.serialno+12);
453       uval = xtoi_2(info.serialno+16)*256 + xtoi_2 (info.serialno+18);
454       es_fprintf (fp, "vendor:%04x:%s:\n", uval, get_manufacturer (uval));
455       es_fprintf (fp, "serial:%.8s:\n", info.serialno+20);
456
457       print_isoname (fp, "Name of cardholder: ", "name", info.disp_name);
458
459       es_fputs ("lang:", fp);
460       if (info.disp_lang)
461         es_write_sanitized (fp, info.disp_lang, strlen (info.disp_lang),
462                             ":", NULL);
463       es_fputs (":\n", fp);
464
465       es_fprintf (fp, "sex:%c:\n", (info.disp_sex == 1? 'm':
466                                  info.disp_sex == 2? 'f' : 'u'));
467
468       es_fputs ("url:", fp);
469       if (info.pubkey_url)
470         es_write_sanitized (fp, info.pubkey_url, strlen (info.pubkey_url),
471                             ":", NULL);
472       es_fputs (":\n", fp);
473
474       es_fputs ("login:", fp);
475       if (info.login_data)
476         es_write_sanitized (fp, info.login_data, strlen (info.login_data),
477                             ":", NULL);
478       es_fputs (":\n", fp);
479
480       es_fprintf (fp, "forcepin:%d:::\n", !info.chv1_cached);
481       for (i=0; i < DIM (info.key_attr); i++)
482         if (info.key_attr[i].algo == PUBKEY_ALGO_RSA)
483           es_fprintf (fp, "keyattr:%d:%d:%u:\n", i+1,
484                       info.key_attr[i].algo, info.key_attr[i].nbits);
485         else if (info.key_attr[i].algo == PUBKEY_ALGO_ECDH
486                  || info.key_attr[i].algo == PUBKEY_ALGO_ECDSA
487                  || info.key_attr[i].algo == PUBKEY_ALGO_EDDSA)
488           es_fprintf (fp, "keyattr:%d:%d:%s:\n", i+1,
489                       info.key_attr[i].algo, info.key_attr[i].curve);
490       es_fprintf (fp, "maxpinlen:%d:%d:%d:\n",
491                   info.chvmaxlen[0], info.chvmaxlen[1], info.chvmaxlen[2]);
492       es_fprintf (fp, "pinretry:%d:%d:%d:\n",
493                   info.chvretry[0], info.chvretry[1], info.chvretry[2]);
494       es_fprintf (fp, "sigcount:%lu:::\n", info.sig_counter);
495
496       for (i=0; i < 4; i++)
497         {
498           if (info.private_do[i])
499             {
500               es_fprintf (fp, "private_do:%d:", i+1);
501               es_write_sanitized (fp, info.private_do[i],
502                                   strlen (info.private_do[i]), ":", NULL);
503               es_fputs (":\n", fp);
504             }
505         }
506
507       es_fputs ("cafpr:", fp);
508       print_sha1_fpr_colon (fp, info.cafpr1valid? info.cafpr1:NULL);
509       print_sha1_fpr_colon (fp, info.cafpr2valid? info.cafpr2:NULL);
510       print_sha1_fpr_colon (fp, info.cafpr3valid? info.cafpr3:NULL);
511       es_putc ('\n', fp);
512       es_fputs ("fpr:", fp);
513       print_sha1_fpr_colon (fp, info.fpr1valid? info.fpr1:NULL);
514       print_sha1_fpr_colon (fp, info.fpr2valid? info.fpr2:NULL);
515       print_sha1_fpr_colon (fp, info.fpr3valid? info.fpr3:NULL);
516       es_putc ('\n', fp);
517       es_fprintf (fp, "fprtime:%lu:%lu:%lu:\n",
518                (unsigned long)info.fpr1time, (unsigned long)info.fpr2time,
519                (unsigned long)info.fpr3time);
520     }
521   else
522     {
523       tty_fprintf (fp, "Version ..........: %.1s%c.%.1s%c\n",
524                    info.serialno[12] == '0'?"":info.serialno+12,
525                    info.serialno[13],
526                    info.serialno[14] == '0'?"":info.serialno+14,
527                    info.serialno[15]);
528       tty_fprintf (fp, "Manufacturer .....: %s\n",
529                    get_manufacturer (xtoi_2(info.serialno+16)*256
530                                      + xtoi_2 (info.serialno+18)));
531       tty_fprintf (fp, "Serial number ....: %.8s\n", info.serialno+20);
532
533       print_isoname (fp, "Name of cardholder: ", "name", info.disp_name);
534       print_name (fp, "Language prefs ...: ", info.disp_lang);
535       tty_fprintf (fp, "Salutation .......: %s\n",
536                    info.disp_sex == 1? _("Mr."):
537                    info.disp_sex == 2? _("Mrs.") : "");
538       print_name (fp, "URL of public key : ", info.pubkey_url);
539       print_name (fp, "Login data .......: ", info.login_data);
540       if (info.private_do[0])
541         print_name (fp, "Private DO 1 .....: ", info.private_do[0]);
542       if (info.private_do[1])
543         print_name (fp, "Private DO 2 .....: ", info.private_do[1]);
544       if (info.private_do[2])
545         print_name (fp, "Private DO 3 .....: ", info.private_do[2]);
546       if (info.private_do[3])
547         print_name (fp, "Private DO 4 .....: ", info.private_do[3]);
548       if (info.cafpr1valid)
549         {
550           tty_fprintf (fp, "CA fingerprint %d .:", 1);
551           print_sha1_fpr (fp, info.cafpr1);
552         }
553       if (info.cafpr2valid)
554         {
555           tty_fprintf (fp, "CA fingerprint %d .:", 2);
556           print_sha1_fpr (fp, info.cafpr2);
557         }
558       if (info.cafpr3valid)
559         {
560           tty_fprintf (fp, "CA fingerprint %d .:", 3);
561           print_sha1_fpr (fp, info.cafpr3);
562         }
563       tty_fprintf (fp,    "Signature PIN ....: %s\n",
564                    info.chv1_cached? _("not forced"): _("forced"));
565       if (info.key_attr[0].algo)
566         {
567           tty_fprintf (fp,    "Key attributes ...:");
568           for (i=0; i < DIM (info.key_attr); i++)
569             if (info.key_attr[i].algo == PUBKEY_ALGO_RSA)
570               tty_fprintf (fp, " rsa%u", info.key_attr[i].nbits);
571             else if (info.key_attr[i].algo == PUBKEY_ALGO_ECDH
572                      || info.key_attr[i].algo == PUBKEY_ALGO_ECDSA
573                      || info.key_attr[i].algo == PUBKEY_ALGO_EDDSA)
574               {
575                 const char *curve_for_print = "?";
576
577                 if (info.key_attr[i].curve)
578                   {
579                     const char *oid;
580                     oid = openpgp_curve_to_oid (info.key_attr[i].curve, NULL);
581                     if (oid)
582                       curve_for_print = openpgp_oid_to_curve (oid, 0);
583                   }
584                 tty_fprintf (fp, " %s", curve_for_print);
585               }
586           tty_fprintf (fp, "\n");
587         }
588       tty_fprintf (fp,    "Max. PIN lengths .: %d %d %d\n",
589                    info.chvmaxlen[0], info.chvmaxlen[1], info.chvmaxlen[2]);
590       tty_fprintf (fp,    "PIN retry counter : %d %d %d\n",
591                    info.chvretry[0], info.chvretry[1], info.chvretry[2]);
592       tty_fprintf (fp,    "Signature counter : %lu\n", info.sig_counter);
593       tty_fprintf (fp, "Signature key ....:");
594       print_sha1_fpr (fp, info.fpr1valid? info.fpr1:NULL);
595       if (info.fpr1valid && info.fpr1time)
596         tty_fprintf (fp, "      created ....: %s\n",
597                      isotimestamp (info.fpr1time));
598       tty_fprintf (fp, "Encryption key....:");
599       print_sha1_fpr (fp, info.fpr2valid? info.fpr2:NULL);
600       if (info.fpr2valid && info.fpr2time)
601         tty_fprintf (fp, "      created ....: %s\n",
602                      isotimestamp (info.fpr2time));
603       tty_fprintf (fp, "Authentication key:");
604       print_sha1_fpr (fp, info.fpr3valid? info.fpr3:NULL);
605       if (info.fpr3valid && info.fpr3time)
606         tty_fprintf (fp, "      created ....: %s\n",
607                      isotimestamp (info.fpr3time));
608       tty_fprintf (fp, "General key info..: ");
609
610       thefpr = (info.fpr1valid? info.fpr1 : info.fpr2valid? info.fpr2 :
611                 info.fpr3valid? info.fpr3 : NULL);
612       /* If the fingerprint is all 0xff, the key has no asssociated
613          OpenPGP certificate.  */
614       if ( thefpr && !fpr_is_ff (thefpr)
615            && !get_pubkey_byfprint (ctrl, pk, &keyblock, thefpr, 20))
616         {
617           print_pubkey_info (ctrl, fp, pk);
618           if (keyblock)
619             print_card_key_info (fp, keyblock);
620         }
621       else
622         tty_fprintf (fp, "[none]\n");
623     }
624
625   release_kbnode (keyblock);
626   free_public_key (pk);
627   agent_release_card_info (&info);
628 }
629
630
631 /* Print all available information for specific card with SERIALNO.
632    Print all available information for current card when SERIALNO is NULL.
633    Or print llfor all cards when SERIALNO is "all".  */
634 void
635 card_status (ctrl_t ctrl, estream_t fp, const char *serialno)
636 {
637   int err;
638   strlist_t card_list, sl;
639   char *serialno0;
640   int all_cards = 0;
641
642   if (serialno == NULL)
643     {
644       current_card_status (ctrl, fp, NULL, 0);
645       return;
646     }
647
648   if (!strcmp (serialno, "all"))
649     all_cards = 1;
650
651   err = agent_scd_serialno (&serialno0, NULL);
652   if (err)
653     {
654       if (gpg_err_code (err) != GPG_ERR_ENODEV && opt.verbose)
655         log_info (_("error getting serial number of card: %s\n"),
656                   gpg_strerror (err));
657       /* Nothing available.  */
658       return;
659     }
660
661   err = agent_scd_cardlist (&card_list);
662
663   for (sl = card_list; sl; sl = sl->next)
664     {
665       char *serialno1;
666
667       if (!all_cards && strcmp (serialno, sl->d))
668         continue;
669
670       err = agent_scd_serialno (&serialno1, sl->d);
671       if (err)
672         {
673           if (opt.verbose)
674             log_info (_("error getting serial number of card: %s\n"),
675                       gpg_strerror (err));
676           continue;
677         }
678
679       current_card_status (ctrl, fp, NULL, 0);
680       xfree (serialno1);
681
682       if (!all_cards)
683         goto leave;
684     }
685
686   /* Select the original card again.  */
687   err = agent_scd_serialno (&serialno0, serialno0);
688
689  leave:
690   xfree (serialno0);
691   free_strlist (card_list);
692 }
693
694
695 static char *
696 get_one_name (const char *prompt1, const char *prompt2)
697 {
698   char *name;
699   int i;
700
701   for (;;)
702     {
703       name = cpr_get (prompt1, prompt2);
704       if (!name)
705         return NULL;
706       trim_spaces (name);
707       cpr_kill_prompt ();
708       for (i=0; name[i] && name[i] >= ' ' && name[i] <= 126; i++)
709         ;
710
711       /* The name must be in Latin-1 and not UTF-8 - lacking the code
712          to ensure this we restrict it to ASCII. */
713       if (name[i])
714         tty_printf (_("Error: Only plain ASCII is currently allowed.\n"));
715       else if (strchr (name, '<'))
716         tty_printf (_("Error: The \"<\" character may not be used.\n"));
717       else if (strstr (name, "  "))
718         tty_printf (_("Error: Double spaces are not allowed.\n"));
719       else
720         return name;
721       xfree (name);
722     }
723 }
724
725
726
727 static int
728 change_name (void)
729 {
730   char *surname = NULL, *givenname = NULL;
731   char *isoname, *p;
732   int rc;
733
734   surname = get_one_name ("keygen.smartcard.surname",
735                                     _("Cardholder's surname: "));
736   givenname = get_one_name ("keygen.smartcard.givenname",
737                                        _("Cardholder's given name: "));
738   if (!surname || !givenname || (!*surname && !*givenname))
739     {
740       xfree (surname);
741       xfree (givenname);
742       return -1; /*canceled*/
743     }
744
745   isoname = xmalloc ( strlen (surname) + 2 + strlen (givenname) + 1);
746   strcpy (stpcpy (stpcpy (isoname, surname), "<<"), givenname);
747   xfree (surname);
748   xfree (givenname);
749   for (p=isoname; *p; p++)
750     if (*p == ' ')
751       *p = '<';
752
753   if (strlen (isoname) > 39 )
754     {
755       tty_printf (_("Error: Combined name too long "
756                     "(limit is %d characters).\n"), 39);
757       xfree (isoname);
758       return -1;
759     }
760
761   rc = agent_scd_setattr ("DISP-NAME", isoname, strlen (isoname), NULL );
762   if (rc)
763     log_error ("error setting Name: %s\n", gpg_strerror (rc));
764
765   xfree (isoname);
766   return rc;
767 }
768
769
770 static int
771 change_url (void)
772 {
773   char *url;
774   int rc;
775
776   url = cpr_get ("cardedit.change_url", _("URL to retrieve public key: "));
777   if (!url)
778     return -1;
779   trim_spaces (url);
780   cpr_kill_prompt ();
781
782   rc = agent_scd_setattr ("PUBKEY-URL", url, strlen (url), NULL );
783   if (rc)
784     log_error ("error setting URL: %s\n", gpg_strerror (rc));
785   xfree (url);
786   write_sc_op_status (rc);
787   return rc;
788 }
789
790
791 /* Fetch the key from the URL given on the card or try to get it from
792    the default keyserver.  */
793 static int
794 fetch_url (ctrl_t ctrl)
795 {
796   int rc;
797   struct agent_card_info_s info;
798
799   memset(&info,0,sizeof(info));
800
801   rc=agent_scd_getattr("PUBKEY-URL",&info);
802   if(rc)
803     log_error("error retrieving URL from card: %s\n",gpg_strerror(rc));
804   else
805     {
806       rc=agent_scd_getattr("KEY-FPR",&info);
807       if(rc)
808         log_error("error retrieving key fingerprint from card: %s\n",
809                   gpg_strerror(rc));
810       else if (info.pubkey_url && *info.pubkey_url)
811         {
812           strlist_t sl = NULL;
813
814           add_to_strlist (&sl, info.pubkey_url);
815           rc = keyserver_fetch (ctrl, sl, KEYORG_URL);
816           free_strlist (sl);
817         }
818       else if (info.fpr1valid)
819         {
820           rc = keyserver_import_fprint (ctrl, info.fpr1, 20, opt.keyserver, 0);
821         }
822     }
823
824   return rc;
825 }
826
827
828 #define MAX_GET_DATA_FROM_FILE 16384
829
830 /* Read data from file FNAME up to MAX_GET_DATA_FROM_FILE characters.
831    On error return -1 and store NULL at R_BUFFER; on success return
832    the number of bytes read and store the address of a newly allocated
833    buffer at R_BUFFER. */
834 static int
835 get_data_from_file (const char *fname, char **r_buffer)
836 {
837   estream_t fp;
838   char *data;
839   int n;
840
841   *r_buffer = NULL;
842
843   fp = es_fopen (fname, "rb");
844 #if GNUPG_MAJOR_VERSION == 1
845   if (fp && is_secured_file (fileno (fp)))
846     {
847       fclose (fp);
848       fp = NULL;
849       errno = EPERM;
850     }
851 #endif
852   if (!fp)
853     {
854       tty_printf (_("can't open '%s': %s\n"), fname, strerror (errno));
855       return -1;
856     }
857
858   data = xtrymalloc (MAX_GET_DATA_FROM_FILE);
859   if (!data)
860     {
861       tty_printf (_("error allocating enough memory: %s\n"), strerror (errno));
862       es_fclose (fp);
863       return -1;
864     }
865
866   n = es_fread (data, 1, MAX_GET_DATA_FROM_FILE, fp);
867   es_fclose (fp);
868   if (n < 0)
869     {
870       tty_printf (_("error reading '%s': %s\n"), fname, strerror (errno));
871       xfree (data);
872       return -1;
873     }
874   *r_buffer = data;
875   return n;
876 }
877
878
879 /* Write LENGTH bytes from BUFFER to file FNAME.  Return 0 on
880    success.  */
881 static int
882 put_data_to_file (const char *fname, const void *buffer, size_t length)
883 {
884   estream_t fp;
885
886   fp = es_fopen (fname, "wb");
887 #if GNUPG_MAJOR_VERSION == 1
888   if (fp && is_secured_file (fileno (fp)))
889     {
890       fclose (fp);
891       fp = NULL;
892       errno = EPERM;
893     }
894 #endif
895   if (!fp)
896     {
897       tty_printf (_("can't create '%s': %s\n"), fname, strerror (errno));
898       return -1;
899     }
900
901   if (length && es_fwrite (buffer, length, 1, fp) != 1)
902     {
903       tty_printf (_("error writing '%s': %s\n"), fname, strerror (errno));
904       es_fclose (fp);
905       return -1;
906     }
907   es_fclose (fp);
908   return 0;
909 }
910
911
912 static int
913 change_login (const char *args)
914 {
915   char *data;
916   int n;
917   int rc;
918
919   if (args && *args == '<')  /* Read it from a file */
920     {
921       for (args++; spacep (args); args++)
922         ;
923       n = get_data_from_file (args, &data);
924       if (n < 0)
925         return -1;
926     }
927   else
928     {
929       data = cpr_get ("cardedit.change_login",
930                       _("Login data (account name): "));
931       if (!data)
932         return -1;
933       trim_spaces (data);
934       cpr_kill_prompt ();
935       n = strlen (data);
936     }
937
938   rc = agent_scd_setattr ("LOGIN-DATA", data, n, NULL );
939   if (rc)
940     log_error ("error setting login data: %s\n", gpg_strerror (rc));
941   xfree (data);
942   write_sc_op_status (rc);
943   return rc;
944 }
945
946 static int
947 change_private_do (const char *args, int nr)
948 {
949   char do_name[] = "PRIVATE-DO-X";
950   char *data;
951   int n;
952   int rc;
953
954   log_assert (nr >= 1 && nr <= 4);
955   do_name[11] = '0' + nr;
956
957   if (args && (args = strchr (args, '<')))  /* Read it from a file */
958     {
959       for (args++; spacep (args); args++)
960         ;
961       n = get_data_from_file (args, &data);
962       if (n < 0)
963         return -1;
964     }
965   else
966     {
967       data = cpr_get ("cardedit.change_private_do",
968                       _("Private DO data: "));
969       if (!data)
970         return -1;
971       trim_spaces (data);
972       cpr_kill_prompt ();
973       n = strlen (data);
974     }
975
976   rc = agent_scd_setattr (do_name, data, n, NULL );
977   if (rc)
978     log_error ("error setting private DO: %s\n", gpg_strerror (rc));
979   xfree (data);
980   write_sc_op_status (rc);
981   return rc;
982 }
983
984
985 static int
986 change_cert (const char *args)
987 {
988   char *data;
989   int n;
990   int rc;
991
992   if (args && *args == '<')  /* Read it from a file */
993     {
994       for (args++; spacep (args); args++)
995         ;
996       n = get_data_from_file (args, &data);
997       if (n < 0)
998         return -1;
999     }
1000   else
1001     {
1002       tty_printf ("usage error: redirection to file required\n");
1003       return -1;
1004     }
1005
1006   rc = agent_scd_writecert ("OPENPGP.3", data, n);
1007   if (rc)
1008     log_error ("error writing certificate to card: %s\n", gpg_strerror (rc));
1009   xfree (data);
1010   write_sc_op_status (rc);
1011   return rc;
1012 }
1013
1014
1015 static int
1016 read_cert (const char *args)
1017 {
1018   const char *fname;
1019   void *buffer;
1020   size_t length;
1021   int rc;
1022
1023   if (args && *args == '>')  /* Write it to a file */
1024     {
1025       for (args++; spacep (args); args++)
1026         ;
1027       fname = args;
1028     }
1029   else
1030     {
1031       tty_printf ("usage error: redirection to file required\n");
1032       return -1;
1033     }
1034
1035   rc = agent_scd_readcert ("OPENPGP.3", &buffer, &length);
1036   if (rc)
1037     log_error ("error reading certificate from card: %s\n", gpg_strerror (rc));
1038   else
1039     rc = put_data_to_file (fname, buffer, length);
1040   xfree (buffer);
1041   write_sc_op_status (rc);
1042   return rc;
1043 }
1044
1045
1046 static int
1047 change_lang (void)
1048 {
1049   char *data, *p;
1050   int rc;
1051
1052   data = cpr_get ("cardedit.change_lang",
1053                   _("Language preferences: "));
1054   if (!data)
1055     return -1;
1056   trim_spaces (data);
1057   cpr_kill_prompt ();
1058
1059   if (strlen (data) > 8 || (strlen (data) & 1))
1060     {
1061       tty_printf (_("Error: invalid length of preference string.\n"));
1062       xfree (data);
1063       return -1;
1064     }
1065
1066   for (p=data; *p && *p >= 'a' && *p <= 'z'; p++)
1067     ;
1068   if (*p)
1069     {
1070       tty_printf (_("Error: invalid characters in preference string.\n"));
1071       xfree (data);
1072       return -1;
1073     }
1074
1075   rc = agent_scd_setattr ("DISP-LANG", data, strlen (data), NULL );
1076   if (rc)
1077     log_error ("error setting lang: %s\n", gpg_strerror (rc));
1078   xfree (data);
1079   write_sc_op_status (rc);
1080   return rc;
1081 }
1082
1083
1084 static int
1085 change_sex (void)
1086 {
1087   char *data;
1088   const char *str;
1089   int rc;
1090
1091   data = cpr_get ("cardedit.change_sex",
1092                   _("Salutation (M = Mr., F = Mrs., or space): "));
1093   if (!data)
1094     return -1;
1095   trim_spaces (data);
1096   cpr_kill_prompt ();
1097
1098   if (!*data)
1099     str = "9";
1100   else if ((*data == 'M' || *data == 'm') && !data[1])
1101     str = "1";
1102   else if ((*data == 'F' || *data == 'f') && !data[1])
1103     str = "2";
1104   else
1105     {
1106       tty_printf (_("Error: invalid response.\n"));
1107       xfree (data);
1108       return -1;
1109     }
1110
1111   rc = agent_scd_setattr ("DISP-SEX", str, 1, NULL );
1112   if (rc)
1113     log_error ("error setting salutation: %s\n", gpg_strerror (rc));
1114   xfree (data);
1115   write_sc_op_status (rc);
1116   return rc;
1117 }
1118
1119
1120 static int
1121 change_cafpr (int fprno)
1122 {
1123   char *data;
1124   const char *s;
1125   int i, c, rc;
1126   unsigned char fpr[MAX_FINGERPRINT_LEN];
1127   int fprlen;
1128
1129   data = cpr_get ("cardedit.change_cafpr", _("CA fingerprint: "));
1130   if (!data)
1131     return -1;
1132   trim_spaces (data);
1133   cpr_kill_prompt ();
1134
1135   for (i=0, s=data; i < MAX_FINGERPRINT_LEN && *s; )
1136     {
1137       while (spacep(s))
1138         s++;
1139       if (*s == ':')
1140         s++;
1141       while (spacep(s))
1142         s++;
1143       c = hextobyte (s);
1144       if (c == -1)
1145         break;
1146       fpr[i++] = c;
1147       s += 2;
1148     }
1149   fprlen = i;
1150   xfree (data);
1151   if ((fprlen != 20 && fprlen != 32) || *s)
1152     {
1153       tty_printf (_("Error: invalid formatted fingerprint.\n"));
1154       return -1;
1155     }
1156
1157   rc = agent_scd_setattr (fprno==1?"CA-FPR-1":
1158                           fprno==2?"CA-FPR-2":
1159                           fprno==3?"CA-FPR-3":"x", fpr, fprlen, NULL );
1160   if (rc)
1161     log_error ("error setting cafpr: %s\n", gpg_strerror (rc));
1162   write_sc_op_status (rc);
1163   return rc;
1164 }
1165
1166
1167
1168 static void
1169 toggle_forcesig (void)
1170 {
1171   struct agent_card_info_s info;
1172   int rc;
1173   int newstate;
1174
1175   memset (&info, 0, sizeof info);
1176   rc = agent_scd_getattr ("CHV-STATUS", &info);
1177   if (rc)
1178     {
1179       log_error ("error getting current status: %s\n", gpg_strerror (rc));
1180       return;
1181     }
1182   newstate = !info.chv1_cached;
1183   agent_release_card_info (&info);
1184
1185   rc = agent_scd_setattr ("CHV-STATUS-1", newstate? "\x01":"", 1, NULL);
1186   if (rc)
1187     log_error ("error toggling signature PIN flag: %s\n", gpg_strerror (rc));
1188   write_sc_op_status (rc);
1189 }
1190
1191
1192 /* Helper for the key generation/edit functions.  */
1193 static int
1194 get_info_for_key_operation (struct agent_card_info_s *info)
1195 {
1196   int rc;
1197
1198   memset (info, 0, sizeof *info);
1199   rc = agent_scd_getattr ("SERIALNO", info);
1200   if (rc || !info->serialno || strncmp (info->serialno, "D27600012401", 12)
1201       || strlen (info->serialno) != 32 )
1202     {
1203       log_error (_("key operation not possible: %s\n"),
1204                  rc ? gpg_strerror (rc) : _("not an OpenPGP card"));
1205       return rc? rc: -1;
1206     }
1207   rc = agent_scd_getattr ("KEY-FPR", info);
1208   if (!rc)
1209     rc = agent_scd_getattr ("CHV-STATUS", info);
1210   if (!rc)
1211     rc = agent_scd_getattr ("DISP-NAME", info);
1212   if (!rc)
1213     rc = agent_scd_getattr ("EXTCAP", info);
1214   if (!rc)
1215     rc = agent_scd_getattr ("KEY-ATTR", info);
1216   if (rc)
1217     log_error (_("error getting current key info: %s\n"), gpg_strerror (rc));
1218   return rc;
1219 }
1220
1221
1222 /* Helper for the key generation/edit functions.  */
1223 static int
1224 check_pin_for_key_operation (struct agent_card_info_s *info, int *forced_chv1)
1225 {
1226   int rc = 0;
1227
1228   agent_clear_pin_cache (info->serialno);
1229
1230   *forced_chv1 = !info->chv1_cached;
1231   if (*forced_chv1)
1232     { /* Switch off the forced mode so that during key generation we
1233          don't get bothered with PIN queries for each
1234          self-signature. */
1235       rc = agent_scd_setattr ("CHV-STATUS-1", "\x01", 1, info->serialno);
1236       if (rc)
1237         {
1238           log_error ("error clearing forced signature PIN flag: %s\n",
1239                      gpg_strerror (rc));
1240           *forced_chv1 = 0;
1241         }
1242     }
1243
1244   if (!rc)
1245     {
1246       /* Check the PIN now, so that we won't get asked later for each
1247          binding signature. */
1248       rc = agent_scd_checkpin (info->serialno);
1249       if (rc)
1250         {
1251           log_error ("error checking the PIN: %s\n", gpg_strerror (rc));
1252           write_sc_op_status (rc);
1253         }
1254   }
1255   return rc;
1256 }
1257
1258 /* Helper for the key generation/edit functions.  */
1259 static void
1260 restore_forced_chv1 (int *forced_chv1)
1261 {
1262   int rc;
1263
1264   if (*forced_chv1)
1265     { /* Switch back to forced state. */
1266       rc = agent_scd_setattr ("CHV-STATUS-1", "", 1, NULL);
1267       if (rc)
1268         {
1269           log_error ("error setting forced signature PIN flag: %s\n",
1270                      gpg_strerror (rc));
1271         }
1272     }
1273 }
1274
1275
1276 /* Helper for the key generation/edit functions.  */
1277 static void
1278 show_card_key_info (struct agent_card_info_s *info)
1279 {
1280   tty_fprintf (NULL, "Signature key ....:");
1281   print_sha1_fpr (NULL, info->fpr1valid? info->fpr1:NULL);
1282   tty_fprintf (NULL, "Encryption key....:");
1283   print_sha1_fpr (NULL, info->fpr2valid? info->fpr2:NULL);
1284   tty_fprintf (NULL, "Authentication key:");
1285   print_sha1_fpr (NULL, info->fpr3valid? info->fpr3:NULL);
1286   tty_printf ("\n");
1287 }
1288
1289
1290 /* Helper for the key generation/edit functions.  */
1291 static int
1292 replace_existing_key_p (struct agent_card_info_s *info, int keyno)
1293 {
1294   log_assert (keyno >= 0 && keyno <= 3);
1295
1296   if ((keyno == 1 && info->fpr1valid)
1297       || (keyno == 2 && info->fpr2valid)
1298       || (keyno == 3 && info->fpr3valid))
1299     {
1300       tty_printf ("\n");
1301       log_info ("WARNING: such a key has already been stored on the card!\n");
1302       tty_printf ("\n");
1303       if ( !cpr_get_answer_is_yes( "cardedit.genkeys.replace_key",
1304                                   _("Replace existing key? (y/N) ")))
1305         return -1;
1306       return 1;
1307     }
1308   return 0;
1309 }
1310
1311
1312 static void
1313 show_keysize_warning (void)
1314 {
1315   static int shown;
1316
1317   if (shown)
1318     return;
1319   shown = 1;
1320   tty_printf
1321     (_("Note: There is no guarantee that the card supports the requested\n"
1322        "      key type or size.  If the key generation does not succeed,\n"
1323        "      please check the documentation of your card to see which\n"
1324        "      key types and sizes are supported.\n")
1325      );
1326 }
1327
1328
1329 /* Ask for the size of a card key.  NBITS is the current size
1330    configured for the card.  KEYNO is the number of the key used to
1331    select the prompt.  Returns 0 to use the default size (i.e. NBITS)
1332    or the selected size.  */
1333 static unsigned int
1334 ask_card_keyattr (int keyno, unsigned int nbits)
1335 {
1336   unsigned int min_nbits = 1024;
1337   unsigned int max_nbits = 4096;
1338   char *prompt, *answer;
1339   unsigned int req_nbits;
1340
1341   for (;;)
1342     {
1343       prompt = xasprintf
1344         (keyno == 0?
1345          _("What keysize do you want for the Signature key? (%u) "):
1346          keyno == 1?
1347          _("What keysize do you want for the Encryption key? (%u) "):
1348          _("What keysize do you want for the Authentication key? (%u) "),
1349          nbits);
1350       answer = cpr_get ("cardedit.genkeys.size", prompt);
1351       cpr_kill_prompt ();
1352       req_nbits = *answer? atoi (answer): nbits;
1353       xfree (prompt);
1354       xfree (answer);
1355
1356       if (req_nbits == 25519)
1357         {
1358           if (req_nbits == nbits)
1359             return 0;  /* Use default.  */
1360
1361           tty_printf (_("The card will now be re-configured"
1362                         " to generate a key of type: %s\n"),
1363                       keyno==1? "cv25519":"ed25519");
1364           show_keysize_warning ();
1365           return req_nbits;
1366         }
1367       else
1368         {
1369           if (req_nbits != nbits && (req_nbits % 32) )
1370             {
1371               req_nbits = ((req_nbits + 31) / 32) * 32;
1372               tty_printf (_("rounded up to %u bits\n"), req_nbits);
1373             }
1374
1375           if (req_nbits == nbits)
1376             return 0;  /* Use default.  */
1377
1378           if (req_nbits < min_nbits || req_nbits > max_nbits)
1379             {
1380               tty_printf (_("%s keysizes must be in the range %u-%u\n"),
1381                       "RSA", min_nbits, max_nbits);
1382             }
1383           else
1384             {
1385               char name[30];
1386
1387               snprintf (name, sizeof name, "rsa%u", req_nbits);
1388               tty_printf (_("The card will now be re-configured"
1389                             " to generate a key of type: %s\n"),
1390                           name);
1391               show_keysize_warning ();
1392               return req_nbits;
1393             }
1394         }
1395     }
1396 }
1397
1398
1399 /* Change the size of key KEYNO (0..2) to NBITS and show an error
1400  * message if that fails.  Using the magic value 25519 for NBITS
1401  * switches to ed25519 or cv25519 depending on the KEYNO.  */
1402 static gpg_error_t
1403 do_change_keyattr (int keyno, unsigned int nbits)
1404 {
1405   gpg_error_t err;
1406   char args[100];
1407
1408   if (nbits == 25519)
1409     snprintf (args, sizeof args, "--force %d %d %s",
1410               keyno+1,
1411               keyno == 1? PUBKEY_ALGO_ECDH : PUBKEY_ALGO_EDDSA,
1412               keyno == 1? "cv25519" : "ed25519");
1413   else
1414     snprintf (args, sizeof args, "--force %d 1 rsa%u", keyno+1, nbits);
1415   err = agent_scd_setattr ("KEY-ATTR", args, strlen (args), NULL);
1416   if (err)
1417     log_error (_("error changing size of key %d to %u bits: %s\n"),
1418                keyno+1, nbits, gpg_strerror (err));
1419   return err;
1420 }
1421
1422
1423 static void
1424 generate_card_keys (ctrl_t ctrl)
1425 {
1426   struct agent_card_info_s info;
1427   int forced_chv1;
1428   int want_backup;
1429   int keyno;
1430
1431   if (get_info_for_key_operation (&info))
1432     return;
1433
1434   if (info.extcap.ki)
1435     {
1436       char *answer;
1437
1438       /* FIXME: Should be something like cpr_get_bool so that a status
1439          GET_BOOL will be emitted.  */
1440       answer = cpr_get ("cardedit.genkeys.backup_enc",
1441                         _("Make off-card backup of encryption key? (Y/n) "));
1442
1443       want_backup = answer_is_yes_no_default (answer, 1/*(default to Yes)*/);
1444       cpr_kill_prompt ();
1445       xfree (answer);
1446     }
1447   else
1448     want_backup = 0;
1449
1450   if ( (info.fpr1valid && !fpr_is_zero (info.fpr1))
1451        || (info.fpr2valid && !fpr_is_zero (info.fpr2))
1452        || (info.fpr3valid && !fpr_is_zero (info.fpr3)))
1453     {
1454       tty_printf ("\n");
1455       log_info (_("Note: keys are already stored on the card!\n"));
1456       tty_printf ("\n");
1457       if ( !cpr_get_answer_is_yes ("cardedit.genkeys.replace_keys",
1458                                    _("Replace existing keys? (y/N) ")))
1459         {
1460           agent_release_card_info (&info);
1461           return;
1462         }
1463     }
1464
1465   /* If no displayed name has been set, we assume that this is a fresh
1466      card and print a hint about the default PINs.  */
1467   if (!info.disp_name || !*info.disp_name)
1468     {
1469       tty_printf ("\n");
1470       tty_printf (_("Please note that the factory settings of the PINs are\n"
1471                     "   PIN = '%s'     Admin PIN = '%s'\n"
1472                     "You should change them using the command --change-pin\n"),
1473                   "123456", "12345678");
1474       tty_printf ("\n");
1475     }
1476
1477   if (check_pin_for_key_operation (&info, &forced_chv1))
1478     goto leave;
1479
1480   /* If the cards features changeable key attributes, we ask for the
1481      key size.  */
1482   if (info.is_v2 && info.extcap.aac)
1483     {
1484       unsigned int nbits;
1485
1486       for (keyno = 0; keyno < DIM (info.key_attr); keyno++)
1487         {
1488           if (info.key_attr[keyno].algo == PUBKEY_ALGO_RSA
1489               || info.key_attr[keyno].algo == PUBKEY_ALGO_ECDH
1490               || info.key_attr[keyno].algo == PUBKEY_ALGO_EDDSA)
1491             {
1492               if (info.key_attr[keyno].algo == PUBKEY_ALGO_RSA)
1493                 nbits = ask_card_keyattr (keyno, info.key_attr[keyno].nbits);
1494               else
1495                 nbits = ask_card_keyattr (keyno, 25519 /* magic */);
1496
1497               if (nbits && do_change_keyattr (keyno, nbits))
1498                 {
1499                   /* Error: Better read the default key size again.  */
1500                   agent_release_card_info (&info);
1501                   if (get_info_for_key_operation (&info))
1502                     goto leave;
1503                   /* Ask again for this key size. */
1504                   keyno--;
1505                 }
1506             }
1507         }
1508       /* Note that INFO has not be synced.  However we will only use
1509          the serialnumber and thus it won't harm.  */
1510     }
1511
1512   generate_keypair (ctrl, 1, NULL, info.serialno, want_backup);
1513
1514  leave:
1515   agent_release_card_info (&info);
1516   restore_forced_chv1 (&forced_chv1);
1517 }
1518
1519
1520 /* This function is used by the key edit menu to generate an arbitrary
1521    subkey. */
1522 gpg_error_t
1523 card_generate_subkey (ctrl_t ctrl, kbnode_t pub_keyblock)
1524 {
1525   gpg_error_t err;
1526   struct agent_card_info_s info;
1527   int forced_chv1 = 0;
1528   int keyno;
1529
1530   err = get_info_for_key_operation (&info);
1531   if (err)
1532     return err;
1533
1534   show_card_key_info (&info);
1535
1536   tty_printf (_("Please select the type of key to generate:\n"));
1537
1538   tty_printf (_("   (1) Signature key\n"));
1539   tty_printf (_("   (2) Encryption key\n"));
1540   tty_printf (_("   (3) Authentication key\n"));
1541
1542   for (;;)
1543     {
1544       char *answer = cpr_get ("cardedit.genkeys.subkeytype",
1545                               _("Your selection? "));
1546       cpr_kill_prompt();
1547       if (*answer == CONTROL_D)
1548         {
1549           xfree (answer);
1550           err = gpg_error (GPG_ERR_CANCELED);
1551           goto leave;
1552         }
1553       keyno = *answer? atoi(answer): 0;
1554       xfree(answer);
1555       if (keyno >= 1 && keyno <= 3)
1556         break; /* Okay. */
1557       tty_printf(_("Invalid selection.\n"));
1558     }
1559
1560   if (replace_existing_key_p (&info, keyno) < 0)
1561     {
1562       err = gpg_error (GPG_ERR_CANCELED);
1563       goto leave;
1564     }
1565
1566   err = check_pin_for_key_operation (&info, &forced_chv1);
1567   if (err)
1568     goto leave;
1569
1570   /* If the cards features changeable key attributes, we ask for the
1571      key size.  */
1572   if (info.is_v2 && info.extcap.aac)
1573     {
1574       if (info.key_attr[keyno-1].algo == PUBKEY_ALGO_RSA
1575           || info.key_attr[keyno].algo == PUBKEY_ALGO_ECDH
1576           || info.key_attr[keyno].algo == PUBKEY_ALGO_EDDSA)
1577         {
1578           unsigned int nbits;
1579
1580         ask_again:
1581           if (info.key_attr[keyno].algo == PUBKEY_ALGO_RSA)
1582             nbits = ask_card_keyattr (keyno-1, info.key_attr[keyno-1].nbits);
1583           else
1584             nbits = ask_card_keyattr (keyno-1, 25519);
1585
1586           if (nbits && do_change_keyattr (keyno-1, nbits))
1587             {
1588               /* Error: Better read the default key size again.  */
1589               agent_release_card_info (&info);
1590               err = get_info_for_key_operation (&info);
1591               if (err)
1592                 goto leave;
1593               goto ask_again;
1594             }
1595         }
1596       /* Note that INFO has not be synced.  However we will only use
1597          the serialnumber and thus it won't harm.  */
1598     }
1599
1600   err = generate_card_subkeypair (ctrl, pub_keyblock, keyno, info.serialno);
1601
1602  leave:
1603   agent_release_card_info (&info);
1604   restore_forced_chv1 (&forced_chv1);
1605   return err;
1606 }
1607
1608
1609 /* Store the key at NODE into the smartcard and modify NODE to
1610    carry the serialno stuff instead of the actual secret key
1611    parameters.  USE is the usage for that key; 0 means any
1612    usage. */
1613 int
1614 card_store_subkey (KBNODE node, int use)
1615 {
1616   struct agent_card_info_s info;
1617   int okay = 0;
1618   unsigned int nbits;
1619   int allow_keyno[3];
1620   int  keyno;
1621   PKT_public_key *pk;
1622   gpg_error_t err;
1623   char *hexgrip;
1624   int rc;
1625   gnupg_isotime_t timebuf;
1626
1627   log_assert (node->pkt->pkttype == PKT_PUBLIC_KEY
1628               || node->pkt->pkttype == PKT_PUBLIC_SUBKEY);
1629
1630   pk = node->pkt->pkt.public_key;
1631
1632   if (get_info_for_key_operation (&info))
1633     return 0;
1634
1635   if (!info.extcap.ki)
1636     {
1637       tty_printf ("The card does not support the import of keys\n");
1638       tty_printf ("\n");
1639       goto leave;
1640     }
1641
1642   nbits = nbits_from_pk (pk);
1643
1644   if (!info.is_v2 && nbits != 1024)
1645     {
1646       tty_printf ("You may only store a 1024 bit RSA key on the card\n");
1647       tty_printf ("\n");
1648       goto leave;
1649     }
1650
1651   allow_keyno[0] = (!use || (use & (PUBKEY_USAGE_SIG|PUBKEY_USAGE_CERT)));
1652   allow_keyno[1] = (!use || (use & (PUBKEY_USAGE_ENC)));
1653   allow_keyno[2] = (!use || (use & (PUBKEY_USAGE_SIG|PUBKEY_USAGE_AUTH)));
1654
1655   tty_printf (_("Please select where to store the key:\n"));
1656
1657   if (allow_keyno[0])
1658     tty_printf (_("   (1) Signature key\n"));
1659   if (allow_keyno[1])
1660     tty_printf (_("   (2) Encryption key\n"));
1661   if (allow_keyno[2])
1662     tty_printf (_("   (3) Authentication key\n"));
1663
1664   for (;;)
1665     {
1666       char *answer = cpr_get ("cardedit.genkeys.storekeytype",
1667                               _("Your selection? "));
1668       cpr_kill_prompt();
1669       if (*answer == CONTROL_D || !*answer)
1670         {
1671           xfree (answer);
1672           goto leave;
1673         }
1674       keyno = *answer? atoi(answer): 0;
1675       xfree(answer);
1676       if (keyno >= 1 && keyno <= 3 && allow_keyno[keyno-1])
1677         {
1678           if (info.is_v2 && !info.extcap.aac
1679               && info.key_attr[keyno-1].nbits != nbits)
1680             {
1681               tty_printf ("Key does not match the card's capability.\n");
1682             }
1683           else
1684             break; /* Okay. */
1685         }
1686       else
1687         tty_printf(_("Invalid selection.\n"));
1688     }
1689
1690   if ((rc = replace_existing_key_p (&info, keyno)) < 0)
1691     goto leave;
1692
1693   err = hexkeygrip_from_pk (pk, &hexgrip);
1694   if (err)
1695     goto leave;
1696
1697   epoch2isotime (timebuf, (time_t)pk->timestamp);
1698   rc = agent_keytocard (hexgrip, keyno, rc, info.serialno, timebuf);
1699
1700   if (rc)
1701     log_error (_("KEYTOCARD failed: %s\n"), gpg_strerror (rc));
1702   else
1703     okay = 1;
1704   xfree (hexgrip);
1705
1706  leave:
1707   agent_release_card_info (&info);
1708   return okay;
1709 }
1710
1711
1712
1713 /* Direct sending of an hex encoded APDU with error printing.  */
1714 static gpg_error_t
1715 send_apdu (const char *hexapdu, const char *desc, unsigned int ignore)
1716 {
1717   gpg_error_t err;
1718   unsigned int sw;
1719
1720   err = agent_scd_apdu (hexapdu, &sw);
1721   if (err)
1722     tty_printf ("sending card command %s failed: %s\n", desc,
1723                 gpg_strerror (err));
1724   else if (!hexapdu || !strcmp (hexapdu, "undefined"))
1725     ;
1726   else if (ignore == 0xffff)
1727     ; /* Ignore all status words.  */
1728   else if (sw != 0x9000)
1729     {
1730       switch (sw)
1731         {
1732         case 0x6285: err = gpg_error (GPG_ERR_OBJ_TERM_STATE); break;
1733         case 0x6982: err = gpg_error (GPG_ERR_BAD_PIN); break;
1734         case 0x6985: err = gpg_error (GPG_ERR_USE_CONDITIONS); break;
1735         default: err = gpg_error (GPG_ERR_CARD);
1736         }
1737       if (!(ignore && ignore == sw))
1738         tty_printf ("card command %s failed: %s (0x%04x)\n", desc,
1739                     gpg_strerror (err),  sw);
1740     }
1741   return err;
1742 }
1743
1744
1745 /* Do a factory reset after confirmation.  */
1746 static void
1747 factory_reset (void)
1748 {
1749   struct agent_card_info_s info;
1750   gpg_error_t err;
1751   char *answer = NULL;
1752   int termstate = 0;
1753   int i;
1754
1755   /*  The code below basically does the same what this
1756       gpg-connect-agent script does:
1757
1758         scd reset
1759         scd serialno undefined
1760         scd apdu 00 A4 04 00 06 D2 76 00 01 24 01
1761         scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
1762         scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
1763         scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
1764         scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
1765         scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
1766         scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
1767         scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
1768         scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
1769         scd apdu 00 e6 00 00
1770         scd apdu 00 44 00 00
1771         /echo Card has been reset to factory defaults
1772
1773       but tries to find out something about the card first.
1774    */
1775
1776   err = agent_scd_learn (&info, 0);
1777   if (gpg_err_code (err) == GPG_ERR_OBJ_TERM_STATE
1778       && gpg_err_source (err) == GPG_ERR_SOURCE_SCD)
1779     termstate = 1;
1780   else if (err)
1781     {
1782       log_error (_("OpenPGP card not available: %s\n"), gpg_strerror (err));
1783       return;
1784     }
1785
1786   if (!termstate)
1787     {
1788       log_info (_("OpenPGP card no. %s detected\n"),
1789                 info.serialno? info.serialno : "[none]");
1790       if (!(info.status_indicator == 3 || info.status_indicator == 5))
1791         {
1792           /* Note: We won't see status-indicator 3 here because it is not
1793              possible to select a card application in termination state.  */
1794           log_error (_("This command is not supported by this card\n"));
1795           goto leave;
1796         }
1797
1798       tty_printf ("\n");
1799       log_info (_("Note: This command destroys all keys stored on the card!\n"));
1800       tty_printf ("\n");
1801       if (!cpr_get_answer_is_yes ("cardedit.factory-reset.proceed",
1802                                   _("Continue? (y/N) ")))
1803         goto leave;
1804
1805
1806       answer = cpr_get ("cardedit.factory-reset.really",
1807                         _("Really do a factory reset? (enter \"yes\") "));
1808       cpr_kill_prompt ();
1809       trim_spaces (answer);
1810       if (strcmp (answer, "yes"))
1811         goto leave;
1812
1813       /* We need to select a card application before we can send APDUs
1814          to the card without scdaemon doing anything on its own.  */
1815       err = send_apdu (NULL, "RESET", 0);
1816       if (err)
1817         goto leave;
1818       err = send_apdu ("undefined", "dummy select ", 0);
1819       if (err)
1820         goto leave;
1821
1822       /* Select the OpenPGP application.  */
1823       err = send_apdu ("00A4040006D27600012401", "SELECT AID", 0);
1824       if (err)
1825         goto leave;
1826
1827       /* Do some dummy verifies with wrong PINs to set the retry
1828          counter to zero.  We can't easily use the card version 2.1
1829          feature of presenting the admin PIN to allow the terminate
1830          command because there is no machinery in scdaemon to catch
1831          the verify command and ask for the PIN when the "APDU"
1832          command is used. */
1833       for (i=0; i < 4; i++)
1834         send_apdu ("00200081084040404040404040", "VERIFY", 0xffff);
1835       for (i=0; i < 4; i++)
1836         send_apdu ("00200083084040404040404040", "VERIFY", 0xffff);
1837
1838       /* Send terminate datafile command.  */
1839       err = send_apdu ("00e60000", "TERMINATE DF", 0x6985);
1840       if (err)
1841         goto leave;
1842     }
1843
1844   /* Send activate datafile command.  This is used without
1845      confirmation if the card is already in termination state.  */
1846   err = send_apdu ("00440000", "ACTIVATE DF", 0);
1847   if (err)
1848     goto leave;
1849
1850   /* Finally we reset the card reader once more.  */
1851   err = send_apdu (NULL, "RESET", 0);
1852   if (err)
1853     goto leave;
1854
1855  leave:
1856   xfree (answer);
1857   agent_release_card_info (&info);
1858 }
1859
1860
1861 \f
1862 /* Data used by the command parser.  This needs to be outside of the
1863    function scope to allow readline based command completion.  */
1864 enum cmdids
1865   {
1866     cmdNOP = 0,
1867     cmdQUIT, cmdADMIN, cmdHELP, cmdLIST, cmdDEBUG, cmdVERIFY,
1868     cmdNAME, cmdURL, cmdFETCH, cmdLOGIN, cmdLANG, cmdSEX, cmdCAFPR,
1869     cmdFORCESIG, cmdGENERATE, cmdPASSWD, cmdPRIVATEDO, cmdWRITECERT,
1870     cmdREADCERT, cmdUNBLOCK, cmdFACTORYRESET,
1871     cmdINVCMD
1872   };
1873
1874 static struct
1875 {
1876   const char *name;
1877   enum cmdids id;
1878   int admin_only;
1879   const char *desc;
1880 } cmds[] =
1881   {
1882     { "quit"    , cmdQUIT  , 0, N_("quit this menu")},
1883     { "q"       , cmdQUIT  , 0, NULL },
1884     { "admin"   , cmdADMIN , 0, N_("show admin commands")},
1885     { "help"    , cmdHELP  , 0, N_("show this help")},
1886     { "?"       , cmdHELP  , 0, NULL },
1887     { "list"    , cmdLIST  , 0, N_("list all available data")},
1888     { "l"       , cmdLIST  , 0, NULL },
1889     { "debug"   , cmdDEBUG , 0, NULL },
1890     { "name"    , cmdNAME  , 1, N_("change card holder's name")},
1891     { "url"     , cmdURL   , 1, N_("change URL to retrieve key")},
1892     { "fetch"   , cmdFETCH , 0, N_("fetch the key specified in the card URL")},
1893     { "login"   , cmdLOGIN , 1, N_("change the login name")},
1894     { "lang"    , cmdLANG  , 1, N_("change the language preferences")},
1895     { "salutation",cmdSEX  , 1, N_("change card holder's salutation")},
1896     { "sex"       ,cmdSEX  , 1, NULL },  /* Backward compatibility.  */
1897     { "cafpr"   , cmdCAFPR , 1, N_("change a CA fingerprint")},
1898     { "forcesig", cmdFORCESIG, 1, N_("toggle the signature force PIN flag")},
1899     { "generate", cmdGENERATE, 1, N_("generate new keys")},
1900     { "passwd"  , cmdPASSWD, 0, N_("menu to change or unblock the PIN")},
1901     { "verify"  , cmdVERIFY, 0, N_("verify the PIN and list all data")},
1902     { "unblock" , cmdUNBLOCK,0, N_("unblock the PIN using a Reset Code") },
1903     { "factory-reset", cmdFACTORYRESET, 1, N_("destroy all keys and data")},
1904     /* Note, that we do not announce these command yet. */
1905     { "privatedo", cmdPRIVATEDO, 0, NULL },
1906     { "readcert", cmdREADCERT, 0, NULL },
1907     { "writecert", cmdWRITECERT, 1, NULL },
1908     { NULL, cmdINVCMD, 0, NULL }
1909   };
1910
1911
1912 #ifdef HAVE_LIBREADLINE
1913
1914 /* These two functions are used by readline for command completion. */
1915
1916 static char *
1917 command_generator(const char *text,int state)
1918 {
1919   static int list_index,len;
1920   const char *name;
1921
1922   /* If this is a new word to complete, initialize now.  This includes
1923      saving the length of TEXT for efficiency, and initializing the
1924      index variable to 0. */
1925   if(!state)
1926     {
1927       list_index=0;
1928       len=strlen(text);
1929     }
1930
1931   /* Return the next partial match */
1932   while((name=cmds[list_index].name))
1933     {
1934       /* Only complete commands that have help text */
1935       if(cmds[list_index++].desc && strncmp(name,text,len)==0)
1936         return strdup(name);
1937     }
1938
1939   return NULL;
1940 }
1941
1942 static char **
1943 card_edit_completion(const char *text, int start, int end)
1944 {
1945   (void)end;
1946   /* If we are at the start of a line, we try and command-complete.
1947      If not, just do nothing for now. */
1948
1949   if(start==0)
1950     return rl_completion_matches(text,command_generator);
1951
1952   rl_attempted_completion_over=1;
1953
1954   return NULL;
1955 }
1956 #endif /*HAVE_LIBREADLINE*/
1957
1958 /* Menu to edit all user changeable values on an OpenPGP card.  Only
1959    Key creation is not handled here. */
1960 void
1961 card_edit (ctrl_t ctrl, strlist_t commands)
1962 {
1963   enum cmdids cmd = cmdNOP;
1964   int have_commands = !!commands;
1965   int redisplay = 1;
1966   char *answer = NULL;
1967   int allow_admin=0;
1968   char serialnobuf[50];
1969
1970
1971   if (opt.command_fd != -1)
1972     ;
1973   else if (opt.batch && !have_commands)
1974     {
1975       log_error(_("can't do this in batch mode\n"));
1976       goto leave;
1977     }
1978
1979   for (;;)
1980     {
1981       int arg_number;
1982       const char *arg_string = "";
1983       const char *arg_rest = "";
1984       char *p;
1985       int i;
1986       int cmd_admin_only;
1987
1988       tty_printf("\n");
1989       if (redisplay)
1990         {
1991           if (opt.with_colons)
1992             {
1993               current_card_status (ctrl, es_stdout,
1994                                    serialnobuf, DIM (serialnobuf));
1995               fflush (stdout);
1996             }
1997           else
1998             {
1999               current_card_status (ctrl, NULL,
2000                                    serialnobuf, DIM (serialnobuf));
2001               tty_printf("\n");
2002             }
2003           redisplay = 0;
2004         }
2005
2006       do
2007         {
2008           xfree (answer);
2009           if (have_commands)
2010             {
2011               if (commands)
2012                 {
2013                   answer = xstrdup (commands->d);
2014                   commands = commands->next;
2015                 }
2016               else if (opt.batch)
2017                 {
2018                   answer = xstrdup ("quit");
2019                 }
2020               else
2021                 have_commands = 0;
2022             }
2023
2024             if (!have_commands)
2025               {
2026                 tty_enable_completion (card_edit_completion);
2027                 answer = cpr_get_no_help("cardedit.prompt", _("gpg/card> "));
2028                 cpr_kill_prompt();
2029                 tty_disable_completion ();
2030               }
2031             trim_spaces(answer);
2032         }
2033       while ( *answer == '#' );
2034
2035       arg_number = 0; /* Yes, here is the init which egcc complains about */
2036       cmd_admin_only = 0;
2037       if (!*answer)
2038         cmd = cmdLIST; /* Default to the list command */
2039       else if (*answer == CONTROL_D)
2040         cmd = cmdQUIT;
2041       else
2042         {
2043           if ((p=strchr (answer,' ')))
2044             {
2045               *p++ = 0;
2046               trim_spaces (answer);
2047               trim_spaces (p);
2048               arg_number = atoi(p);
2049               arg_string = p;
2050               arg_rest = p;
2051               while (digitp (arg_rest))
2052                 arg_rest++;
2053               while (spacep (arg_rest))
2054                 arg_rest++;
2055             }
2056
2057           for (i=0; cmds[i].name; i++ )
2058             if (!ascii_strcasecmp (answer, cmds[i].name ))
2059               break;
2060
2061           cmd = cmds[i].id;
2062           cmd_admin_only = cmds[i].admin_only;
2063         }
2064
2065       if (!allow_admin && cmd_admin_only)
2066         {
2067           tty_printf ("\n");
2068           tty_printf (_("Admin-only command\n"));
2069           continue;
2070         }
2071
2072       switch (cmd)
2073         {
2074         case cmdHELP:
2075           for (i=0; cmds[i].name; i++ )
2076             if(cmds[i].desc
2077                && (!cmds[i].admin_only || (cmds[i].admin_only && allow_admin)))
2078               tty_printf("%-14s %s\n", cmds[i].name, _(cmds[i].desc) );
2079           break;
2080
2081         case cmdADMIN:
2082           if ( !strcmp (arg_string, "on") )
2083             allow_admin = 1;
2084           else if ( !strcmp (arg_string, "off") )
2085             allow_admin = 0;
2086           else if ( !strcmp (arg_string, "verify") )
2087             {
2088               /* Force verification of the Admin Command.  However,
2089                  this is only done if the retry counter is at initial
2090                  state.  */
2091               char *tmp = xmalloc (strlen (serialnobuf) + 6 + 1);
2092               strcpy (stpcpy (tmp, serialnobuf), "[CHV3]");
2093               allow_admin = !agent_scd_checkpin (tmp);
2094               xfree (tmp);
2095             }
2096           else /* Toggle. */
2097             allow_admin=!allow_admin;
2098           if(allow_admin)
2099             tty_printf(_("Admin commands are allowed\n"));
2100           else
2101             tty_printf(_("Admin commands are not allowed\n"));
2102           break;
2103
2104         case cmdVERIFY:
2105           agent_scd_checkpin (serialnobuf);
2106           redisplay = 1;
2107           break;
2108
2109         case cmdLIST:
2110           redisplay = 1;
2111           break;
2112
2113         case cmdNAME:
2114           change_name ();
2115           break;
2116
2117         case cmdURL:
2118           change_url ();
2119           break;
2120
2121         case cmdFETCH:
2122           fetch_url (ctrl);
2123           break;
2124
2125         case cmdLOGIN:
2126           change_login (arg_string);
2127           break;
2128
2129         case cmdLANG:
2130           change_lang ();
2131           break;
2132
2133         case cmdSEX:
2134           change_sex ();
2135           break;
2136
2137         case cmdCAFPR:
2138           if ( arg_number < 1 || arg_number > 3 )
2139             tty_printf ("usage: cafpr N\n"
2140                         "       1 <= N <= 3\n");
2141           else
2142             change_cafpr (arg_number);
2143           break;
2144
2145         case cmdPRIVATEDO:
2146           if ( arg_number < 1 || arg_number > 4 )
2147             tty_printf ("usage: privatedo N\n"
2148                         "       1 <= N <= 4\n");
2149           else
2150             change_private_do (arg_string, arg_number);
2151           break;
2152
2153         case cmdWRITECERT:
2154           if ( arg_number != 3 )
2155             tty_printf ("usage: writecert 3 < FILE\n");
2156           else
2157             change_cert (arg_rest);
2158           break;
2159
2160         case cmdREADCERT:
2161           if ( arg_number != 3 )
2162             tty_printf ("usage: readcert 3 > FILE\n");
2163           else
2164             read_cert (arg_rest);
2165           break;
2166
2167         case cmdFORCESIG:
2168           toggle_forcesig ();
2169           break;
2170
2171         case cmdGENERATE:
2172           generate_card_keys (ctrl);
2173           break;
2174
2175         case cmdPASSWD:
2176           change_pin (0, allow_admin);
2177           break;
2178
2179         case cmdUNBLOCK:
2180           change_pin (1, allow_admin);
2181           break;
2182
2183         case cmdFACTORYRESET:
2184           factory_reset ();
2185           break;
2186
2187         case cmdQUIT:
2188           goto leave;
2189
2190         case cmdNOP:
2191           break;
2192
2193         case cmdINVCMD:
2194         default:
2195           tty_printf ("\n");
2196           tty_printf (_("Invalid command  (try \"help\")\n"));
2197           break;
2198         } /* End command switch. */
2199     } /* End of main menu loop. */
2200
2201  leave:
2202   xfree (answer);
2203 }