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