gpg: Print PROGRESS status lines during key generation.
[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 *s;
1753
1754   if ((s = has_leading_keyword (line, "CACHE_NONCE")))
1755     {
1756       if (parm->cache_nonce_addr)
1757         {
1758           xfree (*parm->cache_nonce_addr);
1759           *parm->cache_nonce_addr = xtrystrdup (s);
1760         }
1761     }
1762   else if ((s = has_leading_keyword (line, "PASSWD_NONCE")))
1763     {
1764       if (parm->passwd_nonce_addr)
1765         {
1766           xfree (*parm->passwd_nonce_addr);
1767           *parm->passwd_nonce_addr = xtrystrdup (s);
1768         }
1769     }
1770   else if ((s = has_leading_keyword (line, "PROGRESS")))
1771     {
1772       if (opt.enable_progress_filter)
1773         write_status_text (STATUS_PROGRESS, s);
1774     }
1775
1776   return 0;
1777 }
1778
1779
1780 \f
1781 /* Handle a KEYPARMS inquiry.  Note, we only send the data,
1782    assuan_transact takes care of flushing and writing the end */
1783 static gpg_error_t
1784 inq_genkey_parms (void *opaque, const char *line)
1785 {
1786   struct genkey_parm_s *parm = opaque;
1787   gpg_error_t err;
1788
1789   if (has_leading_keyword (line, "KEYPARAM"))
1790     {
1791       err = assuan_send_data (parm->dflt->ctx,
1792                               parm->keyparms, strlen (parm->keyparms));
1793     }
1794   else if (has_leading_keyword (line, "NEWPASSWD") && parm->passphrase)
1795     {
1796       err = assuan_send_data (parm->dflt->ctx,
1797                               parm->passphrase,  strlen (parm->passphrase));
1798     }
1799   else
1800     err = default_inq_cb (parm->dflt, line);
1801
1802   return err;
1803 }
1804
1805
1806 /* Call the agent to generate a new key.  KEYPARMS is the usual
1807    S-expression giving the parameters of the key.  gpg-agent passes it
1808    gcry_pk_genkey.  If NO_PROTECTION is true the agent is advised not
1809    to protect the generated key.  If NO_PROTECTION is not set and
1810    PASSPHRASE is not NULL the agent is requested to protect the key
1811    with that passphrase instead of asking for one.  */
1812 gpg_error_t
1813 agent_genkey (ctrl_t ctrl, char **cache_nonce_addr,
1814               const char *keyparms, int no_protection,
1815               const char *passphrase, gcry_sexp_t *r_pubkey)
1816 {
1817   gpg_error_t err;
1818   struct genkey_parm_s gk_parm;
1819   struct cache_nonce_parm_s cn_parm;
1820   struct default_inq_parm_s dfltparm;
1821   membuf_t data;
1822   size_t len;
1823   unsigned char *buf;
1824   char line[ASSUAN_LINELENGTH];
1825
1826   memset (&dfltparm, 0, sizeof dfltparm);
1827   dfltparm.ctrl = ctrl;
1828
1829   *r_pubkey = NULL;
1830   err = start_agent (ctrl, 0);
1831   if (err)
1832     return err;
1833   dfltparm.ctx = agent_ctx;
1834
1835   err = assuan_transact (agent_ctx, "RESET",
1836                          NULL, NULL, NULL, NULL, NULL, NULL);
1837   if (err)
1838     return err;
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",
1845             no_protection? " --no-protection" :
1846             passphrase   ? " --inq-passwd" :
1847             /*          */ "",
1848             cache_nonce_addr && *cache_nonce_addr? " ":"",
1849             cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"");
1850   cn_parm.cache_nonce_addr = cache_nonce_addr;
1851   cn_parm.passwd_nonce_addr = NULL;
1852   err = assuan_transact (agent_ctx, line,
1853                          put_membuf_cb, &data,
1854                          inq_genkey_parms, &gk_parm,
1855                          cache_nonce_status_cb, &cn_parm);
1856   if (err)
1857     {
1858       xfree (get_membuf (&data, &len));
1859       return err;
1860     }
1861
1862   buf = get_membuf (&data, &len);
1863   if (!buf)
1864     err = gpg_error_from_syserror ();
1865   else
1866     {
1867       err = gcry_sexp_sscan (r_pubkey, NULL, buf, len);
1868       xfree (buf);
1869     }
1870   return err;
1871 }
1872
1873
1874 \f
1875 /* Call the agent to read the public key part for a given keygrip.  If
1876    FROMCARD is true, the key is directly read from the current
1877    smartcard. In this case HEXKEYGRIP should be the keyID
1878    (e.g. OPENPGP.3). */
1879 gpg_error_t
1880 agent_readkey (ctrl_t ctrl, int fromcard, const char *hexkeygrip,
1881                unsigned char **r_pubkey)
1882 {
1883   gpg_error_t err;
1884   membuf_t data;
1885   size_t len;
1886   unsigned char *buf;
1887   char line[ASSUAN_LINELENGTH];
1888   struct default_inq_parm_s dfltparm;
1889
1890   memset (&dfltparm, 0, sizeof dfltparm);
1891   dfltparm.ctrl = ctrl;
1892
1893   *r_pubkey = NULL;
1894   err = start_agent (ctrl, 0);
1895   if (err)
1896     return err;
1897   dfltparm.ctx = agent_ctx;
1898
1899   err = assuan_transact (agent_ctx, "RESET",NULL, NULL, NULL, NULL, NULL, NULL);
1900   if (err)
1901     return err;
1902
1903   snprintf (line, DIM(line)-1, "%sREADKEY %s", fromcard? "SCD ":"", hexkeygrip);
1904
1905   init_membuf (&data, 1024);
1906   err = assuan_transact (agent_ctx, line,
1907                          put_membuf_cb, &data,
1908                          default_inq_cb, &dfltparm,
1909                          NULL, NULL);
1910   if (err)
1911     {
1912       xfree (get_membuf (&data, &len));
1913       return err;
1914     }
1915   buf = get_membuf (&data, &len);
1916   if (!buf)
1917     return gpg_error_from_syserror ();
1918   if (!gcry_sexp_canon_len (buf, len, NULL, NULL))
1919     {
1920       xfree (buf);
1921       return gpg_error (GPG_ERR_INV_SEXP);
1922     }
1923   *r_pubkey = buf;
1924   return 0;
1925 }
1926
1927
1928 \f
1929 /* Call the agent to do a sign operation using the key identified by
1930    the hex string KEYGRIP.  DESC is a description of the key to be
1931    displayed if the agent needs to ask for the PIN.  DIGEST and
1932    DIGESTLEN is the hash value to sign and DIGESTALGO the algorithm id
1933    used to compute the digest.  If CACHE_NONCE is used the agent is
1934    advised to first try a passphrase associated with that nonce. */
1935 gpg_error_t
1936 agent_pksign (ctrl_t ctrl, const char *cache_nonce,
1937               const char *keygrip, const char *desc,
1938               u32 *keyid, u32 *mainkeyid, int pubkey_algo,
1939               unsigned char *digest, size_t digestlen, int digestalgo,
1940               gcry_sexp_t *r_sigval)
1941 {
1942   gpg_error_t err;
1943   char line[ASSUAN_LINELENGTH];
1944   membuf_t data;
1945   struct default_inq_parm_s dfltparm;
1946
1947   memset (&dfltparm, 0, sizeof dfltparm);
1948   dfltparm.ctrl = ctrl;
1949   dfltparm.keyinfo.keyid       = keyid;
1950   dfltparm.keyinfo.mainkeyid   = mainkeyid;
1951   dfltparm.keyinfo.pubkey_algo = pubkey_algo;
1952
1953   *r_sigval = NULL;
1954   err = start_agent (ctrl, 0);
1955   if (err)
1956     return err;
1957   dfltparm.ctx = agent_ctx;
1958
1959   if (digestlen*2 + 50 > DIM(line))
1960     return gpg_error (GPG_ERR_GENERAL);
1961
1962   err = assuan_transact (agent_ctx, "RESET",
1963                          NULL, NULL, NULL, NULL, NULL, NULL);
1964   if (err)
1965     return err;
1966
1967   snprintf (line, DIM(line)-1, "SIGKEY %s", keygrip);
1968   line[DIM(line)-1] = 0;
1969   err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
1970   if (err)
1971     return err;
1972
1973   if (desc)
1974     {
1975       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
1976       line[DIM(line)-1] = 0;
1977       err = assuan_transact (agent_ctx, line,
1978                             NULL, NULL, NULL, NULL, NULL, NULL);
1979       if (err)
1980         return err;
1981     }
1982
1983   snprintf (line, sizeof line, "SETHASH %d ", digestalgo);
1984   bin2hex (digest, digestlen, line + strlen (line));
1985   err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
1986   if (err)
1987     return err;
1988
1989   init_membuf (&data, 1024);
1990
1991   snprintf (line, sizeof line, "PKSIGN%s%s",
1992             cache_nonce? " -- ":"",
1993             cache_nonce? cache_nonce:"");
1994   err = assuan_transact (agent_ctx, line,
1995                          put_membuf_cb, &data,
1996                          default_inq_cb, &dfltparm,
1997                          NULL, NULL);
1998   if (err)
1999     xfree (get_membuf (&data, NULL));
2000   else
2001     {
2002       unsigned char *buf;
2003       size_t len;
2004
2005       buf = get_membuf (&data, &len);
2006       if (!buf)
2007         err = gpg_error_from_syserror ();
2008       else
2009         {
2010           err = gcry_sexp_sscan (r_sigval, NULL, buf, len);
2011           xfree (buf);
2012         }
2013     }
2014   return err;
2015 }
2016
2017
2018 \f
2019 /* Handle a CIPHERTEXT inquiry.  Note, we only send the data,
2020    assuan_transact takes care of flushing and writing the END. */
2021 static gpg_error_t
2022 inq_ciphertext_cb (void *opaque, const char *line)
2023 {
2024   struct cipher_parm_s *parm = opaque;
2025   int rc;
2026
2027   if (has_leading_keyword (line, "CIPHERTEXT"))
2028     {
2029       assuan_begin_confidential (parm->ctx);
2030       rc = assuan_send_data (parm->dflt->ctx,
2031                              parm->ciphertext, parm->ciphertextlen);
2032       assuan_end_confidential (parm->ctx);
2033     }
2034   else
2035     rc = default_inq_cb (parm->dflt, line);
2036
2037   return rc;
2038 }
2039
2040
2041 /* Check whether there is any padding info from the agent.  */
2042 static gpg_error_t
2043 padding_info_cb (void *opaque, const char *line)
2044 {
2045   int *r_padding = opaque;
2046   const char *s;
2047
2048   if ((s=has_leading_keyword (line, "PADDING")))
2049     {
2050       *r_padding = atoi (s);
2051     }
2052
2053   return 0;
2054 }
2055
2056
2057 /* Call the agent to do a decrypt operation using the key identified
2058    by the hex string KEYGRIP and the input data S_CIPHERTEXT.  On the
2059    success the decoded value is stored verbatim at R_BUF and its
2060    length at R_BUF; the callers needs to release it.  KEYID, MAINKEYID
2061    and PUBKEY_ALGO are used to construct additional promots or status
2062    messages.   The padding information is stored at R_PADDING with -1
2063    for not known.  */
2064 gpg_error_t
2065 agent_pkdecrypt (ctrl_t ctrl, const char *keygrip, const char *desc,
2066                  u32 *keyid, u32 *mainkeyid, int pubkey_algo,
2067                  gcry_sexp_t s_ciphertext,
2068                  unsigned char **r_buf, size_t *r_buflen, int *r_padding)
2069 {
2070   gpg_error_t err;
2071   char line[ASSUAN_LINELENGTH];
2072   membuf_t data;
2073   size_t n, len;
2074   char *p, *buf, *endp;
2075   struct default_inq_parm_s dfltparm;
2076
2077   memset (&dfltparm, 0, sizeof dfltparm);
2078   dfltparm.ctrl = ctrl;
2079   dfltparm.keyinfo.keyid       = keyid;
2080   dfltparm.keyinfo.mainkeyid   = mainkeyid;
2081   dfltparm.keyinfo.pubkey_algo = pubkey_algo;
2082
2083   if (!keygrip || strlen(keygrip) != 40
2084       || !s_ciphertext || !r_buf || !r_buflen || !r_padding)
2085     return gpg_error (GPG_ERR_INV_VALUE);
2086
2087   *r_buf = NULL;
2088   *r_padding = -1;
2089
2090   err = start_agent (ctrl, 0);
2091   if (err)
2092     return err;
2093   dfltparm.ctx = agent_ctx;
2094
2095   err = assuan_transact (agent_ctx, "RESET",
2096                          NULL, NULL, NULL, NULL, NULL, NULL);
2097   if (err)
2098     return err;
2099
2100   snprintf (line, sizeof line, "SETKEY %s", keygrip);
2101   err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
2102   if (err)
2103     return err;
2104
2105   if (desc)
2106     {
2107       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
2108       line[DIM(line)-1] = 0;
2109       err = assuan_transact (agent_ctx, line,
2110                             NULL, NULL, NULL, NULL, NULL, NULL);
2111       if (err)
2112         return err;
2113     }
2114
2115   init_membuf_secure (&data, 1024);
2116   {
2117     struct cipher_parm_s parm;
2118
2119     parm.dflt = &dfltparm;
2120     parm.ctx = agent_ctx;
2121     err = make_canon_sexp (s_ciphertext, &parm.ciphertext, &parm.ciphertextlen);
2122     if (err)
2123       return err;
2124     err = assuan_transact (agent_ctx, "PKDECRYPT",
2125                            put_membuf_cb, &data,
2126                            inq_ciphertext_cb, &parm,
2127                            padding_info_cb, r_padding);
2128     xfree (parm.ciphertext);
2129   }
2130   if (err)
2131     {
2132       xfree (get_membuf (&data, &len));
2133       return err;
2134     }
2135
2136   put_membuf (&data, "", 1); /* Make sure it is 0 terminated.  */
2137   buf = get_membuf (&data, &len);
2138   if (!buf)
2139     return gpg_error_from_syserror ();
2140   assert (len); /* (we forced Nul termination.)  */
2141
2142   if (*buf != '(')
2143     {
2144       xfree (buf);
2145       return gpg_error (GPG_ERR_INV_SEXP);
2146     }
2147
2148   if (len < 13 || memcmp (buf, "(5:value", 8) ) /* "(5:valueN:D)\0" */
2149     {
2150       xfree (buf);
2151       return gpg_error (GPG_ERR_INV_SEXP);
2152     }
2153   len -= 10;   /* Count only the data of the second part. */
2154   p = buf + 8; /* Skip leading parenthesis and the value tag. */
2155
2156   n = strtoul (p, &endp, 10);
2157   if (!n || *endp != ':')
2158     {
2159       xfree (buf);
2160       return gpg_error (GPG_ERR_INV_SEXP);
2161     }
2162   endp++;
2163   if (endp-p+n > len)
2164     {
2165       xfree (buf);
2166       return gpg_error (GPG_ERR_INV_SEXP); /* Oops: Inconsistent S-Exp. */
2167     }
2168
2169   memmove (buf, endp, n);
2170
2171   *r_buflen = n;
2172   *r_buf = buf;
2173   return 0;
2174 }
2175
2176
2177 \f
2178 /* Retrieve a key encryption key from the agent.  With FOREXPORT true
2179    the key shall be used for export, with false for import.  On success
2180    the new key is stored at R_KEY and its length at R_KEKLEN.  */
2181 gpg_error_t
2182 agent_keywrap_key (ctrl_t ctrl, int forexport, void **r_kek, size_t *r_keklen)
2183 {
2184   gpg_error_t err;
2185   membuf_t data;
2186   size_t len;
2187   unsigned char *buf;
2188   char line[ASSUAN_LINELENGTH];
2189   struct default_inq_parm_s dfltparm;
2190
2191   memset (&dfltparm, 0, sizeof dfltparm);
2192   dfltparm.ctrl = ctrl;
2193
2194   *r_kek = NULL;
2195   err = start_agent (ctrl, 0);
2196   if (err)
2197     return err;
2198   dfltparm.ctx = agent_ctx;
2199
2200   snprintf (line, DIM(line)-1, "KEYWRAP_KEY %s",
2201             forexport? "--export":"--import");
2202
2203   init_membuf_secure (&data, 64);
2204   err = assuan_transact (agent_ctx, line,
2205                          put_membuf_cb, &data,
2206                          default_inq_cb, &dfltparm,
2207                          NULL, NULL);
2208   if (err)
2209     {
2210       xfree (get_membuf (&data, &len));
2211       return err;
2212     }
2213   buf = get_membuf (&data, &len);
2214   if (!buf)
2215     return gpg_error_from_syserror ();
2216   *r_kek = buf;
2217   *r_keklen = len;
2218   return 0;
2219 }
2220
2221
2222 \f
2223 /* Handle the inquiry for an IMPORT_KEY command.  */
2224 static gpg_error_t
2225 inq_import_key_parms (void *opaque, const char *line)
2226 {
2227   struct import_key_parm_s *parm = opaque;
2228   gpg_error_t err;
2229
2230   if (has_leading_keyword (line, "KEYDATA"))
2231     {
2232       err = assuan_send_data (parm->dflt->ctx, parm->key, parm->keylen);
2233     }
2234   else
2235     err = default_inq_cb (parm->dflt, line);
2236
2237   return err;
2238 }
2239
2240
2241 /* Call the agent to import a key into the agent.  */
2242 gpg_error_t
2243 agent_import_key (ctrl_t ctrl, const char *desc, char **cache_nonce_addr,
2244                   const void *key, size_t keylen, int unattended, int force)
2245 {
2246   gpg_error_t err;
2247   struct import_key_parm_s parm;
2248   struct cache_nonce_parm_s cn_parm;
2249   char line[ASSUAN_LINELENGTH];
2250   struct default_inq_parm_s dfltparm;
2251
2252   memset (&dfltparm, 0, sizeof dfltparm);
2253   dfltparm.ctrl = ctrl;
2254
2255   err = start_agent (ctrl, 0);
2256   if (err)
2257     return err;
2258   dfltparm.ctx = agent_ctx;
2259
2260   if (desc)
2261     {
2262       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
2263       line[DIM(line)-1] = 0;
2264       err = assuan_transact (agent_ctx, line,
2265                             NULL, NULL, NULL, NULL, NULL, NULL);
2266       if (err)
2267         return err;
2268     }
2269
2270   parm.dflt   = &dfltparm;
2271   parm.key    = key;
2272   parm.keylen = keylen;
2273
2274   snprintf (line, sizeof line, "IMPORT_KEY%s%s%s%s",
2275             unattended? " --unattended":"",
2276             force? " --force":"",
2277             cache_nonce_addr && *cache_nonce_addr? " ":"",
2278             cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"");
2279   cn_parm.cache_nonce_addr = cache_nonce_addr;
2280   cn_parm.passwd_nonce_addr = NULL;
2281   err = assuan_transact (agent_ctx, line,
2282                          NULL, NULL,
2283                          inq_import_key_parms, &parm,
2284                          cache_nonce_status_cb, &cn_parm);
2285   return err;
2286 }
2287
2288
2289 \f
2290 /* Receive a secret key from the agent.  HEXKEYGRIP is the hexified
2291    keygrip, DESC a prompt to be displayed with the agent's passphrase
2292    question (needs to be plus+percent escaped).  If CACHE_NONCE_ADDR
2293    is not NULL the agent is advised to first try a passphrase
2294    associated with that nonce.  On success the key is stored as a
2295    canonical S-expression at R_RESULT and R_RESULTLEN.  */
2296 gpg_error_t
2297 agent_export_key (ctrl_t ctrl, const char *hexkeygrip, const char *desc,
2298                   char **cache_nonce_addr,
2299                   unsigned char **r_result, size_t *r_resultlen)
2300 {
2301   gpg_error_t err;
2302   struct cache_nonce_parm_s cn_parm;
2303   membuf_t data;
2304   size_t len;
2305   unsigned char *buf;
2306   char line[ASSUAN_LINELENGTH];
2307   struct default_inq_parm_s dfltparm;
2308
2309   memset (&dfltparm, 0, sizeof dfltparm);
2310   dfltparm.ctrl = ctrl;
2311
2312   *r_result = NULL;
2313
2314   err = start_agent (ctrl, 0);
2315   if (err)
2316     return err;
2317   dfltparm.ctx = agent_ctx;
2318
2319   if (desc)
2320     {
2321       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
2322       err = assuan_transact (agent_ctx, line,
2323                              NULL, NULL, NULL, NULL, NULL, NULL);
2324       if (err)
2325         return err;
2326     }
2327
2328   snprintf (line, DIM(line)-1, "EXPORT_KEY --openpgp %s%s %s",
2329             cache_nonce_addr && *cache_nonce_addr? "--cache-nonce=":"",
2330             cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"",
2331             hexkeygrip);
2332
2333   init_membuf_secure (&data, 1024);
2334   cn_parm.cache_nonce_addr = cache_nonce_addr;
2335   cn_parm.passwd_nonce_addr = NULL;
2336   err = assuan_transact (agent_ctx, line,
2337                          put_membuf_cb, &data,
2338                          default_inq_cb, &dfltparm,
2339                          cache_nonce_status_cb, &cn_parm);
2340   if (err)
2341     {
2342       xfree (get_membuf (&data, &len));
2343       return err;
2344     }
2345   buf = get_membuf (&data, &len);
2346   if (!buf)
2347     return gpg_error_from_syserror ();
2348   *r_result = buf;
2349   *r_resultlen = len;
2350   return 0;
2351 }
2352
2353
2354 \f
2355 /* Ask the agent to delete the key identified by HEXKEYGRIP.  If DESC
2356    is not NULL, display DESC instead of the default description
2357    message.  */
2358 gpg_error_t
2359 agent_delete_key (ctrl_t ctrl, const char *hexkeygrip, const char *desc)
2360 {
2361   gpg_error_t err;
2362   char line[ASSUAN_LINELENGTH];
2363   struct default_inq_parm_s dfltparm;
2364
2365   memset (&dfltparm, 0, sizeof dfltparm);
2366   dfltparm.ctrl = ctrl;
2367
2368   err = start_agent (ctrl, 0);
2369   if (err)
2370     return err;
2371
2372   if (!hexkeygrip || strlen (hexkeygrip) != 40)
2373     return gpg_error (GPG_ERR_INV_VALUE);
2374
2375   if (desc)
2376     {
2377       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
2378       err = assuan_transact (agent_ctx, line,
2379                              NULL, NULL, NULL, NULL, NULL, NULL);
2380       if (err)
2381         return err;
2382     }
2383
2384   snprintf (line, DIM(line)-1, "DELETE_KEY %s", hexkeygrip);
2385   err = assuan_transact (agent_ctx, line, NULL, NULL,
2386                          default_inq_cb, &dfltparm,
2387                          NULL, NULL);
2388   return err;
2389 }
2390
2391
2392 \f
2393 /* Ask the agent to change the passphrase of the key identified by
2394    HEXKEYGRIP.  If DESC is not NULL, display DESC instead of the
2395    default description message.  If CACHE_NONCE_ADDR is not NULL the
2396    agent is advised to first try a passphrase associated with that
2397    nonce.  If PASSWD_NONCE_ADDR is not NULL the agent will try to use
2398    the passphrase associated with that nonce.  */
2399 gpg_error_t
2400 agent_passwd (ctrl_t ctrl, const char *hexkeygrip, const char *desc,
2401               char **cache_nonce_addr, char **passwd_nonce_addr)
2402 {
2403   gpg_error_t err;
2404   struct cache_nonce_parm_s cn_parm;
2405   char line[ASSUAN_LINELENGTH];
2406   struct default_inq_parm_s dfltparm;
2407
2408   memset (&dfltparm, 0, sizeof dfltparm);
2409   dfltparm.ctrl = ctrl;
2410
2411   err = start_agent (ctrl, 0);
2412   if (err)
2413     return err;
2414   dfltparm.ctx = agent_ctx;
2415
2416   if (!hexkeygrip || strlen (hexkeygrip) != 40)
2417     return gpg_error (GPG_ERR_INV_VALUE);
2418
2419
2420   if (desc)
2421     {
2422       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
2423       err = assuan_transact (agent_ctx, line,
2424                              NULL, NULL, NULL, NULL, NULL, NULL);
2425       if (err)
2426         return err;
2427     }
2428
2429   snprintf (line, DIM(line)-1, "PASSWD %s%s %s%s %s",
2430             cache_nonce_addr && *cache_nonce_addr? "--cache-nonce=":"",
2431             cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"",
2432             passwd_nonce_addr && *passwd_nonce_addr? "--passwd-nonce=":"",
2433             passwd_nonce_addr && *passwd_nonce_addr? *passwd_nonce_addr:"",
2434             hexkeygrip);
2435   cn_parm.cache_nonce_addr = cache_nonce_addr;
2436   cn_parm.passwd_nonce_addr = passwd_nonce_addr;
2437   err = assuan_transact (agent_ctx, line, NULL, NULL,
2438                          default_inq_cb, &dfltparm,
2439                          cache_nonce_status_cb, &cn_parm);
2440   return err;
2441 }
2442
2443 /* Return the version reported by gpg-agent.  */
2444 gpg_error_t
2445 agent_get_version (ctrl_t ctrl, char **r_version)
2446 {
2447   gpg_error_t err;
2448
2449   err = start_agent (ctrl, 0);
2450   if (err)
2451     return err;
2452
2453   err = get_assuan_server_version (agent_ctx, 0, r_version);
2454   return err;
2455 }