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