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