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