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