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