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