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