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