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