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