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