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