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