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