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