gpg: Update list of card vendors from master
[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,    "Sex ..............: %s\n",
536                    info.disp_sex == 1? _("male"):
537                    info.disp_sex == 2? _("female") : _("unspecified"));
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                   _("Sex ((M)ale, (F)emale 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 sex: %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[20];
1127
1128   data = cpr_get ("cardedit.change_cafpr", _("CA fingerprint: "));
1129   if (!data)
1130     return -1;
1131   trim_spaces (data);
1132   cpr_kill_prompt ();
1133
1134   for (i=0, s=data; i < 20 && *s; )
1135     {
1136       while (spacep(s))
1137         s++;
1138       if (*s == ':')
1139         s++;
1140       while (spacep(s))
1141         s++;
1142       c = hextobyte (s);
1143       if (c == -1)
1144         break;
1145       fpr[i++] = c;
1146       s += 2;
1147     }
1148   xfree (data);
1149   if (i != 20 || *s)
1150     {
1151       tty_printf (_("Error: invalid formatted fingerprint.\n"));
1152       return -1;
1153     }
1154
1155   rc = agent_scd_setattr (fprno==1?"CA-FPR-1":
1156                           fprno==2?"CA-FPR-2":
1157                           fprno==3?"CA-FPR-3":"x", fpr, 20, NULL );
1158   if (rc)
1159     log_error ("error setting cafpr: %s\n", gpg_strerror (rc));
1160   write_sc_op_status (rc);
1161   return rc;
1162 }
1163
1164
1165
1166 static void
1167 toggle_forcesig (void)
1168 {
1169   struct agent_card_info_s info;
1170   int rc;
1171   int newstate;
1172
1173   memset (&info, 0, sizeof info);
1174   rc = agent_scd_getattr ("CHV-STATUS", &info);
1175   if (rc)
1176     {
1177       log_error ("error getting current status: %s\n", gpg_strerror (rc));
1178       return;
1179     }
1180   newstate = !info.chv1_cached;
1181   agent_release_card_info (&info);
1182
1183   rc = agent_scd_setattr ("CHV-STATUS-1", newstate? "\x01":"", 1, NULL);
1184   if (rc)
1185     log_error ("error toggling signature PIN flag: %s\n", gpg_strerror (rc));
1186   write_sc_op_status (rc);
1187 }
1188
1189
1190 /* Helper for the key generation/edit functions.  */
1191 static int
1192 get_info_for_key_operation (struct agent_card_info_s *info)
1193 {
1194   int rc;
1195
1196   memset (info, 0, sizeof *info);
1197   rc = agent_scd_getattr ("SERIALNO", info);
1198   if (rc || !info->serialno || strncmp (info->serialno, "D27600012401", 12)
1199       || strlen (info->serialno) != 32 )
1200     {
1201       log_error (_("key operation not possible: %s\n"),
1202                  rc ? gpg_strerror (rc) : _("not an OpenPGP card"));
1203       return rc? rc: -1;
1204     }
1205   rc = agent_scd_getattr ("KEY-FPR", info);
1206   if (!rc)
1207     rc = agent_scd_getattr ("CHV-STATUS", info);
1208   if (!rc)
1209     rc = agent_scd_getattr ("DISP-NAME", info);
1210   if (!rc)
1211     rc = agent_scd_getattr ("EXTCAP", info);
1212   if (!rc)
1213     rc = agent_scd_getattr ("KEY-ATTR", info);
1214   if (rc)
1215     log_error (_("error getting current key info: %s\n"), gpg_strerror (rc));
1216   return rc;
1217 }
1218
1219
1220 /* Helper for the key generation/edit functions.  */
1221 static int
1222 check_pin_for_key_operation (struct agent_card_info_s *info, int *forced_chv1)
1223 {
1224   int rc = 0;
1225
1226   agent_clear_pin_cache (info->serialno);
1227
1228   *forced_chv1 = !info->chv1_cached;
1229   if (*forced_chv1)
1230     { /* Switch off the forced mode so that during key generation we
1231          don't get bothered with PIN queries for each
1232          self-signature. */
1233       rc = agent_scd_setattr ("CHV-STATUS-1", "\x01", 1, info->serialno);
1234       if (rc)
1235         {
1236           log_error ("error clearing forced signature PIN flag: %s\n",
1237                      gpg_strerror (rc));
1238           *forced_chv1 = 0;
1239         }
1240     }
1241
1242   if (!rc)
1243     {
1244       /* Check the PIN now, so that we won't get asked later for each
1245          binding signature. */
1246       rc = agent_scd_checkpin (info->serialno);
1247       if (rc)
1248         {
1249           log_error ("error checking the PIN: %s\n", gpg_strerror (rc));
1250           write_sc_op_status (rc);
1251         }
1252   }
1253   return rc;
1254 }
1255
1256 /* Helper for the key generation/edit functions.  */
1257 static void
1258 restore_forced_chv1 (int *forced_chv1)
1259 {
1260   int rc;
1261
1262   if (*forced_chv1)
1263     { /* Switch back to forced state. */
1264       rc = agent_scd_setattr ("CHV-STATUS-1", "", 1, NULL);
1265       if (rc)
1266         {
1267           log_error ("error setting forced signature PIN flag: %s\n",
1268                      gpg_strerror (rc));
1269         }
1270     }
1271 }
1272
1273
1274 /* Helper for the key generation/edit functions.  */
1275 static void
1276 show_card_key_info (struct agent_card_info_s *info)
1277 {
1278   tty_fprintf (NULL, "Signature key ....:");
1279   print_sha1_fpr (NULL, info->fpr1valid? info->fpr1:NULL);
1280   tty_fprintf (NULL, "Encryption key....:");
1281   print_sha1_fpr (NULL, info->fpr2valid? info->fpr2:NULL);
1282   tty_fprintf (NULL, "Authentication key:");
1283   print_sha1_fpr (NULL, info->fpr3valid? info->fpr3:NULL);
1284   tty_printf ("\n");
1285 }
1286
1287
1288 /* Helper for the key generation/edit functions.  */
1289 static int
1290 replace_existing_key_p (struct agent_card_info_s *info, int keyno)
1291 {
1292   log_assert (keyno >= 0 && keyno <= 3);
1293
1294   if ((keyno == 1 && info->fpr1valid)
1295       || (keyno == 2 && info->fpr2valid)
1296       || (keyno == 3 && info->fpr3valid))
1297     {
1298       tty_printf ("\n");
1299       log_info ("WARNING: such a key has already been stored on the card!\n");
1300       tty_printf ("\n");
1301       if ( !cpr_get_answer_is_yes( "cardedit.genkeys.replace_key",
1302                                   _("Replace existing key? (y/N) ")))
1303         return -1;
1304       return 1;
1305     }
1306   return 0;
1307 }
1308
1309
1310 static void
1311 show_keysize_warning (void)
1312 {
1313   static int shown;
1314
1315   if (shown)
1316     return;
1317   shown = 1;
1318   tty_printf
1319     (_("Note: There is no guarantee that the card "
1320        "supports the requested size.\n"
1321        "      If the key generation does not succeed, "
1322        "please check the\n"
1323        "      documentation of your card to see what "
1324        "sizes are allowed.\n"));
1325 }
1326
1327
1328 /* Ask for the size of a card key.  NBITS is the current size
1329    configured for the card.  KEYNO is the number of the key used to
1330    select the prompt.  Returns 0 to use the default size (i.e. NBITS)
1331    or the selected size.  */
1332 static unsigned int
1333 ask_card_keyattr (int keyno, unsigned int nbits)
1334 {
1335   unsigned int min_nbits = 1024;
1336   unsigned int max_nbits = 4096;
1337   char *prompt, *answer;
1338   unsigned int req_nbits;
1339
1340   for (;;)
1341     {
1342       prompt = xasprintf
1343         (keyno == 0?
1344          _("What keysize do you want for the Signature key? (%u) "):
1345          keyno == 1?
1346          _("What keysize do you want for the Encryption key? (%u) "):
1347          _("What keysize do you want for the Authentication key? (%u) "),
1348          nbits);
1349       answer = cpr_get ("cardedit.genkeys.size", prompt);
1350       cpr_kill_prompt ();
1351       req_nbits = *answer? atoi (answer): nbits;
1352       xfree (prompt);
1353       xfree (answer);
1354
1355       if (req_nbits == 25519)
1356         {
1357           if (req_nbits == nbits)
1358             return 0;  /* Use default.  */
1359
1360           tty_printf (_("The card will now be re-configured"
1361                         " to generate a key of type: %s\n"),
1362                       keyno==1? "cv25519":"ed25519");
1363           show_keysize_warning ();
1364           return req_nbits;
1365         }
1366       else
1367         {
1368           if (req_nbits != nbits && (req_nbits % 32) )
1369             {
1370               req_nbits = ((req_nbits + 31) / 32) * 32;
1371               tty_printf (_("rounded up to %u bits\n"), req_nbits);
1372             }
1373
1374           if (req_nbits == nbits)
1375             return 0;  /* Use default.  */
1376
1377           if (req_nbits < min_nbits || req_nbits > max_nbits)
1378             {
1379               tty_printf (_("%s keysizes must be in the range %u-%u\n"),
1380                       "RSA", min_nbits, max_nbits);
1381             }
1382           else
1383             {
1384               tty_printf (_("The card will now be re-configured"
1385                             " to generate a key of %u bits\n"), req_nbits);
1386               show_keysize_warning ();
1387               return req_nbits;
1388             }
1389         }
1390     }
1391 }
1392
1393
1394 /* Change the size of key KEYNO (0..2) to NBITS and show an error
1395  * message if that fails.  Using the magic value 25519 for NBITS
1396  * switches to ed25519 or cv25519 depending on the KEYNO.  */
1397 static gpg_error_t
1398 do_change_keyattr (int keyno, unsigned int nbits)
1399 {
1400   gpg_error_t err;
1401   char args[100];
1402
1403   if (nbits == 25519)
1404     snprintf (args, sizeof args, "--force %d %d %s",
1405               keyno+1,
1406               keyno == 1? PUBKEY_ALGO_ECDH : PUBKEY_ALGO_EDDSA,
1407               keyno == 1? "cv25519" : "ed25519");
1408   else
1409     snprintf (args, sizeof args, "--force %d 1 rsa%u", keyno+1, nbits);
1410   err = agent_scd_setattr ("KEY-ATTR", args, strlen (args), NULL);
1411   if (err)
1412     log_error (_("error changing size of key %d to %u bits: %s\n"),
1413                keyno+1, nbits, gpg_strerror (err));
1414   return err;
1415 }
1416
1417
1418 static void
1419 generate_card_keys (ctrl_t ctrl)
1420 {
1421   struct agent_card_info_s info;
1422   int forced_chv1;
1423   int want_backup;
1424   int keyno;
1425
1426   if (get_info_for_key_operation (&info))
1427     return;
1428
1429   if (info.extcap.ki)
1430     {
1431       char *answer;
1432
1433       /* FIXME: Should be something like cpr_get_bool so that a status
1434          GET_BOOL will be emitted.  */
1435       answer = cpr_get ("cardedit.genkeys.backup_enc",
1436                         _("Make off-card backup of encryption key? (Y/n) "));
1437
1438       want_backup = answer_is_yes_no_default (answer, 1/*(default to Yes)*/);
1439       cpr_kill_prompt ();
1440       xfree (answer);
1441     }
1442   else
1443     want_backup = 0;
1444
1445   if ( (info.fpr1valid && !fpr_is_zero (info.fpr1))
1446        || (info.fpr2valid && !fpr_is_zero (info.fpr2))
1447        || (info.fpr3valid && !fpr_is_zero (info.fpr3)))
1448     {
1449       tty_printf ("\n");
1450       log_info (_("Note: keys are already stored on the card!\n"));
1451       tty_printf ("\n");
1452       if ( !cpr_get_answer_is_yes ("cardedit.genkeys.replace_keys",
1453                                    _("Replace existing keys? (y/N) ")))
1454         {
1455           agent_release_card_info (&info);
1456           return;
1457         }
1458     }
1459
1460   /* If no displayed name has been set, we assume that this is a fresh
1461      card and print a hint about the default PINs.  */
1462   if (!info.disp_name || !*info.disp_name)
1463     {
1464       tty_printf ("\n");
1465       tty_printf (_("Please note that the factory settings of the PINs are\n"
1466                     "   PIN = '%s'     Admin PIN = '%s'\n"
1467                     "You should change them using the command --change-pin\n"),
1468                   "123456", "12345678");
1469       tty_printf ("\n");
1470     }
1471
1472   if (check_pin_for_key_operation (&info, &forced_chv1))
1473     goto leave;
1474
1475   /* If the cards features changeable key attributes, we ask for the
1476      key size.  */
1477   if (info.is_v2 && info.extcap.aac)
1478     {
1479       unsigned int nbits;
1480
1481       for (keyno = 0; keyno < DIM (info.key_attr); keyno++)
1482         {
1483           if (info.key_attr[keyno].algo == PUBKEY_ALGO_RSA
1484               || info.key_attr[keyno].algo == PUBKEY_ALGO_ECDH
1485               || info.key_attr[keyno].algo == PUBKEY_ALGO_EDDSA)
1486             {
1487               if (info.key_attr[keyno].algo == PUBKEY_ALGO_RSA)
1488                 nbits = ask_card_keyattr (keyno, info.key_attr[keyno].nbits);
1489               else
1490                 nbits = ask_card_keyattr (keyno, 25519 /* magic */);
1491
1492               if (nbits && do_change_keyattr (keyno, nbits))
1493                 {
1494                   /* Error: Better read the default key size again.  */
1495                   agent_release_card_info (&info);
1496                   if (get_info_for_key_operation (&info))
1497                     goto leave;
1498                   /* Ask again for this key size. */
1499                   keyno--;
1500                 }
1501             }
1502         }
1503       /* Note that INFO has not be synced.  However we will only use
1504          the serialnumber and thus it won't harm.  */
1505     }
1506
1507   generate_keypair (ctrl, 1, NULL, info.serialno, want_backup);
1508
1509  leave:
1510   agent_release_card_info (&info);
1511   restore_forced_chv1 (&forced_chv1);
1512 }
1513
1514
1515 /* This function is used by the key edit menu to generate an arbitrary
1516    subkey. */
1517 gpg_error_t
1518 card_generate_subkey (ctrl_t ctrl, kbnode_t pub_keyblock)
1519 {
1520   gpg_error_t err;
1521   struct agent_card_info_s info;
1522   int forced_chv1 = 0;
1523   int keyno;
1524
1525   err = get_info_for_key_operation (&info);
1526   if (err)
1527     return err;
1528
1529   show_card_key_info (&info);
1530
1531   tty_printf (_("Please select the type of key to generate:\n"));
1532
1533   tty_printf (_("   (1) Signature key\n"));
1534   tty_printf (_("   (2) Encryption key\n"));
1535   tty_printf (_("   (3) Authentication key\n"));
1536
1537   for (;;)
1538     {
1539       char *answer = cpr_get ("cardedit.genkeys.subkeytype",
1540                               _("Your selection? "));
1541       cpr_kill_prompt();
1542       if (*answer == CONTROL_D)
1543         {
1544           xfree (answer);
1545           err = gpg_error (GPG_ERR_CANCELED);
1546           goto leave;
1547         }
1548       keyno = *answer? atoi(answer): 0;
1549       xfree(answer);
1550       if (keyno >= 1 && keyno <= 3)
1551         break; /* Okay. */
1552       tty_printf(_("Invalid selection.\n"));
1553     }
1554
1555   if (replace_existing_key_p (&info, keyno) < 0)
1556     {
1557       err = gpg_error (GPG_ERR_CANCELED);
1558       goto leave;
1559     }
1560
1561   err = check_pin_for_key_operation (&info, &forced_chv1);
1562   if (err)
1563     goto leave;
1564
1565   /* If the cards features changeable key attributes, we ask for the
1566      key size.  */
1567   if (info.is_v2 && info.extcap.aac)
1568     {
1569       if (info.key_attr[keyno-1].algo == PUBKEY_ALGO_RSA
1570           || info.key_attr[keyno].algo == PUBKEY_ALGO_ECDH
1571           || info.key_attr[keyno].algo == PUBKEY_ALGO_EDDSA)
1572         {
1573           unsigned int nbits;
1574
1575         ask_again:
1576           if (info.key_attr[keyno].algo == PUBKEY_ALGO_RSA)
1577             nbits = ask_card_keyattr (keyno-1, info.key_attr[keyno-1].nbits);
1578           else
1579             nbits = ask_card_keyattr (keyno-1, 25519);
1580
1581           if (nbits && do_change_keyattr (keyno-1, nbits))
1582             {
1583               /* Error: Better read the default key size again.  */
1584               agent_release_card_info (&info);
1585               err = get_info_for_key_operation (&info);
1586               if (err)
1587                 goto leave;
1588               goto ask_again;
1589             }
1590         }
1591       /* Note that INFO has not be synced.  However we will only use
1592          the serialnumber and thus it won't harm.  */
1593     }
1594
1595   err = generate_card_subkeypair (ctrl, pub_keyblock, keyno, info.serialno);
1596
1597  leave:
1598   agent_release_card_info (&info);
1599   restore_forced_chv1 (&forced_chv1);
1600   return err;
1601 }
1602
1603
1604 /* Store the key at NODE into the smartcard and modify NODE to
1605    carry the serialno stuff instead of the actual secret key
1606    parameters.  USE is the usage for that key; 0 means any
1607    usage. */
1608 int
1609 card_store_subkey (KBNODE node, int use)
1610 {
1611   struct agent_card_info_s info;
1612   int okay = 0;
1613   unsigned int nbits;
1614   int allow_keyno[3];
1615   int  keyno;
1616   PKT_public_key *pk;
1617   gpg_error_t err;
1618   char *hexgrip;
1619   int rc;
1620   gnupg_isotime_t timebuf;
1621
1622   log_assert (node->pkt->pkttype == PKT_PUBLIC_KEY
1623               || node->pkt->pkttype == PKT_PUBLIC_SUBKEY);
1624
1625   pk = node->pkt->pkt.public_key;
1626
1627   if (get_info_for_key_operation (&info))
1628     return 0;
1629
1630   if (!info.extcap.ki)
1631     {
1632       tty_printf ("The card does not support the import of keys\n");
1633       tty_printf ("\n");
1634       goto leave;
1635     }
1636
1637   nbits = nbits_from_pk (pk);
1638
1639   if (!info.is_v2 && nbits != 1024)
1640     {
1641       tty_printf ("You may only store a 1024 bit RSA key on the card\n");
1642       tty_printf ("\n");
1643       goto leave;
1644     }
1645
1646   allow_keyno[0] = (!use || (use & (PUBKEY_USAGE_SIG|PUBKEY_USAGE_CERT)));
1647   allow_keyno[1] = (!use || (use & (PUBKEY_USAGE_ENC)));
1648   allow_keyno[2] = (!use || (use & (PUBKEY_USAGE_SIG|PUBKEY_USAGE_AUTH)));
1649
1650   tty_printf (_("Please select where to store the key:\n"));
1651
1652   if (allow_keyno[0])
1653     tty_printf (_("   (1) Signature key\n"));
1654   if (allow_keyno[1])
1655     tty_printf (_("   (2) Encryption key\n"));
1656   if (allow_keyno[2])
1657     tty_printf (_("   (3) Authentication key\n"));
1658
1659   for (;;)
1660     {
1661       char *answer = cpr_get ("cardedit.genkeys.storekeytype",
1662                               _("Your selection? "));
1663       cpr_kill_prompt();
1664       if (*answer == CONTROL_D || !*answer)
1665         {
1666           xfree (answer);
1667           goto leave;
1668         }
1669       keyno = *answer? atoi(answer): 0;
1670       xfree(answer);
1671       if (keyno >= 1 && keyno <= 3 && allow_keyno[keyno-1])
1672         {
1673           if (info.is_v2 && !info.extcap.aac
1674               && info.key_attr[keyno-1].nbits != nbits)
1675             {
1676               tty_printf ("Key does not match the card's capability.\n");
1677             }
1678           else
1679             break; /* Okay. */
1680         }
1681       else
1682         tty_printf(_("Invalid selection.\n"));
1683     }
1684
1685   if ((rc = replace_existing_key_p (&info, keyno)) < 0)
1686     goto leave;
1687
1688   err = hexkeygrip_from_pk (pk, &hexgrip);
1689   if (err)
1690     goto leave;
1691
1692   epoch2isotime (timebuf, (time_t)pk->timestamp);
1693   rc = agent_keytocard (hexgrip, keyno, rc, info.serialno, timebuf);
1694
1695   if (rc)
1696     log_error (_("KEYTOCARD failed: %s\n"), gpg_strerror (rc));
1697   else
1698     okay = 1;
1699   xfree (hexgrip);
1700
1701  leave:
1702   agent_release_card_info (&info);
1703   return okay;
1704 }
1705
1706
1707
1708 /* Direct sending of an hex encoded APDU with error printing.  */
1709 static gpg_error_t
1710 send_apdu (const char *hexapdu, const char *desc, unsigned int ignore)
1711 {
1712   gpg_error_t err;
1713   unsigned int sw;
1714
1715   err = agent_scd_apdu (hexapdu, &sw);
1716   if (err)
1717     tty_printf ("sending card command %s failed: %s\n", desc,
1718                 gpg_strerror (err));
1719   else if (!hexapdu || !strcmp (hexapdu, "undefined"))
1720     ;
1721   else if (ignore == 0xffff)
1722     ; /* Ignore all status words.  */
1723   else if (sw != 0x9000)
1724     {
1725       switch (sw)
1726         {
1727         case 0x6285: err = gpg_error (GPG_ERR_OBJ_TERM_STATE); break;
1728         case 0x6982: err = gpg_error (GPG_ERR_BAD_PIN); break;
1729         case 0x6985: err = gpg_error (GPG_ERR_USE_CONDITIONS); break;
1730         default: err = gpg_error (GPG_ERR_CARD);
1731         }
1732       if (!(ignore && ignore == sw))
1733         tty_printf ("card command %s failed: %s (0x%04x)\n", desc,
1734                     gpg_strerror (err),  sw);
1735     }
1736   return err;
1737 }
1738
1739
1740 /* Do a factory reset after confirmation.  */
1741 static void
1742 factory_reset (void)
1743 {
1744   struct agent_card_info_s info;
1745   gpg_error_t err;
1746   char *answer = NULL;
1747   int termstate = 0;
1748   int i;
1749
1750   /*  The code below basically does the same what this
1751       gpg-connect-agent script does:
1752
1753         scd reset
1754         scd serialno undefined
1755         scd apdu 00 A4 04 00 06 D2 76 00 01 24 01
1756         scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
1757         scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
1758         scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
1759         scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
1760         scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
1761         scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
1762         scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
1763         scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
1764         scd apdu 00 e6 00 00
1765         scd apdu 00 44 00 00
1766         /echo Card has been reset to factory defaults
1767
1768       but tries to find out something about the card first.
1769    */
1770
1771   err = agent_scd_learn (&info, 0);
1772   if (gpg_err_code (err) == GPG_ERR_OBJ_TERM_STATE
1773       && gpg_err_source (err) == GPG_ERR_SOURCE_SCD)
1774     termstate = 1;
1775   else if (err)
1776     {
1777       log_error (_("OpenPGP card not available: %s\n"), gpg_strerror (err));
1778       return;
1779     }
1780
1781   if (!termstate)
1782     {
1783       log_info (_("OpenPGP card no. %s detected\n"),
1784                 info.serialno? info.serialno : "[none]");
1785       if (!(info.status_indicator == 3 || info.status_indicator == 5))
1786         {
1787           /* Note: We won't see status-indicator 3 here because it is not
1788              possible to select a card application in termination state.  */
1789           log_error (_("This command is not supported by this card\n"));
1790           goto leave;
1791         }
1792
1793       tty_printf ("\n");
1794       log_info (_("Note: This command destroys all keys stored on the card!\n"));
1795       tty_printf ("\n");
1796       if (!cpr_get_answer_is_yes ("cardedit.factory-reset.proceed",
1797                                   _("Continue? (y/N) ")))
1798         goto leave;
1799
1800
1801       answer = cpr_get ("cardedit.factory-reset.really",
1802                         _("Really do a factory reset? (enter \"yes\") "));
1803       cpr_kill_prompt ();
1804       trim_spaces (answer);
1805       if (strcmp (answer, "yes"))
1806         goto leave;
1807
1808       /* We need to select a card application before we can send APDUs
1809          to the card without scdaemon doing anything on its own.  */
1810       err = send_apdu (NULL, "RESET", 0);
1811       if (err)
1812         goto leave;
1813       err = send_apdu ("undefined", "dummy select ", 0);
1814       if (err)
1815         goto leave;
1816
1817       /* Select the OpenPGP application.  */
1818       err = send_apdu ("00A4040006D27600012401", "SELECT AID", 0);
1819       if (err)
1820         goto leave;
1821
1822       /* Do some dummy verifies with wrong PINs to set the retry
1823          counter to zero.  We can't easily use the card version 2.1
1824          feature of presenting the admin PIN to allow the terminate
1825          command because there is no machinery in scdaemon to catch
1826          the verify command and ask for the PIN when the "APDU"
1827          command is used. */
1828       for (i=0; i < 4; i++)
1829         send_apdu ("00200081084040404040404040", "VERIFY", 0xffff);
1830       for (i=0; i < 4; i++)
1831         send_apdu ("00200083084040404040404040", "VERIFY", 0xffff);
1832
1833       /* Send terminate datafile command.  */
1834       err = send_apdu ("00e60000", "TERMINATE DF", 0x6985);
1835       if (err)
1836         goto leave;
1837     }
1838
1839   /* Send activate datafile command.  This is used without
1840      confirmation if the card is already in termination state.  */
1841   err = send_apdu ("00440000", "ACTIVATE DF", 0);
1842   if (err)
1843     goto leave;
1844
1845   /* Finally we reset the card reader once more.  */
1846   err = send_apdu (NULL, "RESET", 0);
1847   if (err)
1848     goto leave;
1849
1850  leave:
1851   xfree (answer);
1852   agent_release_card_info (&info);
1853 }
1854
1855
1856 \f
1857 /* Data used by the command parser.  This needs to be outside of the
1858    function scope to allow readline based command completion.  */
1859 enum cmdids
1860   {
1861     cmdNOP = 0,
1862     cmdQUIT, cmdADMIN, cmdHELP, cmdLIST, cmdDEBUG, cmdVERIFY,
1863     cmdNAME, cmdURL, cmdFETCH, cmdLOGIN, cmdLANG, cmdSEX, cmdCAFPR,
1864     cmdFORCESIG, cmdGENERATE, cmdPASSWD, cmdPRIVATEDO, cmdWRITECERT,
1865     cmdREADCERT, cmdUNBLOCK, cmdFACTORYRESET,
1866     cmdINVCMD
1867   };
1868
1869 static struct
1870 {
1871   const char *name;
1872   enum cmdids id;
1873   int admin_only;
1874   const char *desc;
1875 } cmds[] =
1876   {
1877     { "quit"    , cmdQUIT  , 0, N_("quit this menu")},
1878     { "q"       , cmdQUIT  , 0, NULL },
1879     { "admin"   , cmdADMIN , 0, N_("show admin commands")},
1880     { "help"    , cmdHELP  , 0, N_("show this help")},
1881     { "?"       , cmdHELP  , 0, NULL },
1882     { "list"    , cmdLIST  , 0, N_("list all available data")},
1883     { "l"       , cmdLIST  , 0, NULL },
1884     { "debug"   , cmdDEBUG , 0, NULL },
1885     { "name"    , cmdNAME  , 1, N_("change card holder's name")},
1886     { "url"     , cmdURL   , 1, N_("change URL to retrieve key")},
1887     { "fetch"   , cmdFETCH , 0, N_("fetch the key specified in the card URL")},
1888     { "login"   , cmdLOGIN , 1, N_("change the login name")},
1889     { "lang"    , cmdLANG  , 1, N_("change the language preferences")},
1890     { "sex"     , cmdSEX   , 1, N_("change card holder's sex")},
1891     { "cafpr"   , cmdCAFPR , 1, N_("change a CA fingerprint")},
1892     { "forcesig", cmdFORCESIG, 1, N_("toggle the signature force PIN flag")},
1893     { "generate", cmdGENERATE, 1, N_("generate new keys")},
1894     { "passwd"  , cmdPASSWD, 0, N_("menu to change or unblock the PIN")},
1895     { "verify"  , cmdVERIFY, 0, N_("verify the PIN and list all data")},
1896     { "unblock" , cmdUNBLOCK,0, N_("unblock the PIN using a Reset Code") },
1897     { "factory-reset", cmdFACTORYRESET, 1, N_("destroy all keys and data")},
1898     /* Note, that we do not announce these command yet. */
1899     { "privatedo", cmdPRIVATEDO, 0, NULL },
1900     { "readcert", cmdREADCERT, 0, NULL },
1901     { "writecert", cmdWRITECERT, 1, NULL },
1902     { NULL, cmdINVCMD, 0, NULL }
1903   };
1904
1905
1906 #ifdef HAVE_LIBREADLINE
1907
1908 /* These two functions are used by readline for command completion. */
1909
1910 static char *
1911 command_generator(const char *text,int state)
1912 {
1913   static int list_index,len;
1914   const char *name;
1915
1916   /* If this is a new word to complete, initialize now.  This includes
1917      saving the length of TEXT for efficiency, and initializing the
1918      index variable to 0. */
1919   if(!state)
1920     {
1921       list_index=0;
1922       len=strlen(text);
1923     }
1924
1925   /* Return the next partial match */
1926   while((name=cmds[list_index].name))
1927     {
1928       /* Only complete commands that have help text */
1929       if(cmds[list_index++].desc && strncmp(name,text,len)==0)
1930         return strdup(name);
1931     }
1932
1933   return NULL;
1934 }
1935
1936 static char **
1937 card_edit_completion(const char *text, int start, int end)
1938 {
1939   (void)end;
1940   /* If we are at the start of a line, we try and command-complete.
1941      If not, just do nothing for now. */
1942
1943   if(start==0)
1944     return rl_completion_matches(text,command_generator);
1945
1946   rl_attempted_completion_over=1;
1947
1948   return NULL;
1949 }
1950 #endif /*HAVE_LIBREADLINE*/
1951
1952 /* Menu to edit all user changeable values on an OpenPGP card.  Only
1953    Key creation is not handled here. */
1954 void
1955 card_edit (ctrl_t ctrl, strlist_t commands)
1956 {
1957   enum cmdids cmd = cmdNOP;
1958   int have_commands = !!commands;
1959   int redisplay = 1;
1960   char *answer = NULL;
1961   int allow_admin=0;
1962   char serialnobuf[50];
1963
1964
1965   if (opt.command_fd != -1)
1966     ;
1967   else if (opt.batch && !have_commands)
1968     {
1969       log_error(_("can't do this in batch mode\n"));
1970       goto leave;
1971     }
1972
1973   for (;;)
1974     {
1975       int arg_number;
1976       const char *arg_string = "";
1977       const char *arg_rest = "";
1978       char *p;
1979       int i;
1980       int cmd_admin_only;
1981
1982       tty_printf("\n");
1983       if (redisplay)
1984         {
1985           if (opt.with_colons)
1986             {
1987               current_card_status (ctrl, es_stdout,
1988                                    serialnobuf, DIM (serialnobuf));
1989               fflush (stdout);
1990             }
1991           else
1992             {
1993               current_card_status (ctrl, NULL,
1994                                    serialnobuf, DIM (serialnobuf));
1995               tty_printf("\n");
1996             }
1997           redisplay = 0;
1998         }
1999
2000       do
2001         {
2002           xfree (answer);
2003           if (have_commands)
2004             {
2005               if (commands)
2006                 {
2007                   answer = xstrdup (commands->d);
2008                   commands = commands->next;
2009                 }
2010               else if (opt.batch)
2011                 {
2012                   answer = xstrdup ("quit");
2013                 }
2014               else
2015                 have_commands = 0;
2016             }
2017
2018             if (!have_commands)
2019               {
2020                 tty_enable_completion (card_edit_completion);
2021                 answer = cpr_get_no_help("cardedit.prompt", _("gpg/card> "));
2022                 cpr_kill_prompt();
2023                 tty_disable_completion ();
2024               }
2025             trim_spaces(answer);
2026         }
2027       while ( *answer == '#' );
2028
2029       arg_number = 0; /* Yes, here is the init which egcc complains about */
2030       cmd_admin_only = 0;
2031       if (!*answer)
2032         cmd = cmdLIST; /* Default to the list command */
2033       else if (*answer == CONTROL_D)
2034         cmd = cmdQUIT;
2035       else
2036         {
2037           if ((p=strchr (answer,' ')))
2038             {
2039               *p++ = 0;
2040               trim_spaces (answer);
2041               trim_spaces (p);
2042               arg_number = atoi(p);
2043               arg_string = p;
2044               arg_rest = p;
2045               while (digitp (arg_rest))
2046                 arg_rest++;
2047               while (spacep (arg_rest))
2048                 arg_rest++;
2049             }
2050
2051           for (i=0; cmds[i].name; i++ )
2052             if (!ascii_strcasecmp (answer, cmds[i].name ))
2053               break;
2054
2055           cmd = cmds[i].id;
2056           cmd_admin_only = cmds[i].admin_only;
2057         }
2058
2059       if (!allow_admin && cmd_admin_only)
2060         {
2061           tty_printf ("\n");
2062           tty_printf (_("Admin-only command\n"));
2063           continue;
2064         }
2065
2066       switch (cmd)
2067         {
2068         case cmdHELP:
2069           for (i=0; cmds[i].name; i++ )
2070             if(cmds[i].desc
2071                && (!cmds[i].admin_only || (cmds[i].admin_only && allow_admin)))
2072               tty_printf("%-14s %s\n", cmds[i].name, _(cmds[i].desc) );
2073           break;
2074
2075         case cmdADMIN:
2076           if ( !strcmp (arg_string, "on") )
2077             allow_admin = 1;
2078           else if ( !strcmp (arg_string, "off") )
2079             allow_admin = 0;
2080           else if ( !strcmp (arg_string, "verify") )
2081             {
2082               /* Force verification of the Admin Command.  However,
2083                  this is only done if the retry counter is at initial
2084                  state.  */
2085               char *tmp = xmalloc (strlen (serialnobuf) + 6 + 1);
2086               strcpy (stpcpy (tmp, serialnobuf), "[CHV3]");
2087               allow_admin = !agent_scd_checkpin (tmp);
2088               xfree (tmp);
2089             }
2090           else /* Toggle. */
2091             allow_admin=!allow_admin;
2092           if(allow_admin)
2093             tty_printf(_("Admin commands are allowed\n"));
2094           else
2095             tty_printf(_("Admin commands are not allowed\n"));
2096           break;
2097
2098         case cmdVERIFY:
2099           agent_scd_checkpin (serialnobuf);
2100           redisplay = 1;
2101           break;
2102
2103         case cmdLIST:
2104           redisplay = 1;
2105           break;
2106
2107         case cmdNAME:
2108           change_name ();
2109           break;
2110
2111         case cmdURL:
2112           change_url ();
2113           break;
2114
2115         case cmdFETCH:
2116           fetch_url (ctrl);
2117           break;
2118
2119         case cmdLOGIN:
2120           change_login (arg_string);
2121           break;
2122
2123         case cmdLANG:
2124           change_lang ();
2125           break;
2126
2127         case cmdSEX:
2128           change_sex ();
2129           break;
2130
2131         case cmdCAFPR:
2132           if ( arg_number < 1 || arg_number > 3 )
2133             tty_printf ("usage: cafpr N\n"
2134                         "       1 <= N <= 3\n");
2135           else
2136             change_cafpr (arg_number);
2137           break;
2138
2139         case cmdPRIVATEDO:
2140           if ( arg_number < 1 || arg_number > 4 )
2141             tty_printf ("usage: privatedo N\n"
2142                         "       1 <= N <= 4\n");
2143           else
2144             change_private_do (arg_string, arg_number);
2145           break;
2146
2147         case cmdWRITECERT:
2148           if ( arg_number != 3 )
2149             tty_printf ("usage: writecert 3 < FILE\n");
2150           else
2151             change_cert (arg_rest);
2152           break;
2153
2154         case cmdREADCERT:
2155           if ( arg_number != 3 )
2156             tty_printf ("usage: readcert 3 > FILE\n");
2157           else
2158             read_cert (arg_rest);
2159           break;
2160
2161         case cmdFORCESIG:
2162           toggle_forcesig ();
2163           break;
2164
2165         case cmdGENERATE:
2166           generate_card_keys (ctrl);
2167           break;
2168
2169         case cmdPASSWD:
2170           change_pin (0, allow_admin);
2171           break;
2172
2173         case cmdUNBLOCK:
2174           change_pin (1, allow_admin);
2175           break;
2176
2177         case cmdFACTORYRESET:
2178           factory_reset ();
2179           break;
2180
2181         case cmdQUIT:
2182           goto leave;
2183
2184         case cmdNOP:
2185           break;
2186
2187         case cmdINVCMD:
2188         default:
2189           tty_printf ("\n");
2190           tty_printf (_("Invalid command  (try \"help\")\n"));
2191           break;
2192         } /* End command switch. */
2193     } /* End of main menu loop. */
2194
2195  leave:
2196   xfree (answer);
2197 }