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