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