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