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