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