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