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