g10/call-agent.c

   1 /* call-agent.c - Divert GPG operations to the agent.
   2  * Copyright (C) 2001-2003, 2006-2011, 2013 Free Software Foundation, Inc.
   3  * Copyright (C) 2013-2015  Werner Koch
   4  *
   5  * This file is part of GnuPG.
   6  *
   7  * GnuPG is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 3 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * GnuPG is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, see <https://www.gnu.org/licenses/>.
  19  */
  20
  21 #include <config.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <errno.h>
  26 #include <unistd.h>
  27 #include <time.h>
  28 #ifdef HAVE_LOCALE_H
  29 #include <locale.h>
  30 #endif
  31
  32 #include "gpg.h"
  33 #include <assuan.h>
  34 #include "../common/util.h"
  35 #include "../common/membuf.h"
  36 #include "options.h"
  37 #include "../common/i18n.h"
  38 #include "../common/asshelp.h"
  39 #include "../common/sysutils.h"
  40 #include "call-agent.h"
  41 #include "../common/status.h"
  42 #include "../common/shareddefs.h"
  43 #include "../common/host2net.h"
  44
  45 #define CONTROL_D ('D' - 'A' + 1)
  46
  47
  48 static assuan_context_t agent_ctx = NULL;
  49 static int did_early_card_test;
  50
  51 struct default_inq_parm_s
  52 {
  53   ctrl_t ctrl;
  54   assuan_context_t ctx;
  55   struct {
  56     u32 *keyid;
  57     u32 *mainkeyid;
  58     int pubkey_algo;
  59   } keyinfo;
  60 };
  61
  62 struct cipher_parm_s
  63 {
  64   struct default_inq_parm_s *dflt;
  65   assuan_context_t ctx;
  66   unsigned char *ciphertext;
  67   size_t ciphertextlen;
  68 };
  69
  70 struct writecert_parm_s
  71 {
  72   struct default_inq_parm_s *dflt;
  73   const unsigned char *certdata;
  74   size_t certdatalen;
  75 };
  76
  77 struct writekey_parm_s
  78 {
  79   struct default_inq_parm_s *dflt;
  80   const unsigned char *keydata;
  81   size_t keydatalen;
  82 };
  83
  84 struct genkey_parm_s
  85 {
  86   struct default_inq_parm_s *dflt;
  87   const char *keyparms;
  88   const char *passphrase;
  89 };
  90
  91 struct import_key_parm_s
  92 {
  93   struct default_inq_parm_s *dflt;
  94   const void *key;
  95   size_t keylen;
  96 };
  97
  98
  99 struct cache_nonce_parm_s
 100 {
 101   char **cache_nonce_addr;
 102   char **passwd_nonce_addr;
 103 };
 104
 105
 106 static gpg_error_t learn_status_cb (void *opaque, const char *line);
 107
 108
 109 \f
 110 /* If RC is not 0, write an appropriate status message. */
 111 static void
 112 status_sc_op_failure (int rc)
 113 {
 114   switch (gpg_err_code (rc))
 115     {
 116     case 0:
 117       break;
 118     case GPG_ERR_CANCELED:
 119     case GPG_ERR_FULLY_CANCELED:
 120       write_status_text (STATUS_SC_OP_FAILURE, "1");
 121       break;
 122     case GPG_ERR_BAD_PIN:
 123       write_status_text (STATUS_SC_OP_FAILURE, "2");
 124       break;
 125     default:
 126       write_status (STATUS_SC_OP_FAILURE);
 127       break;
 128     }
 129 }
 130
 131
 132 /* This is the default inquiry callback.  It mainly handles the
 133    Pinentry notifications.  */
 134 static gpg_error_t
 135 default_inq_cb (void *opaque, const char *line)
 136 {
 137   gpg_error_t err = 0;
 138   struct default_inq_parm_s *parm = opaque;
 139
 140   if (has_leading_keyword (line, "PINENTRY_LAUNCHED"))
 141     {
 142       err = gpg_proxy_pinentry_notify (parm->ctrl, line);
 143       if (err)
 144         log_error (_("failed to proxy %s inquiry to client\n"),
 145                    "PINENTRY_LAUNCHED");
 146       /* We do not pass errors to avoid breaking other code.  */
 147     }
 148   else if ((has_leading_keyword (line, "PASSPHRASE")
 149             || has_leading_keyword (line, "NEW_PASSPHRASE"))
 150            && opt.pinentry_mode == PINENTRY_MODE_LOOPBACK)
 151     {
 152       if (have_static_passphrase ())
 153         {
 154           const char *s = get_static_passphrase ();
 155           err = assuan_send_data (parm->ctx, s, strlen (s));
 156         }
 157       else
 158         {
 159           char *pw;
 160           char buf[32];
 161
 162           if (parm->keyinfo.keyid)
 163             emit_status_need_passphrase (parm->ctrl,
 164                                          parm->keyinfo.keyid,
 165                                          parm->keyinfo.mainkeyid,
 166                                          parm->keyinfo.pubkey_algo);
 167
 168           snprintf (buf, sizeof (buf), "%u", 100);
 169           write_status_text (STATUS_INQUIRE_MAXLEN, buf);
 170           pw = cpr_get_hidden ("passphrase.enter", _("Enter passphrase: "));
 171           cpr_kill_prompt ();
 172           if (*pw == CONTROL_D && !pw[1])
 173             err = gpg_error (GPG_ERR_CANCELED);
 174           else
 175             err = assuan_send_data (parm->ctx, pw, strlen (pw));
 176           xfree (pw);
 177         }
 178     }
 179   else
 180     log_debug ("ignoring gpg-agent inquiry '%s'\n", line);
 181
 182   return err;
 183 }
 184
 185
 186 /* Print a warning if the server's version number is less than our
 187    version number.  Returns an error code on a connection problem.  */
 188 static gpg_error_t
 189 warn_version_mismatch (assuan_context_t ctx, const char *servername, int mode)
 190 {
 191   gpg_error_t err;
 192   char *serverversion;
 193   const char *myversion = strusage (13);
 194
 195   err = get_assuan_server_version (ctx, mode, &serverversion);
 196   if (err)
 197     log_log (gpg_err_code (err) == GPG_ERR_NOT_SUPPORTED?
 198              GPGRT_LOG_INFO : GPGRT_LOG_ERROR,
 199              _("error getting version from '%s': %s\n"),
 200              servername, gpg_strerror (err));
 201   else if (compare_version_strings (serverversion, myversion) < 0)
 202     {
 203       char *warn;
 204
 205       warn = xtryasprintf (_("server '%s' is older than us (%s < %s)"),
 206                            servername, serverversion, myversion);
 207       if (!warn)
 208         err = gpg_error_from_syserror ();
 209       else
 210         {
 211           log_info (_("WARNING: %s\n"), warn);
 212           if (!opt.quiet)
 213             {
 214               log_info (_("Note: Outdated servers may lack important"
 215                           " security fixes.\n"));
 216               log_info (_("Note: Use the command \"%s\" to restart them.\n"),
 217                         "gpgconf --kill all");
 218             }
 219           write_status_strings (STATUS_WARNING, "server_version_mismatch 0",
 220                                 " ", warn, NULL);
 221           xfree (warn);
 222         }
 223     }
 224   xfree (serverversion);
 225   return err;
 226 }
 227
 228
 229 #define FLAG_FOR_CARD_SUPPRESS_ERRORS 2
 230
 231 /* Try to connect to the agent via socket or fork it off and work by
 232    pipes.  Handle the server's initial greeting */
 233 static int
 234 start_agent (ctrl_t ctrl, int flag_for_card)
 235 {
 236   int rc;
 237
 238   (void)ctrl;  /* Not yet used.  */
 239
 240   /* Fixme: We need a context for each thread or serialize the access
 241      to the agent. */
 242   if (agent_ctx)
 243     rc = 0;
 244   else
 245     {
 246       rc = start_new_gpg_agent (&agent_ctx,
 247                                 GPG_ERR_SOURCE_DEFAULT,
 248                                 opt.agent_program,
 249                                 opt.lc_ctype, opt.lc_messages,
 250                                 opt.session_env,
 251                                 opt.autostart, opt.verbose, DBG_IPC,
 252                                 NULL, NULL);
 253       if (!opt.autostart && gpg_err_code (rc) == GPG_ERR_NO_AGENT)
 254         {
 255           static int shown;
 256
 257           if (!shown)
 258             {
 259               shown = 1;
 260               log_info (_("no gpg-agent running in this session\n"));
 261             }
 262         }
 263       else if (!rc
 264                && !(rc = warn_version_mismatch (agent_ctx, GPG_AGENT_NAME, 0)))
 265         {
 266           /* Tell the agent that we support Pinentry notifications.
 267              No error checking so that it will work also with older
 268              agents.  */
 269           assuan_transact (agent_ctx, "OPTION allow-pinentry-notify",
 270                            NULL, NULL, NULL, NULL, NULL, NULL);
 271           /* Tell the agent about what version we are aware.  This is
 272              here used to indirectly enable GPG_ERR_FULLY_CANCELED.  */
 273           assuan_transact (agent_ctx, "OPTION agent-awareness=2.1.0",
 274                            NULL, NULL, NULL, NULL, NULL, NULL);
 275           /* Pass on the pinentry mode.  */
 276           if (opt.pinentry_mode)
 277             {
 278               char *tmp = xasprintf ("OPTION pinentry-mode=%s",
 279                                      str_pinentry_mode (opt.pinentry_mode));
 280               rc = assuan_transact (agent_ctx, tmp,
 281                                NULL, NULL, NULL, NULL, NULL, NULL);
 282               xfree (tmp);
 283               if (rc)
 284                 {
 285                   log_error ("setting pinentry mode '%s' failed: %s\n",
 286                              str_pinentry_mode (opt.pinentry_mode),
 287                              gpg_strerror (rc));
 288                   write_status_error ("set_pinentry_mode", rc);
 289                 }
 290             }
 291
 292           /* In DE_VS mode under Windows we require that the JENT RNG
 293            * is active.  */
 294 #ifdef HAVE_W32_SYSTEM
 295           if (!rc && opt.compliance == CO_DE_VS)
 296             {
 297               if (assuan_transact (agent_ctx, "GETINFO jent_active",
 298                                    NULL, NULL, NULL, NULL, NULL, NULL))
 299                 {
 300                   rc = gpg_error (GPG_ERR_FORBIDDEN);
 301                   log_error (_("%s is not compliant with %s mode\n"),
 302                              GPG_AGENT_NAME,
 303                              gnupg_compliance_option_string (opt.compliance));
 304                   write_status_error ("random-compliance", rc);
 305                 }
 306             }
 307 #endif /*HAVE_W32_SYSTEM*/
 308
 309         }
 310     }
 311
 312   if (!rc && flag_for_card && !did_early_card_test)
 313     {
 314       /* Request the serial number of the card for an early test.  */
 315       struct agent_card_info_s info;
 316
 317       memset (&info, 0, sizeof info);
 318
 319       if (!(flag_for_card & FLAG_FOR_CARD_SUPPRESS_ERRORS))
 320         rc = warn_version_mismatch (agent_ctx, SCDAEMON_NAME, 2);
 321       if (!rc)
 322         rc = assuan_transact (agent_ctx, "SCD SERIALNO openpgp",
 323                               NULL, NULL, NULL, NULL,
 324                               learn_status_cb, &info);
 325       if (rc && !(flag_for_card & FLAG_FOR_CARD_SUPPRESS_ERRORS))
 326         {
 327           switch (gpg_err_code (rc))
 328             {
 329             case GPG_ERR_NOT_SUPPORTED:
 330             case GPG_ERR_NO_SCDAEMON:
 331               write_status_text (STATUS_CARDCTRL, "6");
 332               break;
 333             case GPG_ERR_OBJ_TERM_STATE:
 334               write_status_text (STATUS_CARDCTRL, "7");
 335               break;
 336             default:
 337               write_status_text (STATUS_CARDCTRL, "4");
 338               log_info ("selecting openpgp failed: %s\n", gpg_strerror (rc));
 339               break;
 340             }
 341         }
 342
 343       if (!rc && is_status_enabled () && info.serialno)
 344         {
 345           char *buf;
 346
 347           buf = xasprintf ("3 %s", info.serialno);
 348           write_status_text (STATUS_CARDCTRL, buf);
 349           xfree (buf);
 350         }
 351
 352       agent_release_card_info (&info);
 353
 354       if (!rc)
 355         did_early_card_test = 1;
 356     }
 357
 358
 359   return rc;
 360 }
 361
 362
 363 /* Return a new malloced string by unescaping the string S.  Escaping
 364    is percent escaping and '+'/space mapping.  A binary nul will
 365    silently be replaced by a 0xFF.  Function returns NULL to indicate
 366    an out of memory status. */
 367 static char *
 368 unescape_status_string (const unsigned char *s)
 369 {
 370   return percent_plus_unescape (s, 0xff);
 371 }
 372
 373
 374 /* Take a 20 byte hexencoded string and put it into the provided
 375    20 byte buffer FPR in binary format. */
 376 static int
 377 unhexify_fpr (const char *hexstr, unsigned char *fpr)
 378 {
 379   const char *s;
 380   int n;
 381
 382   for (s=hexstr, n=0; hexdigitp (s); s++, n++)
 383     ;
 384   if (*s || (n != 40))
 385     return 0; /* no fingerprint (invalid or wrong length). */
 386   for (s=hexstr, n=0; *s; s += 2, n++)
 387     fpr[n] = xtoi_2 (s);
 388   return 1; /* okay */
 389 }
 390
 391 /* Take the serial number from LINE and return it verbatim in a newly
 392    allocated string.  We make sure that only hex characters are
 393    returned. */
 394 static char *
 395 store_serialno (const char *line)
 396 {
 397   const char *s;
 398   char *p;
 399
 400   for (s=line; hexdigitp (s); s++)
 401     ;
 402   p = xtrymalloc (s + 1 - line);
 403   if (p)
 404     {
 405       memcpy (p, line, s-line);
 406       p[s-line] = 0;
 407     }
 408   return p;
 409 }
 410
 411
 412 \f
 413 /* This is a dummy data line callback.  */
 414 static gpg_error_t
 415 dummy_data_cb (void *opaque, const void *buffer, size_t length)
 416 {
 417   (void)opaque;
 418   (void)buffer;
 419   (void)length;
 420   return 0;
 421 }
 422
 423 /* A simple callback used to return the serialnumber of a card.  */
 424 static gpg_error_t
 425 get_serialno_cb (void *opaque, const char *line)
 426 {
 427   char **serialno = opaque;
 428   const char *keyword = line;
 429   const char *s;
 430   int keywordlen, n;
 431
 432   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
 433     ;
 434   while (spacep (line))
 435     line++;
 436
 437   if (keywordlen == 8 && !memcmp (keyword, "SERIALNO", keywordlen))
 438     {
 439       if (*serialno)
 440         return gpg_error (GPG_ERR_CONFLICT); /* Unexpected status line. */
 441       for (n=0,s=line; hexdigitp (s); s++, n++)
 442         ;
 443       if (!n || (n&1)|| !(spacep (s) || !*s) )
 444         return gpg_error (GPG_ERR_ASS_PARAMETER);
 445       *serialno = xtrymalloc (n+1);
 446       if (!*serialno)
 447         return out_of_core ();
 448       memcpy (*serialno, line, n);
 449       (*serialno)[n] = 0;
 450     }
 451
 452   return 0;
 453 }
 454
 455
 456
 457 /* Release the card info structure INFO. */
 458 void
 459 agent_release_card_info (struct agent_card_info_s *info)
 460 {
 461   int i;
 462
 463   if (!info)
 464     return;
 465
 466   xfree (info->reader); info->reader = NULL;
 467   xfree (info->serialno); info->serialno = NULL;
 468   xfree (info->apptype); info->apptype = NULL;
 469   xfree (info->disp_name); info->disp_name = NULL;
 470   xfree (info->disp_lang); info->disp_lang = NULL;
 471   xfree (info->pubkey_url); info->pubkey_url = NULL;
 472   xfree (info->login_data); info->login_data = NULL;
 473   info->cafpr1valid = info->cafpr2valid = info->cafpr3valid = 0;
 474   info->fpr1valid = info->fpr2valid = info->fpr3valid = 0;
 475   for (i=0; i < DIM(info->private_do); i++)
 476     {
 477       xfree (info->private_do[i]);
 478       info->private_do[i] = NULL;
 479     }
 480 }
 481
 482
 483 static gpg_error_t
 484 learn_status_cb (void *opaque, const char *line)
 485 {
 486   struct agent_card_info_s *parm = opaque;
 487   const char *keyword = line;
 488   int keywordlen;
 489   int i;
 490
 491   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
 492     ;
 493   while (spacep (line))
 494     line++;
 495
 496   if (keywordlen == 6 && !memcmp (keyword, "READER", keywordlen))
 497     {
 498       xfree (parm->reader);
 499       parm->reader = unescape_status_string (line);
 500     }
 501   else if (keywordlen == 8 && !memcmp (keyword, "SERIALNO", keywordlen))
 502     {
 503       xfree (parm->serialno);
 504       parm->serialno = store_serialno (line);
 505       parm->is_v2 = (strlen (parm->serialno) >= 16
 506                      && xtoi_2 (parm->serialno+12) >= 2 );
 507     }
 508   else if (keywordlen == 7 && !memcmp (keyword, "APPTYPE", keywordlen))
 509     {
 510       xfree (parm->apptype);
 511       parm->apptype = unescape_status_string (line);
 512     }
 513   else if (keywordlen == 9 && !memcmp (keyword, "DISP-NAME", keywordlen))
 514     {
 515       xfree (parm->disp_name);
 516       parm->disp_name = unescape_status_string (line);
 517     }
 518   else if (keywordlen == 9 && !memcmp (keyword, "DISP-LANG", keywordlen))
 519     {
 520       xfree (parm->disp_lang);
 521       parm->disp_lang = unescape_status_string (line);
 522     }
 523   else if (keywordlen == 8 && !memcmp (keyword, "DISP-SEX", keywordlen))
 524     {
 525       parm->disp_sex = *line == '1'? 1 : *line == '2' ? 2: 0;
 526     }
 527   else if (keywordlen == 10 && !memcmp (keyword, "PUBKEY-URL", keywordlen))
 528     {
 529       xfree (parm->pubkey_url);
 530       parm->pubkey_url = unescape_status_string (line);
 531     }
 532   else if (keywordlen == 10 && !memcmp (keyword, "LOGIN-DATA", keywordlen))
 533     {
 534       xfree (parm->login_data);
 535       parm->login_data = unescape_status_string (line);
 536     }
 537   else if (keywordlen == 11 && !memcmp (keyword, "SIG-COUNTER", keywordlen))
 538     {
 539       parm->sig_counter = strtoul (line, NULL, 0);
 540     }
 541   else if (keywordlen == 10 && !memcmp (keyword, "CHV-STATUS", keywordlen))
 542     {
 543       char *p, *buf;
 544
 545       buf = p = unescape_status_string (line);
 546       if (buf)
 547         {
 548           while (spacep (p))
 549             p++;
 550           parm->chv1_cached = atoi (p);
 551           while (*p && !spacep (p))
 552             p++;
 553           while (spacep (p))
 554             p++;
 555           for (i=0; *p && i < 3; i++)
 556             {
 557               parm->chvmaxlen[i] = atoi (p);
 558               while (*p && !spacep (p))
 559                 p++;
 560               while (spacep (p))
 561                 p++;
 562             }
 563           for (i=0; *p && i < 3; i++)
 564             {
 565               parm->chvretry[i] = atoi (p);
 566               while (*p && !spacep (p))
 567                 p++;
 568               while (spacep (p))
 569                 p++;
 570             }
 571           xfree (buf);
 572         }
 573     }
 574   else if (keywordlen == 6 && !memcmp (keyword, "EXTCAP", keywordlen))
 575     {
 576       char *p, *p2, *buf;
 577       int abool;
 578
 579       buf = p = unescape_status_string (line);
 580       if (buf)
 581         {
 582           for (p = strtok (buf, " "); p; p = strtok (NULL, " "))
 583             {
 584               p2 = strchr (p, '=');
 585               if (p2)
 586                 {
 587                   *p2++ = 0;
 588                   abool = (*p2 == '1');
 589                   if (!strcmp (p, "ki"))
 590                     parm->extcap.ki = abool;
 591                   else if (!strcmp (p, "aac"))
 592                     parm->extcap.aac = abool;
 593                   else if (!strcmp (p, "si"))
 594                     parm->status_indicator = strtoul (p2, NULL, 10);
 595                 }
 596             }
 597           xfree (buf);
 598         }
 599     }
 600   else if (keywordlen == 7 && !memcmp (keyword, "KEY-FPR", keywordlen))
 601     {
 602       int no = atoi (line);
 603       while (*line && !spacep (line))
 604         line++;
 605       while (spacep (line))
 606         line++;
 607       if (no == 1)
 608         parm->fpr1valid = unhexify_fpr (line, parm->fpr1);
 609       else if (no == 2)
 610         parm->fpr2valid = unhexify_fpr (line, parm->fpr2);
 611       else if (no == 3)
 612         parm->fpr3valid = unhexify_fpr (line, parm->fpr3);
 613     }
 614   else if (keywordlen == 8 && !memcmp (keyword, "KEY-TIME", keywordlen))
 615     {
 616       int no = atoi (line);
 617       while (* line && !spacep (line))
 618         line++;
 619       while (spacep (line))
 620         line++;
 621       if (no == 1)
 622         parm->fpr1time = strtoul (line, NULL, 10);
 623       else if (no == 2)
 624         parm->fpr2time = strtoul (line, NULL, 10);
 625       else if (no == 3)
 626         parm->fpr3time = strtoul (line, NULL, 10);
 627     }
 628   else if (keywordlen == 6 && !memcmp (keyword, "CA-FPR", keywordlen))
 629     {
 630       int no = atoi (line);
 631       while (*line && !spacep (line))
 632         line++;
 633       while (spacep (line))
 634         line++;
 635       if (no == 1)
 636         parm->cafpr1valid = unhexify_fpr (line, parm->cafpr1);
 637       else if (no == 2)
 638         parm->cafpr2valid = unhexify_fpr (line, parm->cafpr2);
 639       else if (no == 3)
 640         parm->cafpr3valid = unhexify_fpr (line, parm->cafpr3);
 641     }
 642   else if (keywordlen == 8 && !memcmp (keyword, "KEY-ATTR", keywordlen))
 643     {
 644       int keyno = 0;
 645       int algo = PUBKEY_ALGO_RSA;
 646       int n = 0;
 647
 648       sscanf (line, "%d %d %n", &keyno, &algo, &n);
 649       keyno--;
 650       if (keyno < 0 || keyno >= DIM (parm->key_attr))
 651         return 0;
 652
 653       parm->key_attr[keyno].algo = algo;
 654       if (algo == PUBKEY_ALGO_RSA)
 655         parm->key_attr[keyno].nbits = strtoul (line+n+3, NULL, 10);
 656       else if (algo == PUBKEY_ALGO_ECDH || algo == PUBKEY_ALGO_ECDSA
 657                || algo == PUBKEY_ALGO_EDDSA)
 658         parm->key_attr[keyno].curve = openpgp_is_curve_supported (line + n,
 659                                                                   NULL, NULL);
 660     }
 661   else if (keywordlen == 12 && !memcmp (keyword, "PRIVATE-DO-", 11)
 662            && strchr("1234", keyword[11]))
 663     {
 664       int no = keyword[11] - '1';
 665       log_assert (no >= 0 && no <= 3);
 666       xfree (parm->private_do[no]);
 667       parm->private_do[no] = unescape_status_string (line);
 668     }
 669
 670   return 0;
 671 }
 672
 673 /* Call the scdaemon to learn about a smartcard */
 674 int
 675 agent_scd_learn (struct agent_card_info_s *info, int force)
 676 {
 677   int rc;
 678   struct default_inq_parm_s parm;
 679   struct agent_card_info_s dummyinfo;
 680
 681   if (!info)
 682     info = &dummyinfo;
 683   memset (info, 0, sizeof *info);
 684   memset (&parm, 0, sizeof parm);
 685
 686   rc = start_agent (NULL, 1);
 687   if (rc)
 688     return rc;
 689
 690   parm.ctx = agent_ctx;
 691   rc = assuan_transact (agent_ctx,
 692                         force ? "LEARN --sendinfo --force" : "LEARN --sendinfo",
 693                         dummy_data_cb, NULL, default_inq_cb, &parm,
 694                         learn_status_cb, info);
 695   /* Also try to get the key attributes.  */
 696   if (!rc)
 697     agent_scd_getattr ("KEY-ATTR", info);
 698
 699   if (info == &dummyinfo)
 700     agent_release_card_info (info);
 701
 702   return rc;
 703 }
 704
 705
 706 /* Send an APDU to the current card.  On success the status word is
 707    stored at R_SW.  With HEXAPDU being NULL only a RESET command is
 708    send to scd.  With HEXAPDU being the string "undefined" the command
 709    "SERIALNO undefined" is send to scd. */
 710 gpg_error_t
 711 agent_scd_apdu (const char *hexapdu, unsigned int *r_sw)
 712 {
 713   gpg_error_t err;
 714
 715   /* Start the agent but not with the card flag so that we do not
 716      autoselect the openpgp application.  */
 717   err = start_agent (NULL, 0);
 718   if (err)
 719     return err;
 720
 721   if (!hexapdu)
 722     {
 723       err = assuan_transact (agent_ctx, "SCD RESET",
 724                              NULL, NULL, NULL, NULL, NULL, NULL);
 725
 726     }
 727   else if (!strcmp (hexapdu, "undefined"))
 728     {
 729       err = assuan_transact (agent_ctx, "SCD SERIALNO undefined",
 730                              NULL, NULL, NULL, NULL, NULL, NULL);
 731     }
 732   else
 733     {
 734       char line[ASSUAN_LINELENGTH];
 735       membuf_t mb;
 736       unsigned char *data;
 737       size_t datalen;
 738
 739       init_membuf (&mb, 256);
 740
 741       snprintf (line, DIM(line), "SCD APDU %s", hexapdu);
 742       err = assuan_transact (agent_ctx, line,
 743                              put_membuf_cb, &mb, NULL, NULL, NULL, NULL);
 744       if (!err)
 745         {
 746           data = get_membuf (&mb, &datalen);
 747           if (!data)
 748             err = gpg_error_from_syserror ();
 749           else if (datalen < 2) /* Ooops */
 750             err = gpg_error (GPG_ERR_CARD);
 751           else
 752             {
 753               *r_sw = buf16_to_uint (data+datalen-2);
 754             }
 755           xfree (data);
 756         }
 757     }
 758
 759   return err;
 760 }
 761
 762
 763 int
 764 agent_keytocard (const char *hexgrip, int keyno, int force,
 765                  const char *serialno, const char *timestamp)
 766 {
 767   int rc;
 768   char line[ASSUAN_LINELENGTH];
 769   struct default_inq_parm_s parm;
 770
 771   memset (&parm, 0, sizeof parm);
 772
 773   snprintf (line, DIM(line), "KEYTOCARD %s%s %s OPENPGP.%d %s",
 774             force?"--force ": "", hexgrip, serialno, keyno, timestamp);
 775
 776   rc = start_agent (NULL, 1);
 777   if (rc)
 778     return rc;
 779   parm.ctx = agent_ctx;
 780
 781   rc = assuan_transact (agent_ctx, line, NULL, NULL, default_inq_cb, &parm,
 782                         NULL, NULL);
 783   if (rc)
 784     return rc;
 785
 786   return rc;
 787 }
 788 \f
 789 /* Call the agent to retrieve a data object.  This function returns
 790    the data in the same structure as used by the learn command.  It is
 791    allowed to update such a structure using this command. */
 792 int
 793 agent_scd_getattr (const char *name, struct agent_card_info_s *info)
 794 {
 795   int rc;
 796   char line[ASSUAN_LINELENGTH];
 797   struct default_inq_parm_s parm;
 798
 799   memset (&parm, 0, sizeof parm);
 800
 801   if (!*name)
 802     return gpg_error (GPG_ERR_INV_VALUE);
 803
 804   /* We assume that NAME does not need escaping. */
 805   if (12 + strlen (name) > DIM(line)-1)
 806     return gpg_error (GPG_ERR_TOO_LARGE);
 807   stpcpy (stpcpy (line, "SCD GETATTR "), name);
 808
 809   rc = start_agent (NULL, 1);
 810   if (rc)
 811     return rc;
 812
 813   parm.ctx = agent_ctx;
 814   rc = assuan_transact (agent_ctx, line, NULL, NULL, default_inq_cb, &parm,
 815                         learn_status_cb, info);
 816
 817   return rc;
 818 }
 819
 820 \f
 821 /* Send an setattr command to the SCdaemon.  SERIALNO is not actually
 822    used here but required by gpg 1.4's implementation of this code in
 823    cardglue.c. */
 824 int
 825 agent_scd_setattr (const char *name,
 826                    const unsigned char *value, size_t valuelen,
 827                    const char *serialno)
 828 {
 829   int rc;
 830   char line[ASSUAN_LINELENGTH];
 831   char *p;
 832   struct default_inq_parm_s parm;
 833
 834   memset (&parm, 0, sizeof parm);
 835
 836   (void)serialno;
 837
 838   if (!*name || !valuelen)
 839     return gpg_error (GPG_ERR_INV_VALUE);
 840
 841   /* We assume that NAME does not need escaping. */
 842   if (12 + strlen (name) > DIM(line)-1)
 843     return gpg_error (GPG_ERR_TOO_LARGE);
 844
 845   p = stpcpy (stpcpy (line, "SCD SETATTR "), name);
 846   *p++ = ' ';
 847   for (; valuelen; value++, valuelen--)
 848     {
 849       if (p >= line + DIM(line)-5 )
 850         return gpg_error (GPG_ERR_TOO_LARGE);
 851       if (*value < ' ' || *value == '+' || *value == '%')
 852         {
 853           sprintf (p, "%%%02X", *value);
 854           p += 3;
 855         }
 856       else if (*value == ' ')
 857         *p++ = '+';
 858       else
 859         *p++ = *value;
 860     }
 861   *p = 0;
 862
 863   rc = start_agent (NULL, 1);
 864   if (!rc)
 865     {
 866       parm.ctx = agent_ctx;
 867       rc = assuan_transact (agent_ctx, line, NULL, NULL,
 868                             default_inq_cb, &parm, NULL, NULL);
 869     }
 870
 871   status_sc_op_failure (rc);
 872   return rc;
 873 }
 874
 875
 876 \f
 877 /* Handle a CERTDATA inquiry.  Note, we only send the data,
 878    assuan_transact takes care of flushing and writing the END
 879    command. */
 880 static gpg_error_t
 881 inq_writecert_parms (void *opaque, const char *line)
 882 {
 883   int rc;
 884   struct writecert_parm_s *parm = opaque;
 885
 886   if (has_leading_keyword (line, "CERTDATA"))
 887     {
 888       rc = assuan_send_data (parm->dflt->ctx,
 889                              parm->certdata, parm->certdatalen);
 890     }
 891   else
 892     rc = default_inq_cb (parm->dflt, line);
 893
 894   return rc;
 895 }
 896
 897
 898 /* Send a WRITECERT command to the SCdaemon. */
 899 int
 900 agent_scd_writecert (const char *certidstr,
 901                      const unsigned char *certdata, size_t certdatalen)
 902 {
 903   int rc;
 904   char line[ASSUAN_LINELENGTH];
 905   struct writecert_parm_s parms;
 906   struct default_inq_parm_s dfltparm;
 907
 908   memset (&dfltparm, 0, sizeof dfltparm);
 909
 910   rc = start_agent (NULL, 1);
 911   if (rc)
 912     return rc;
 913
 914   memset (&parms, 0, sizeof parms);
 915
 916   snprintf (line, DIM(line), "SCD WRITECERT %s", certidstr);
 917   dfltparm.ctx = agent_ctx;
 918   parms.dflt = &dfltparm;
 919   parms.certdata = certdata;
 920   parms.certdatalen = certdatalen;
 921
 922   rc = assuan_transact (agent_ctx, line, NULL, NULL,
 923                         inq_writecert_parms, &parms, NULL, NULL);
 924
 925   return rc;
 926 }
 927
 928
 929 \f
 930 /* Handle a KEYDATA inquiry.  Note, we only send the data,
 931    assuan_transact takes care of flushing and writing the end */
 932 static gpg_error_t
 933 inq_writekey_parms (void *opaque, const char *line)
 934 {
 935   int rc;
 936   struct writekey_parm_s *parm = opaque;
 937
 938   if (has_leading_keyword (line, "KEYDATA"))
 939     {
 940       rc = assuan_send_data (parm->dflt->ctx, parm->keydata, parm->keydatalen);
 941     }
 942   else
 943     rc = default_inq_cb (parm->dflt, line);
 944
 945   return rc;
 946 }
 947
 948
 949 /* Send a WRITEKEY command to the SCdaemon. */
 950 int
 951 agent_scd_writekey (int keyno, const char *serialno,
 952                     const unsigned char *keydata, size_t keydatalen)
 953 {
 954   int rc;
 955   char line[ASSUAN_LINELENGTH];
 956   struct writekey_parm_s parms;
 957   struct default_inq_parm_s dfltparm;
 958
 959   memset (&dfltparm, 0, sizeof dfltparm);
 960
 961   (void)serialno;
 962
 963   rc = start_agent (NULL, 1);
 964   if (rc)
 965     return rc;
 966
 967   memset (&parms, 0, sizeof parms);
 968
 969   snprintf (line, DIM(line), "SCD WRITEKEY --force OPENPGP.%d", keyno);
 970   dfltparm.ctx = agent_ctx;
 971   parms.dflt = &dfltparm;
 972   parms.keydata = keydata;
 973   parms.keydatalen = keydatalen;
 974
 975   rc = assuan_transact (agent_ctx, line, NULL, NULL,
 976                         inq_writekey_parms, &parms, NULL, NULL);
 977
 978   status_sc_op_failure (rc);
 979   return rc;
 980 }
 981
 982
 983 \f
 984 /* Status callback for the SCD GENKEY command. */
 985 static gpg_error_t
 986 scd_genkey_cb (void *opaque, const char *line)
 987 {
 988   u32 *createtime = opaque;
 989   const char *keyword = line;
 990   int keywordlen;
 991
 992   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
 993     ;
 994   while (spacep (line))
 995     line++;
 996
 997  if (keywordlen == 14 && !memcmp (keyword,"KEY-CREATED-AT", keywordlen))
 998     {
 999       *createtime = (u32)strtoul (line, NULL, 10);
1000     }
1001   else if (keywordlen == 8 && !memcmp (keyword, "PROGRESS", keywordlen))
1002     {
1003       write_status_text (STATUS_PROGRESS, line);
1004     }
1005
1006   return 0;
1007 }
1008
1009 /* Send a GENKEY command to the SCdaemon.  If *CREATETIME is not 0,
1010   the value will be passed to SCDAEMON with --timestamp option so that
1011   the key is created with this.  Otherwise, timestamp was generated by
1012   SCDEAMON.  On success, creation time is stored back to
1013   CREATETIME.  */
1014 int
1015 agent_scd_genkey (int keyno, int force, u32 *createtime)
1016 {
1017   int rc;
1018   char line[ASSUAN_LINELENGTH];
1019   gnupg_isotime_t tbuf;
1020   struct default_inq_parm_s dfltparm;
1021
1022   memset (&dfltparm, 0, sizeof dfltparm);
1023
1024   rc = start_agent (NULL, 1);
1025   if (rc)
1026     return rc;
1027
1028   if (*createtime)
1029     epoch2isotime (tbuf, *createtime);
1030   else
1031     *tbuf = 0;
1032
1033   snprintf (line, DIM(line), "SCD GENKEY %s%s %s %d",
1034             *tbuf? "--timestamp=":"", tbuf,
1035             force? "--force":"",
1036             keyno);
1037
1038   dfltparm.ctx = agent_ctx;
1039   rc = assuan_transact (agent_ctx, line,
1040                         NULL, NULL, default_inq_cb, &dfltparm,
1041                         scd_genkey_cb, createtime);
1042
1043   status_sc_op_failure (rc);
1044   return rc;
1045 }
1046 \f
1047 /* Return the serial number of the card or an appropriate error.  The
1048    serial number is returned as a hexstring. */
1049 int
1050 agent_scd_serialno (char **r_serialno, const char *demand)
1051 {
1052   int err;
1053   char *serialno = NULL;
1054   char line[ASSUAN_LINELENGTH];
1055
1056   err = start_agent (NULL, 1 | FLAG_FOR_CARD_SUPPRESS_ERRORS);
1057   if (err)
1058     return err;
1059
1060   if (!demand)
1061     strcpy (line, "SCD SERIALNO");
1062   else
1063     snprintf (line, DIM(line), "SCD SERIALNO --demand=%s", demand);
1064
1065   err = assuan_transact (agent_ctx, line,
1066                          NULL, NULL, NULL, NULL,
1067                          get_serialno_cb, &serialno);
1068   if (err)
1069     {
1070       xfree (serialno);
1071       return err;
1072     }
1073
1074   *r_serialno = serialno;
1075   return 0;
1076 }
1077 \f
1078 /* Send a READCERT command to the SCdaemon. */
1079 int
1080 agent_scd_readcert (const char *certidstr,
1081                     void **r_buf, size_t *r_buflen)
1082 {
1083   int rc;
1084   char line[ASSUAN_LINELENGTH];
1085   membuf_t data;
1086   size_t len;
1087   struct default_inq_parm_s dfltparm;
1088
1089   memset (&dfltparm, 0, sizeof dfltparm);
1090
1091   *r_buf = NULL;
1092   rc = start_agent (NULL, 1);
1093   if (rc)
1094     return rc;
1095
1096   dfltparm.ctx = agent_ctx;
1097
1098   init_membuf (&data, 2048);
1099
1100   snprintf (line, DIM(line), "SCD READCERT %s", certidstr);
1101   rc = assuan_transact (agent_ctx, line,
1102                         put_membuf_cb, &data,
1103                         default_inq_cb, &dfltparm,
1104                         NULL, NULL);
1105   if (rc)
1106     {
1107       xfree (get_membuf (&data, &len));
1108       return rc;
1109     }
1110   *r_buf = get_membuf (&data, r_buflen);
1111   if (!*r_buf)
1112     return gpg_error (GPG_ERR_ENOMEM);
1113
1114   return 0;
1115 }
1116 \f
1117 struct card_cardlist_parm_s {
1118   int error;
1119   strlist_t list;
1120 };
1121
1122
1123 /* Callback function for agent_card_cardlist.  */
1124 static gpg_error_t
1125 card_cardlist_cb (void *opaque, const char *line)
1126 {
1127   struct card_cardlist_parm_s *parm = opaque;
1128   const char *keyword = line;
1129   int keywordlen;
1130
1131   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
1132     ;
1133   while (spacep (line))
1134     line++;
1135
1136   if (keywordlen == 8 && !memcmp (keyword, "SERIALNO", keywordlen))
1137     {
1138       const char *s;
1139       int n;
1140
1141       for (n=0,s=line; hexdigitp (s); s++, n++)
1142         ;
1143
1144       if (!n || (n&1) || *s)
1145         parm->error = gpg_error (GPG_ERR_ASS_PARAMETER);
1146       else
1147         add_to_strlist (&parm->list, line);
1148     }
1149
1150   return 0;
1151 }
1152
1153 /* Return cardlist.  */
1154 int
1155 agent_scd_cardlist (strlist_t *result)
1156 {
1157   int err;
1158   char line[ASSUAN_LINELENGTH];
1159   struct card_cardlist_parm_s parm;
1160
1161   memset (&parm, 0, sizeof parm);
1162   *result = NULL;
1163   err = start_agent (NULL, 1);
1164   if (err)
1165     return err;
1166
1167   strcpy (line, "SCD GETINFO card_list");
1168
1169   err = assuan_transact (agent_ctx, line,
1170                          NULL, NULL, NULL, NULL,
1171                          card_cardlist_cb, &parm);
1172   if (!err && parm.error)
1173     err = parm.error;
1174
1175   if (!err)
1176     *result = parm.list;
1177   else
1178     free_strlist (parm.list);
1179
1180   return 0;
1181 }
1182 \f
1183 /* Change the PIN of an OpenPGP card or reset the retry counter.
1184    CHVNO 1: Change the PIN
1185          2: For v1 cards: Same as 1.
1186             For v2 cards: Reset the PIN using the Reset Code.
1187          3: Change the admin PIN
1188        101: Set a new PIN and reset the retry counter
1189        102: For v1 cars: Same as 101.
1190             For v2 cards: Set a new Reset Code.
1191    SERIALNO is not used.
1192  */
1193 int
1194 agent_scd_change_pin (int chvno, const char *serialno)
1195 {
1196   int rc;
1197   char line[ASSUAN_LINELENGTH];
1198   const char *reset = "";
1199   struct default_inq_parm_s dfltparm;
1200
1201   memset (&dfltparm, 0, sizeof dfltparm);
1202
1203   (void)serialno;
1204
1205   if (chvno >= 100)
1206     reset = "--reset";
1207   chvno %= 100;
1208
1209   rc = start_agent (NULL, 1);
1210   if (rc)
1211     return rc;
1212   dfltparm.ctx = agent_ctx;
1213
1214   snprintf (line, DIM(line), "SCD PASSWD %s %d", reset, chvno);
1215   rc = assuan_transact (agent_ctx, line,
1216                         NULL, NULL,
1217                         default_inq_cb, &dfltparm,
1218                         NULL, NULL);
1219   status_sc_op_failure (rc);
1220   return rc;
1221 }
1222
1223
1224 /* Perform a CHECKPIN operation.  SERIALNO should be the serial
1225    number of the card - optionally followed by the fingerprint;
1226    however the fingerprint is ignored here. */
1227 int
1228 agent_scd_checkpin  (const char *serialno)
1229 {
1230   int rc;
1231   char line[ASSUAN_LINELENGTH];
1232   struct default_inq_parm_s dfltparm;
1233
1234   memset (&dfltparm, 0, sizeof dfltparm);
1235
1236   rc = start_agent (NULL, 1);
1237   if (rc)
1238     return rc;
1239   dfltparm.ctx = agent_ctx;
1240
1241   snprintf (line, DIM(line), "SCD CHECKPIN %s", serialno);
1242   rc = assuan_transact (agent_ctx, line,
1243                         NULL, NULL,
1244                         default_inq_cb, &dfltparm,
1245                         NULL, NULL);
1246   status_sc_op_failure (rc);
1247   return rc;
1248 }
1249
1250
1251 /* Dummy function, only used by the gpg 1.4 implementation. */
1252 void
1253 agent_clear_pin_cache (const char *sn)
1254 {
1255   (void)sn;
1256 }
1257
1258
1259
1260 \f
1261 /* Note: All strings shall be UTF-8. On success the caller needs to
1262    free the string stored at R_PASSPHRASE. On error NULL will be
1263    stored at R_PASSPHRASE and an appropriate fpf error code
1264    returned. */
1265 gpg_error_t
1266 agent_get_passphrase (const char *cache_id,
1267                       const char *err_msg,
1268                       const char *prompt,
1269                       const char *desc_msg,
1270                       int repeat,
1271                       int check,
1272                       char **r_passphrase)
1273 {
1274   int rc;
1275   char line[ASSUAN_LINELENGTH];
1276   char *arg1 = NULL;
1277   char *arg2 = NULL;
1278   char *arg3 = NULL;
1279   char *arg4 = NULL;
1280   membuf_t data;
1281   struct default_inq_parm_s dfltparm;
1282
1283   memset (&dfltparm, 0, sizeof dfltparm);
1284
1285   *r_passphrase = NULL;
1286
1287   rc = start_agent (NULL, 0);
1288   if (rc)
1289     return rc;
1290   dfltparm.ctx = agent_ctx;
1291
1292   /* Check that the gpg-agent understands the repeat option.  */
1293   if (assuan_transact (agent_ctx,
1294                        "GETINFO cmd_has_option GET_PASSPHRASE repeat",
1295                        NULL, NULL, NULL, NULL, NULL, NULL))
1296     return gpg_error (GPG_ERR_NOT_SUPPORTED);
1297
1298   if (cache_id && *cache_id)
1299     if (!(arg1 = percent_plus_escape (cache_id)))
1300       goto no_mem;
1301   if (err_msg && *err_msg)
1302     if (!(arg2 = percent_plus_escape (err_msg)))
1303       goto no_mem;
1304   if (prompt && *prompt)
1305     if (!(arg3 = percent_plus_escape (prompt)))
1306       goto no_mem;
1307   if (desc_msg && *desc_msg)
1308     if (!(arg4 = percent_plus_escape (desc_msg)))
1309       goto no_mem;
1310
1311   snprintf (line, DIM(line),
1312             "GET_PASSPHRASE --data --repeat=%d%s -- %s %s %s %s",
1313             repeat,
1314             check? " --check --qualitybar":"",
1315             arg1? arg1:"X",
1316             arg2? arg2:"X",
1317             arg3? arg3:"X",
1318             arg4? arg4:"X");
1319   xfree (arg1);
1320   xfree (arg2);
1321   xfree (arg3);
1322   xfree (arg4);
1323
1324   init_membuf_secure (&data, 64);
1325   rc = assuan_transact (agent_ctx, line,
1326                         put_membuf_cb, &data,
1327                         default_inq_cb, &dfltparm,
1328                         NULL, NULL);
1329
1330   if (rc)
1331     xfree (get_membuf (&data, NULL));
1332   else
1333     {
1334       put_membuf (&data, "", 1);
1335       *r_passphrase = get_membuf (&data, NULL);
1336       if (!*r_passphrase)
1337         rc = gpg_error_from_syserror ();
1338     }
1339   return rc;
1340  no_mem:
1341   rc = gpg_error_from_syserror ();
1342   xfree (arg1);
1343   xfree (arg2);
1344   xfree (arg3);
1345   xfree (arg4);
1346   return rc;
1347 }
1348
1349
1350 gpg_error_t
1351 agent_clear_passphrase (const char *cache_id)
1352 {
1353   int rc;
1354   char line[ASSUAN_LINELENGTH];
1355   struct default_inq_parm_s dfltparm;
1356
1357   memset (&dfltparm, 0, sizeof dfltparm);
1358
1359   if (!cache_id || !*cache_id)
1360     return 0;
1361
1362   rc = start_agent (NULL, 0);
1363   if (rc)
1364     return rc;
1365   dfltparm.ctx = agent_ctx;
1366
1367   snprintf (line, DIM(line), "CLEAR_PASSPHRASE %s", cache_id);
1368   return assuan_transact (agent_ctx, line,
1369                           NULL, NULL,
1370                           default_inq_cb, &dfltparm,
1371                           NULL, NULL);
1372 }
1373
1374
1375 /* Ask the agent to pop up a confirmation dialog with the text DESC
1376    and an okay and cancel button. */
1377 gpg_error_t
1378 gpg_agent_get_confirmation (const char *desc)
1379 {
1380   int rc;
1381   char *tmp;
1382   char line[ASSUAN_LINELENGTH];
1383   struct default_inq_parm_s dfltparm;
1384
1385   memset (&dfltparm, 0, sizeof dfltparm);
1386
1387   rc = start_agent (NULL, 0);
1388   if (rc)
1389     return rc;
1390   dfltparm.ctx = agent_ctx;
1391
1392   tmp = percent_plus_escape (desc);
1393   if (!tmp)
1394     return gpg_error_from_syserror ();
1395   snprintf (line, DIM(line), "GET_CONFIRMATION %s", tmp);
1396   xfree (tmp);
1397
1398   rc = assuan_transact (agent_ctx, line,
1399                         NULL, NULL,
1400                         default_inq_cb, &dfltparm,
1401                         NULL, NULL);
1402   return rc;
1403 }
1404
1405
1406 /* Return the S2K iteration count as computed by gpg-agent.  */
1407 gpg_error_t
1408 agent_get_s2k_count (unsigned long *r_count)
1409 {
1410   gpg_error_t err;
1411   membuf_t data;
1412   char *buf;
1413
1414   *r_count = 0;
1415
1416   err = start_agent (NULL, 0);
1417   if (err)
1418     return err;
1419
1420   init_membuf (&data, 32);
1421   err = assuan_transact (agent_ctx, "GETINFO s2k_count",
1422                         put_membuf_cb, &data,
1423                         NULL, NULL, NULL, NULL);
1424   if (err)
1425     xfree (get_membuf (&data, NULL));
1426   else
1427     {
1428       put_membuf (&data, "", 1);
1429       buf = get_membuf (&data, NULL);
1430       if (!buf)
1431         err = gpg_error_from_syserror ();
1432       else
1433         {
1434           *r_count = strtoul (buf, NULL, 10);
1435           xfree (buf);
1436         }
1437     }
1438   return err;
1439 }
1440
1441
1442 \f
1443 /* Ask the agent whether a secret key for the given public key is
1444    available.  Returns 0 if available.  */
1445 gpg_error_t
1446 agent_probe_secret_key (ctrl_t ctrl, PKT_public_key *pk)
1447 {
1448   gpg_error_t err;
1449   char line[ASSUAN_LINELENGTH];
1450   char *hexgrip;
1451
1452   err = start_agent (ctrl, 0);
1453   if (err)
1454     return err;
1455
1456   err = hexkeygrip_from_pk (pk, &hexgrip);
1457   if (err)
1458     return err;
1459
1460   snprintf (line, sizeof line, "HAVEKEY %s", hexgrip);
1461   xfree (hexgrip);
1462
1463   err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
1464   return err;
1465 }
1466
1467 /* Ask the agent whether a secret key is available for any of the
1468    keys (primary or sub) in KEYBLOCK.  Returns 0 if available.  */
1469 gpg_error_t
1470 agent_probe_any_secret_key (ctrl_t ctrl, kbnode_t keyblock)
1471 {
1472   gpg_error_t err;
1473   char line[ASSUAN_LINELENGTH];
1474   char *p;
1475   kbnode_t kbctx, node;
1476   int nkeys;
1477   unsigned char grip[20];
1478
1479   err = start_agent (ctrl, 0);
1480   if (err)
1481     return err;
1482
1483   err = gpg_error (GPG_ERR_NO_SECKEY); /* Just in case no key was
1484                                           found in KEYBLOCK.  */
1485   p = stpcpy (line, "HAVEKEY");
1486   for (kbctx=NULL, nkeys=0; (node = walk_kbnode (keyblock, &kbctx, 0)); )
1487     if (node->pkt->pkttype == PKT_PUBLIC_KEY
1488         || node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1489         || node->pkt->pkttype == PKT_SECRET_KEY
1490         || node->pkt->pkttype == PKT_SECRET_SUBKEY)
1491       {
1492         if (nkeys && ((p - line) + 41) > (ASSUAN_LINELENGTH - 2))
1493           {
1494             err = assuan_transact (agent_ctx, line,
1495                                    NULL, NULL, NULL, NULL, NULL, NULL);
1496             if (err != gpg_err_code (GPG_ERR_NO_SECKEY))
1497               break; /* Seckey available or unexpected error - ready.  */
1498             p = stpcpy (line, "HAVEKEY");
1499             nkeys = 0;
1500           }
1501
1502         err = keygrip_from_pk (node->pkt->pkt.public_key, grip);
1503         if (err)
1504           return err;
1505         *p++ = ' ';
1506         bin2hex (grip, 20, p);
1507         p += 40;
1508         nkeys++;
1509       }
1510
1511   if (!err && nkeys)
1512     err = assuan_transact (agent_ctx, line,
1513                            NULL, NULL, NULL, NULL, NULL, NULL);
1514
1515   return err;
1516 }
1517
1518
1519 \f
1520 struct keyinfo_data_parm_s
1521 {
1522   char *serialno;
1523   int cleartext;
1524 };
1525
1526
1527 static gpg_error_t
1528 keyinfo_status_cb (void *opaque, const char *line)
1529 {
1530   struct keyinfo_data_parm_s *data = opaque;
1531   int is_smartcard;
1532   char *s;
1533
1534   if ((s = has_leading_keyword (line, "KEYINFO")) && data)
1535     {
1536       /* Parse the arguments:
1537        *      0        1        2        3       4          5
1538        *   <keygrip> <type> <serialno> <idstr> <cached> <protection>
1539        */
1540       char *fields[6];
1541
1542       if (split_fields (s, fields, DIM (fields)) == 6)
1543         {
1544           is_smartcard = (fields[1][0] == 'T');
1545           if (is_smartcard && !data->serialno && strcmp (fields[2], "-"))
1546             data->serialno = xtrystrdup (fields[2]);
1547           /* 'P' for protected, 'C' for clear */
1548           data->cleartext = (fields[5][0] == 'C');
1549         }
1550     }
1551   return 0;
1552 }
1553
1554
1555 /* Return the serial number for a secret key.  If the returned serial
1556    number is NULL, the key is not stored on a smartcard.  Caller needs
1557    to free R_SERIALNO.
1558
1559    if r_cleartext is not NULL, the referenced int will be set to 1 if
1560    the agent's copy of the key is stored in the clear, or 0 otherwise
1561 */
1562 gpg_error_t
1563 agent_get_keyinfo (ctrl_t ctrl, const char *hexkeygrip,
1564                    char **r_serialno, int *r_cleartext)
1565 {
1566   gpg_error_t err;
1567   char line[ASSUAN_LINELENGTH];
1568   struct keyinfo_data_parm_s keyinfo;
1569
1570   memset (&keyinfo, 0,sizeof keyinfo);
1571
1572   *r_serialno = NULL;
1573
1574   err = start_agent (ctrl, 0);
1575   if (err)
1576     return err;
1577
1578   if (!hexkeygrip || strlen (hexkeygrip) != 40)
1579     return gpg_error (GPG_ERR_INV_VALUE);
1580
1581   snprintf (line, DIM(line), "KEYINFO %s", hexkeygrip);
1582
1583   err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL,
1584                          keyinfo_status_cb, &keyinfo);
1585   if (!err && keyinfo.serialno)
1586     {
1587       /* Sanity check for bad characters.  */
1588       if (strpbrk (keyinfo.serialno, ":\n\r"))
1589         err = GPG_ERR_INV_VALUE;
1590     }
1591   if (err)
1592     xfree (keyinfo.serialno);
1593   else
1594     {
1595       *r_serialno = keyinfo.serialno;
1596       if (r_cleartext)
1597         *r_cleartext = keyinfo.cleartext;
1598     }
1599   return err;
1600 }
1601
1602 \f
1603 /* Status callback for agent_import_key, agent_export_key and
1604    agent_genkey.  */
1605 static gpg_error_t
1606 cache_nonce_status_cb (void *opaque, const char *line)
1607 {
1608   struct cache_nonce_parm_s *parm = opaque;
1609   const char *s;
1610
1611   if ((s = has_leading_keyword (line, "CACHE_NONCE")))
1612     {
1613       if (parm->cache_nonce_addr)
1614         {
1615           xfree (*parm->cache_nonce_addr);
1616           *parm->cache_nonce_addr = xtrystrdup (s);
1617         }
1618     }
1619   else if ((s = has_leading_keyword (line, "PASSWD_NONCE")))
1620     {
1621       if (parm->passwd_nonce_addr)
1622         {
1623           xfree (*parm->passwd_nonce_addr);
1624           *parm->passwd_nonce_addr = xtrystrdup (s);
1625         }
1626     }
1627   else if ((s = has_leading_keyword (line, "PROGRESS")))
1628     {
1629       if (opt.enable_progress_filter)
1630         write_status_text (STATUS_PROGRESS, s);
1631     }
1632
1633   return 0;
1634 }
1635
1636
1637 \f
1638 /* Handle a KEYPARMS inquiry.  Note, we only send the data,
1639    assuan_transact takes care of flushing and writing the end */
1640 static gpg_error_t
1641 inq_genkey_parms (void *opaque, const char *line)
1642 {
1643   struct genkey_parm_s *parm = opaque;
1644   gpg_error_t err;
1645
1646   if (has_leading_keyword (line, "KEYPARAM"))
1647     {
1648       err = assuan_send_data (parm->dflt->ctx,
1649                               parm->keyparms, strlen (parm->keyparms));
1650     }
1651   else if (has_leading_keyword (line, "NEWPASSWD") && parm->passphrase)
1652     {
1653       err = assuan_send_data (parm->dflt->ctx,
1654                               parm->passphrase,  strlen (parm->passphrase));
1655     }
1656   else
1657     err = default_inq_cb (parm->dflt, line);
1658
1659   return err;
1660 }
1661
1662
1663 /* Call the agent to generate a new key.  KEYPARMS is the usual
1664    S-expression giving the parameters of the key.  gpg-agent passes it
1665    gcry_pk_genkey.  If NO_PROTECTION is true the agent is advised not
1666    to protect the generated key.  If NO_PROTECTION is not set and
1667    PASSPHRASE is not NULL the agent is requested to protect the key
1668    with that passphrase instead of asking for one.  */
1669 gpg_error_t
1670 agent_genkey (ctrl_t ctrl, char **cache_nonce_addr, char **passwd_nonce_addr,
1671               const char *keyparms, int no_protection,
1672               const char *passphrase, gcry_sexp_t *r_pubkey)
1673 {
1674   gpg_error_t err;
1675   struct genkey_parm_s gk_parm;
1676   struct cache_nonce_parm_s cn_parm;
1677   struct default_inq_parm_s dfltparm;
1678   membuf_t data;
1679   size_t len;
1680   unsigned char *buf;
1681   char line[ASSUAN_LINELENGTH];
1682
1683   memset (&dfltparm, 0, sizeof dfltparm);
1684   dfltparm.ctrl = ctrl;
1685
1686   *r_pubkey = NULL;
1687   err = start_agent (ctrl, 0);
1688   if (err)
1689     return err;
1690   dfltparm.ctx = agent_ctx;
1691
1692   if (passwd_nonce_addr && *passwd_nonce_addr)
1693     ; /* A RESET would flush the passwd nonce cache.  */
1694   else
1695     {
1696       err = assuan_transact (agent_ctx, "RESET",
1697                              NULL, NULL, NULL, NULL, NULL, NULL);
1698       if (err)
1699         return err;
1700     }
1701
1702   init_membuf (&data, 1024);
1703   gk_parm.dflt     = &dfltparm;
1704   gk_parm.keyparms = keyparms;
1705   gk_parm.passphrase = passphrase;
1706   snprintf (line, sizeof line, "GENKEY%s%s%s%s%s",
1707             no_protection? " --no-protection" :
1708             passphrase   ? " --inq-passwd" :
1709             /*          */ "",
1710             passwd_nonce_addr && *passwd_nonce_addr? " --passwd-nonce=":"",
1711             passwd_nonce_addr && *passwd_nonce_addr? *passwd_nonce_addr:"",
1712             cache_nonce_addr && *cache_nonce_addr? " ":"",
1713             cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"");
1714   cn_parm.cache_nonce_addr = cache_nonce_addr;
1715   cn_parm.passwd_nonce_addr = NULL;
1716   err = assuan_transact (agent_ctx, line,
1717                          put_membuf_cb, &data,
1718                          inq_genkey_parms, &gk_parm,
1719                          cache_nonce_status_cb, &cn_parm);
1720   if (err)
1721     {
1722       xfree (get_membuf (&data, &len));
1723       return err;
1724     }
1725
1726   buf = get_membuf (&data, &len);
1727   if (!buf)
1728     err = gpg_error_from_syserror ();
1729   else
1730     {
1731       err = gcry_sexp_sscan (r_pubkey, NULL, buf, len);
1732       xfree (buf);
1733     }
1734   return err;
1735 }
1736
1737
1738 \f
1739 /* Call the agent to read the public key part for a given keygrip.  If
1740    FROMCARD is true, the key is directly read from the current
1741    smartcard. In this case HEXKEYGRIP should be the keyID
1742    (e.g. OPENPGP.3). */
1743 gpg_error_t
1744 agent_readkey (ctrl_t ctrl, int fromcard, const char *hexkeygrip,
1745                unsigned char **r_pubkey)
1746 {
1747   gpg_error_t err;
1748   membuf_t data;
1749   size_t len;
1750   unsigned char *buf;
1751   char line[ASSUAN_LINELENGTH];
1752   struct default_inq_parm_s dfltparm;
1753
1754   memset (&dfltparm, 0, sizeof dfltparm);
1755   dfltparm.ctrl = ctrl;
1756
1757   *r_pubkey = NULL;
1758   err = start_agent (ctrl, 0);
1759   if (err)
1760     return err;
1761   dfltparm.ctx = agent_ctx;
1762
1763   err = assuan_transact (agent_ctx, "RESET",NULL, NULL, NULL, NULL, NULL, NULL);
1764   if (err)
1765     return err;
1766
1767   snprintf (line, DIM(line), "READKEY %s%s", fromcard? "--card ":"",
1768             hexkeygrip);
1769
1770   init_membuf (&data, 1024);
1771   err = assuan_transact (agent_ctx, line,
1772                          put_membuf_cb, &data,
1773                          default_inq_cb, &dfltparm,
1774                          NULL, NULL);
1775   if (err)
1776     {
1777       xfree (get_membuf (&data, &len));
1778       return err;
1779     }
1780   buf = get_membuf (&data, &len);
1781   if (!buf)
1782     return gpg_error_from_syserror ();
1783   if (!gcry_sexp_canon_len (buf, len, NULL, NULL))
1784     {
1785       xfree (buf);
1786       return gpg_error (GPG_ERR_INV_SEXP);
1787     }
1788   *r_pubkey = buf;
1789   return 0;
1790 }
1791
1792
1793 \f
1794 /* Call the agent to do a sign operation using the key identified by
1795    the hex string KEYGRIP.  DESC is a description of the key to be
1796    displayed if the agent needs to ask for the PIN.  DIGEST and
1797    DIGESTLEN is the hash value to sign and DIGESTALGO the algorithm id
1798    used to compute the digest.  If CACHE_NONCE is used the agent is
1799    advised to first try a passphrase associated with that nonce. */
1800 gpg_error_t
1801 agent_pksign (ctrl_t ctrl, const char *cache_nonce,
1802               const char *keygrip, const char *desc,
1803               u32 *keyid, u32 *mainkeyid, int pubkey_algo,
1804               unsigned char *digest, size_t digestlen, int digestalgo,
1805               gcry_sexp_t *r_sigval)
1806 {
1807   gpg_error_t err;
1808   char line[ASSUAN_LINELENGTH];
1809   membuf_t data;
1810   struct default_inq_parm_s dfltparm;
1811
1812   memset (&dfltparm, 0, sizeof dfltparm);
1813   dfltparm.ctrl = ctrl;
1814   dfltparm.keyinfo.keyid       = keyid;
1815   dfltparm.keyinfo.mainkeyid   = mainkeyid;
1816   dfltparm.keyinfo.pubkey_algo = pubkey_algo;
1817
1818   *r_sigval = NULL;
1819   err = start_agent (ctrl, 0);
1820   if (err)
1821     return err;
1822   dfltparm.ctx = agent_ctx;
1823
1824   if (digestlen*2 + 50 > DIM(line))
1825     return gpg_error (GPG_ERR_GENERAL);
1826
1827   err = assuan_transact (agent_ctx, "RESET",
1828                          NULL, NULL, NULL, NULL, NULL, NULL);
1829   if (err)
1830     return err;
1831
1832   snprintf (line, DIM(line), "SIGKEY %s", keygrip);
1833   err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
1834   if (err)
1835     return err;
1836
1837   if (desc)
1838     {
1839       snprintf (line, DIM(line), "SETKEYDESC %s", desc);
1840       err = assuan_transact (agent_ctx, line,
1841                             NULL, NULL, NULL, NULL, NULL, NULL);
1842       if (err)
1843         return err;
1844     }
1845
1846   snprintf (line, sizeof line, "SETHASH %d ", digestalgo);
1847   bin2hex (digest, digestlen, line + strlen (line));
1848   err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
1849   if (err)
1850     return err;
1851
1852   init_membuf (&data, 1024);
1853
1854   snprintf (line, sizeof line, "PKSIGN%s%s",
1855             cache_nonce? " -- ":"",
1856             cache_nonce? cache_nonce:"");
1857   err = assuan_transact (agent_ctx, line,
1858                          put_membuf_cb, &data,
1859                          default_inq_cb, &dfltparm,
1860                          NULL, NULL);
1861   if (err)
1862     xfree (get_membuf (&data, NULL));
1863   else
1864     {
1865       unsigned char *buf;
1866       size_t len;
1867
1868       buf = get_membuf (&data, &len);
1869       if (!buf)
1870         err = gpg_error_from_syserror ();
1871       else
1872         {
1873           err = gcry_sexp_sscan (r_sigval, NULL, buf, len);
1874           xfree (buf);
1875         }
1876     }
1877   return err;
1878 }
1879
1880
1881 \f
1882 /* Handle a CIPHERTEXT inquiry.  Note, we only send the data,
1883    assuan_transact takes care of flushing and writing the END. */
1884 static gpg_error_t
1885 inq_ciphertext_cb (void *opaque, const char *line)
1886 {
1887   struct cipher_parm_s *parm = opaque;
1888   int rc;
1889
1890   if (has_leading_keyword (line, "CIPHERTEXT"))
1891     {
1892       assuan_begin_confidential (parm->ctx);
1893       rc = assuan_send_data (parm->dflt->ctx,
1894                              parm->ciphertext, parm->ciphertextlen);
1895       assuan_end_confidential (parm->ctx);
1896     }
1897   else
1898     rc = default_inq_cb (parm->dflt, line);
1899
1900   return rc;
1901 }
1902
1903
1904 /* Check whether there is any padding info from the agent.  */
1905 static gpg_error_t
1906 padding_info_cb (void *opaque, const char *line)
1907 {
1908   int *r_padding = opaque;
1909   const char *s;
1910
1911   if ((s=has_leading_keyword (line, "PADDING")))
1912     {
1913       *r_padding = atoi (s);
1914     }
1915
1916   return 0;
1917 }
1918
1919
1920 /* Call the agent to do a decrypt operation using the key identified
1921    by the hex string KEYGRIP and the input data S_CIPHERTEXT.  On the
1922    success the decoded value is stored verbatim at R_BUF and its
1923    length at R_BUF; the callers needs to release it.  KEYID, MAINKEYID
1924    and PUBKEY_ALGO are used to construct additional promots or status
1925    messages.   The padding information is stored at R_PADDING with -1
1926    for not known.  */
1927 gpg_error_t
1928 agent_pkdecrypt (ctrl_t ctrl, const char *keygrip, const char *desc,
1929                  u32 *keyid, u32 *mainkeyid, int pubkey_algo,
1930                  gcry_sexp_t s_ciphertext,
1931                  unsigned char **r_buf, size_t *r_buflen, int *r_padding)
1932 {
1933   gpg_error_t err;
1934   char line[ASSUAN_LINELENGTH];
1935   membuf_t data;
1936   size_t n, len;
1937   char *p, *buf, *endp;
1938   struct default_inq_parm_s dfltparm;
1939
1940   memset (&dfltparm, 0, sizeof dfltparm);
1941   dfltparm.ctrl = ctrl;
1942   dfltparm.keyinfo.keyid       = keyid;
1943   dfltparm.keyinfo.mainkeyid   = mainkeyid;
1944   dfltparm.keyinfo.pubkey_algo = pubkey_algo;
1945
1946   if (!keygrip || strlen(keygrip) != 40
1947       || !s_ciphertext || !r_buf || !r_buflen || !r_padding)
1948     return gpg_error (GPG_ERR_INV_VALUE);
1949
1950   *r_buf = NULL;
1951   *r_padding = -1;
1952
1953   err = start_agent (ctrl, 0);
1954   if (err)
1955     return err;
1956   dfltparm.ctx = agent_ctx;
1957
1958   err = assuan_transact (agent_ctx, "RESET",
1959                          NULL, NULL, NULL, NULL, NULL, NULL);
1960   if (err)
1961     return err;
1962
1963   snprintf (line, sizeof line, "SETKEY %s", keygrip);
1964   err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
1965   if (err)
1966     return err;
1967
1968   if (desc)
1969     {
1970       snprintf (line, DIM(line), "SETKEYDESC %s", desc);
1971       err = assuan_transact (agent_ctx, line,
1972                             NULL, NULL, NULL, NULL, NULL, NULL);
1973       if (err)
1974         return err;
1975     }
1976
1977   init_membuf_secure (&data, 1024);
1978   {
1979     struct cipher_parm_s parm;
1980
1981     parm.dflt = &dfltparm;
1982     parm.ctx = agent_ctx;
1983     err = make_canon_sexp (s_ciphertext, &parm.ciphertext, &parm.ciphertextlen);
1984     if (err)
1985       return err;
1986     err = assuan_transact (agent_ctx, "PKDECRYPT",
1987                            put_membuf_cb, &data,
1988                            inq_ciphertext_cb, &parm,
1989                            padding_info_cb, r_padding);
1990     xfree (parm.ciphertext);
1991   }
1992   if (err)
1993     {
1994       xfree (get_membuf (&data, &len));
1995       return err;
1996     }
1997
1998   put_membuf (&data, "", 1); /* Make sure it is 0 terminated.  */
1999   buf = get_membuf (&data, &len);
2000   if (!buf)
2001     return gpg_error_from_syserror ();
2002   log_assert (len); /* (we forced Nul termination.)  */
2003
2004   if (*buf != '(')
2005     {
2006       xfree (buf);
2007       return gpg_error (GPG_ERR_INV_SEXP);
2008     }
2009
2010   if (len < 13 || memcmp (buf, "(5:value", 8) ) /* "(5:valueN:D)\0" */
2011     {
2012       xfree (buf);
2013       return gpg_error (GPG_ERR_INV_SEXP);
2014     }
2015   len -= 10;   /* Count only the data of the second part. */
2016   p = buf + 8; /* Skip leading parenthesis and the value tag. */
2017
2018   n = strtoul (p, &endp, 10);
2019   if (!n || *endp != ':')
2020     {
2021       xfree (buf);
2022       return gpg_error (GPG_ERR_INV_SEXP);
2023     }
2024   endp++;
2025   if (endp-p+n > len)
2026     {
2027       xfree (buf);
2028       return gpg_error (GPG_ERR_INV_SEXP); /* Oops: Inconsistent S-Exp. */
2029     }
2030
2031   memmove (buf, endp, n);
2032
2033   *r_buflen = n;
2034   *r_buf = buf;
2035   return 0;
2036 }
2037
2038
2039 \f
2040 /* Retrieve a key encryption key from the agent.  With FOREXPORT true
2041    the key shall be used for export, with false for import.  On success
2042    the new key is stored at R_KEY and its length at R_KEKLEN.  */
2043 gpg_error_t
2044 agent_keywrap_key (ctrl_t ctrl, int forexport, void **r_kek, size_t *r_keklen)
2045 {
2046   gpg_error_t err;
2047   membuf_t data;
2048   size_t len;
2049   unsigned char *buf;
2050   char line[ASSUAN_LINELENGTH];
2051   struct default_inq_parm_s dfltparm;
2052
2053   memset (&dfltparm, 0, sizeof dfltparm);
2054   dfltparm.ctrl = ctrl;
2055
2056   *r_kek = NULL;
2057   err = start_agent (ctrl, 0);
2058   if (err)
2059     return err;
2060   dfltparm.ctx = agent_ctx;
2061
2062   snprintf (line, DIM(line), "KEYWRAP_KEY %s",
2063             forexport? "--export":"--import");
2064
2065   init_membuf_secure (&data, 64);
2066   err = assuan_transact (agent_ctx, line,
2067                          put_membuf_cb, &data,
2068                          default_inq_cb, &dfltparm,
2069                          NULL, NULL);
2070   if (err)
2071     {
2072       xfree (get_membuf (&data, &len));
2073       return err;
2074     }
2075   buf = get_membuf (&data, &len);
2076   if (!buf)
2077     return gpg_error_from_syserror ();
2078   *r_kek = buf;
2079   *r_keklen = len;
2080   return 0;
2081 }
2082
2083
2084 \f
2085 /* Handle the inquiry for an IMPORT_KEY command.  */
2086 static gpg_error_t
2087 inq_import_key_parms (void *opaque, const char *line)
2088 {
2089   struct import_key_parm_s *parm = opaque;
2090   gpg_error_t err;
2091
2092   if (has_leading_keyword (line, "KEYDATA"))
2093     {
2094       err = assuan_send_data (parm->dflt->ctx, parm->key, parm->keylen);
2095     }
2096   else
2097     err = default_inq_cb (parm->dflt, line);
2098
2099   return err;
2100 }
2101
2102
2103 /* Call the agent to import a key into the agent.  */
2104 gpg_error_t
2105 agent_import_key (ctrl_t ctrl, const char *desc, char **cache_nonce_addr,
2106                   const void *key, size_t keylen, int unattended, int force,
2107                   u32 *keyid, u32 *mainkeyid, int pubkey_algo)
2108 {
2109   gpg_error_t err;
2110   struct import_key_parm_s parm;
2111   struct cache_nonce_parm_s cn_parm;
2112   char line[ASSUAN_LINELENGTH];
2113   struct default_inq_parm_s dfltparm;
2114
2115   memset (&dfltparm, 0, sizeof dfltparm);
2116   dfltparm.ctrl = ctrl;
2117   dfltparm.keyinfo.keyid       = keyid;
2118   dfltparm.keyinfo.mainkeyid   = mainkeyid;
2119   dfltparm.keyinfo.pubkey_algo = pubkey_algo;
2120
2121   err = start_agent (ctrl, 0);
2122   if (err)
2123     return err;
2124   dfltparm.ctx = agent_ctx;
2125
2126   if (desc)
2127     {
2128       snprintf (line, DIM(line), "SETKEYDESC %s", desc);
2129       err = assuan_transact (agent_ctx, line,
2130                             NULL, NULL, NULL, NULL, NULL, NULL);
2131       if (err)
2132         return err;
2133     }
2134
2135   parm.dflt   = &dfltparm;
2136   parm.key    = key;
2137   parm.keylen = keylen;
2138
2139   snprintf (line, sizeof line, "IMPORT_KEY%s%s%s%s",
2140             unattended? " --unattended":"",
2141             force? " --force":"",
2142             cache_nonce_addr && *cache_nonce_addr? " ":"",
2143             cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"");
2144   cn_parm.cache_nonce_addr = cache_nonce_addr;
2145   cn_parm.passwd_nonce_addr = NULL;
2146   err = assuan_transact (agent_ctx, line,
2147                          NULL, NULL,
2148                          inq_import_key_parms, &parm,
2149                          cache_nonce_status_cb, &cn_parm);
2150   return err;
2151 }
2152
2153
2154 \f
2155 /* Receive a secret key from the agent.  HEXKEYGRIP is the hexified
2156    keygrip, DESC a prompt to be displayed with the agent's passphrase
2157    question (needs to be plus+percent escaped).  if OPENPGP_PROTECTED
2158    is not zero, ensure that the key material is returned in RFC
2159    4880-compatible passphrased-protected form.  If CACHE_NONCE_ADDR is
2160    not NULL the agent is advised to first try a passphrase associated
2161    with that nonce.  On success the key is stored as a canonical
2162    S-expression at R_RESULT and R_RESULTLEN.  */
2163 gpg_error_t
2164 agent_export_key (ctrl_t ctrl, const char *hexkeygrip, const char *desc,
2165                   int openpgp_protected, char **cache_nonce_addr,
2166                   unsigned char **r_result, size_t *r_resultlen,
2167                   u32 *keyid, u32 *mainkeyid, int pubkey_algo)
2168 {
2169   gpg_error_t err;
2170   struct cache_nonce_parm_s cn_parm;
2171   membuf_t data;
2172   size_t len;
2173   unsigned char *buf;
2174   char line[ASSUAN_LINELENGTH];
2175   struct default_inq_parm_s dfltparm;
2176
2177   memset (&dfltparm, 0, sizeof dfltparm);
2178   dfltparm.ctrl = ctrl;
2179   dfltparm.keyinfo.keyid       = keyid;
2180   dfltparm.keyinfo.mainkeyid   = mainkeyid;
2181   dfltparm.keyinfo.pubkey_algo = pubkey_algo;
2182
2183   *r_result = NULL;
2184
2185   err = start_agent (ctrl, 0);
2186   if (err)
2187     return err;
2188   dfltparm.ctx = agent_ctx;
2189
2190   if (desc)
2191     {
2192       snprintf (line, DIM(line), "SETKEYDESC %s", desc);
2193       err = assuan_transact (agent_ctx, line,
2194                              NULL, NULL, NULL, NULL, NULL, NULL);
2195       if (err)
2196         return err;
2197     }
2198
2199   snprintf (line, DIM(line), "EXPORT_KEY %s%s%s %s",
2200             openpgp_protected ? "--openpgp ":"",
2201             cache_nonce_addr && *cache_nonce_addr? "--cache-nonce=":"",
2202             cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"",
2203             hexkeygrip);
2204
2205   init_membuf_secure (&data, 1024);
2206   cn_parm.cache_nonce_addr = cache_nonce_addr;
2207   cn_parm.passwd_nonce_addr = NULL;
2208   err = assuan_transact (agent_ctx, line,
2209                          put_membuf_cb, &data,
2210                          default_inq_cb, &dfltparm,
2211                          cache_nonce_status_cb, &cn_parm);
2212   if (err)
2213     {
2214       xfree (get_membuf (&data, &len));
2215       return err;
2216     }
2217   buf = get_membuf (&data, &len);
2218   if (!buf)
2219     return gpg_error_from_syserror ();
2220   *r_result = buf;
2221   *r_resultlen = len;
2222   return 0;
2223 }
2224
2225
2226 \f
2227 /* Ask the agent to delete the key identified by HEXKEYGRIP.  If DESC
2228    is not NULL, display DESC instead of the default description
2229    message.  If FORCE is true the agent is advised not to ask for
2230    confirmation. */
2231 gpg_error_t
2232 agent_delete_key (ctrl_t ctrl, const char *hexkeygrip, const char *desc,
2233                   int force)
2234 {
2235   gpg_error_t err;
2236   char line[ASSUAN_LINELENGTH];
2237   struct default_inq_parm_s dfltparm;
2238
2239   memset (&dfltparm, 0, sizeof dfltparm);
2240   dfltparm.ctrl = ctrl;
2241
2242   err = start_agent (ctrl, 0);
2243   if (err)
2244     return err;
2245
2246   if (!hexkeygrip || strlen (hexkeygrip) != 40)
2247     return gpg_error (GPG_ERR_INV_VALUE);
2248
2249   if (desc)
2250     {
2251       snprintf (line, DIM(line), "SETKEYDESC %s", desc);
2252       err = assuan_transact (agent_ctx, line,
2253                              NULL, NULL, NULL, NULL, NULL, NULL);
2254       if (err)
2255         return err;
2256     }
2257
2258   snprintf (line, DIM(line), "DELETE_KEY%s %s",
2259             force? " --force":"", hexkeygrip);
2260   err = assuan_transact (agent_ctx, line, NULL, NULL,
2261                          default_inq_cb, &dfltparm,
2262                          NULL, NULL);
2263   return err;
2264 }
2265
2266
2267 \f
2268 /* Ask the agent to change the passphrase of the key identified by
2269  * HEXKEYGRIP.  If DESC is not NULL, display DESC instead of the
2270  * default description message.  If CACHE_NONCE_ADDR is not NULL the
2271  * agent is advised to first try a passphrase associated with that
2272  * nonce.  If PASSWD_NONCE_ADDR is not NULL the agent will try to use
2273  * the passphrase associated with that nonce for the new passphrase.
2274  * If VERIFY is true the passphrase is only verified.  */
2275 gpg_error_t
2276 agent_passwd (ctrl_t ctrl, const char *hexkeygrip, const char *desc, int verify,
2277               char **cache_nonce_addr, char **passwd_nonce_addr)
2278 {
2279   gpg_error_t err;
2280   struct cache_nonce_parm_s cn_parm;
2281   char line[ASSUAN_LINELENGTH];
2282   struct default_inq_parm_s dfltparm;
2283
2284   memset (&dfltparm, 0, sizeof dfltparm);
2285   dfltparm.ctrl = ctrl;
2286
2287   err = start_agent (ctrl, 0);
2288   if (err)
2289     return err;
2290   dfltparm.ctx = agent_ctx;
2291
2292   if (!hexkeygrip || strlen (hexkeygrip) != 40)
2293     return gpg_error (GPG_ERR_INV_VALUE);
2294
2295   if (desc)
2296     {
2297       snprintf (line, DIM(line), "SETKEYDESC %s", desc);
2298       err = assuan_transact (agent_ctx, line,
2299                              NULL, NULL, NULL, NULL, NULL, NULL);
2300       if (err)
2301         return err;
2302     }
2303
2304   if (verify)
2305     snprintf (line, DIM(line), "PASSWD %s%s --verify %s",
2306               cache_nonce_addr && *cache_nonce_addr? "--cache-nonce=":"",
2307               cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"",
2308               hexkeygrip);
2309   else
2310     snprintf (line, DIM(line), "PASSWD %s%s %s%s %s",
2311               cache_nonce_addr && *cache_nonce_addr? "--cache-nonce=":"",
2312               cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"",
2313               passwd_nonce_addr && *passwd_nonce_addr? "--passwd-nonce=":"",
2314               passwd_nonce_addr && *passwd_nonce_addr? *passwd_nonce_addr:"",
2315               hexkeygrip);
2316   cn_parm.cache_nonce_addr = cache_nonce_addr;
2317   cn_parm.passwd_nonce_addr = passwd_nonce_addr;
2318   err = assuan_transact (agent_ctx, line, NULL, NULL,
2319                          default_inq_cb, &dfltparm,
2320                          cache_nonce_status_cb, &cn_parm);
2321   return err;
2322 }
2323
2324
2325 /* Return the version reported by gpg-agent.  */
2326 gpg_error_t
2327 agent_get_version (ctrl_t ctrl, char **r_version)
2328 {
2329   gpg_error_t err;
2330
2331   err = start_agent (ctrl, 0);
2332   if (err)
2333     return err;
2334
2335   err = get_assuan_server_version (agent_ctx, 0, r_version);
2336   return err;
2337 }