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