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