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