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