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