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