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