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