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