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