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