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