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