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