g10/card-util.c

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