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