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