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