gpg: Re-enable the "Passphrase" parameter for batch key generation.
[gnupg.git] / g10 / call-agent.c
1 /* call-agent.c - Divert GPG operations to the agent.
2  * Copyright (C) 2001-2003, 2006-2011, 2013 Free Software Foundation, Inc.
3  * Copyright (C) 2013-2015  Werner Koch
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26 #include <unistd.h>
27 #include <time.h>
28 #include <assert.h>
29 #ifdef HAVE_LOCALE_H
30 #include <locale.h>
31 #endif
32
33 #include "gpg.h"
34 #include <assuan.h>
35 #include "util.h"
36 #include "membuf.h"
37 #include "options.h"
38 #include "i18n.h"
39 #include "asshelp.h"
40 #include "sysutils.h"
41 #include "call-agent.h"
42 #include "status.h"
43 #include "../common/shareddefs.h"
44
45 #ifndef DBG_ASSUAN
46 # define DBG_ASSUAN 1
47 #endif
48
49 #define CONTROL_D ('D' - 'A' + 1)
50
51
52 static assuan_context_t agent_ctx = NULL;
53 static int did_early_card_test;
54
55 struct default_inq_parm_s
56 {
57   ctrl_t ctrl;
58   assuan_context_t ctx;
59   struct {
60     u32 *keyid;
61     u32 *mainkeyid;
62     int pubkey_algo;
63   } keyinfo;
64 };
65
66 struct cipher_parm_s
67 {
68   struct default_inq_parm_s *dflt;
69   assuan_context_t ctx;
70   unsigned char *ciphertext;
71   size_t ciphertextlen;
72 };
73
74 struct writecert_parm_s
75 {
76   struct default_inq_parm_s *dflt;
77   const unsigned char *certdata;
78   size_t certdatalen;
79 };
80
81 struct writekey_parm_s
82 {
83   struct default_inq_parm_s *dflt;
84   const unsigned char *keydata;
85   size_t keydatalen;
86 };
87
88 struct genkey_parm_s
89 {
90   struct default_inq_parm_s *dflt;
91   const char *keyparms;
92   const char *passphrase;
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 if (has_leading_keyword (line, "NEWPASSWD") && parm->passphrase)
1741     {
1742       err = assuan_send_data (parm->dflt->ctx,
1743                               parm->passphrase,  strlen (parm->passphrase));
1744     }
1745   else
1746     err = default_inq_cb (parm->dflt, line);
1747
1748   return err;
1749 }
1750
1751
1752 /* Call the agent to generate a new key.  KEYPARMS is the usual
1753    S-expression giving the parameters of the key.  gpg-agent passes it
1754    gcry_pk_genkey.  If NO_PROTECTION is true the agent is advised not
1755    to protect the generated key.  If NO_PROTECTION is not set and
1756    PASSPHRASE is not NULL the agent is requested to protect the key
1757    with that passphrase instead of asking for one.  */
1758 gpg_error_t
1759 agent_genkey (ctrl_t ctrl, char **cache_nonce_addr,
1760               const char *keyparms, int no_protection,
1761               const char *passphrase, gcry_sexp_t *r_pubkey)
1762 {
1763   gpg_error_t err;
1764   struct genkey_parm_s gk_parm;
1765   struct cache_nonce_parm_s cn_parm;
1766   struct default_inq_parm_s dfltparm;
1767   membuf_t data;
1768   size_t len;
1769   unsigned char *buf;
1770   char line[ASSUAN_LINELENGTH];
1771
1772   memset (&dfltparm, 0, sizeof dfltparm);
1773   dfltparm.ctrl = ctrl;
1774
1775   *r_pubkey = NULL;
1776   err = start_agent (ctrl, 0);
1777   if (err)
1778     return err;
1779   dfltparm.ctx = agent_ctx;
1780
1781   err = assuan_transact (agent_ctx, "RESET",
1782                          NULL, NULL, NULL, NULL, NULL, NULL);
1783   if (err)
1784     return err;
1785
1786   init_membuf (&data, 1024);
1787   gk_parm.dflt     = &dfltparm;
1788   gk_parm.keyparms = keyparms;
1789   gk_parm.passphrase = passphrase;
1790   snprintf (line, sizeof line, "GENKEY%s%s%s",
1791             no_protection? " --no-protection" :
1792             passphrase   ? " --inq-passwd" :
1793             /*          */ "",
1794             cache_nonce_addr && *cache_nonce_addr? " ":"",
1795             cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"");
1796   cn_parm.cache_nonce_addr = cache_nonce_addr;
1797   cn_parm.passwd_nonce_addr = NULL;
1798   err = assuan_transact (agent_ctx, line,
1799                          membuf_data_cb, &data,
1800                          inq_genkey_parms, &gk_parm,
1801                          cache_nonce_status_cb, &cn_parm);
1802   if (err)
1803     {
1804       xfree (get_membuf (&data, &len));
1805       return err;
1806     }
1807
1808   buf = get_membuf (&data, &len);
1809   if (!buf)
1810     err = gpg_error_from_syserror ();
1811   else
1812     {
1813       err = gcry_sexp_sscan (r_pubkey, NULL, buf, len);
1814       xfree (buf);
1815     }
1816   return err;
1817 }
1818
1819
1820 \f
1821 /* Call the agent to read the public key part for a given keygrip.  If
1822    FROMCARD is true, the key is directly read from the current
1823    smartcard. In this case HEXKEYGRIP should be the keyID
1824    (e.g. OPENPGP.3). */
1825 gpg_error_t
1826 agent_readkey (ctrl_t ctrl, int fromcard, const char *hexkeygrip,
1827                unsigned char **r_pubkey)
1828 {
1829   gpg_error_t err;
1830   membuf_t data;
1831   size_t len;
1832   unsigned char *buf;
1833   char line[ASSUAN_LINELENGTH];
1834   struct default_inq_parm_s dfltparm;
1835
1836   memset (&dfltparm, 0, sizeof dfltparm);
1837   dfltparm.ctrl = ctrl;
1838
1839   *r_pubkey = NULL;
1840   err = start_agent (ctrl, 0);
1841   if (err)
1842     return err;
1843   dfltparm.ctx = agent_ctx;
1844
1845   err = assuan_transact (agent_ctx, "RESET",NULL, NULL, NULL, NULL, NULL, NULL);
1846   if (err)
1847     return err;
1848
1849   snprintf (line, DIM(line)-1, "%sREADKEY %s", fromcard? "SCD ":"", hexkeygrip);
1850
1851   init_membuf (&data, 1024);
1852   err = assuan_transact (agent_ctx, line,
1853                          membuf_data_cb, &data,
1854                          default_inq_cb, &dfltparm,
1855                          NULL, NULL);
1856   if (err)
1857     {
1858       xfree (get_membuf (&data, &len));
1859       return err;
1860     }
1861   buf = get_membuf (&data, &len);
1862   if (!buf)
1863     return gpg_error_from_syserror ();
1864   if (!gcry_sexp_canon_len (buf, len, NULL, NULL))
1865     {
1866       xfree (buf);
1867       return gpg_error (GPG_ERR_INV_SEXP);
1868     }
1869   *r_pubkey = buf;
1870   return 0;
1871 }
1872
1873
1874 \f
1875 /* Call the agent to do a sign operation using the key identified by
1876    the hex string KEYGRIP.  DESC is a description of the key to be
1877    displayed if the agent needs to ask for the PIN.  DIGEST and
1878    DIGESTLEN is the hash value to sign and DIGESTALGO the algorithm id
1879    used to compute the digest.  If CACHE_NONCE is used the agent is
1880    advised to first try a passphrase associated with that nonce. */
1881 gpg_error_t
1882 agent_pksign (ctrl_t ctrl, const char *cache_nonce,
1883               const char *keygrip, const char *desc,
1884               u32 *keyid, u32 *mainkeyid, int pubkey_algo,
1885               unsigned char *digest, size_t digestlen, int digestalgo,
1886               gcry_sexp_t *r_sigval)
1887 {
1888   gpg_error_t err;
1889   char line[ASSUAN_LINELENGTH];
1890   membuf_t data;
1891   struct default_inq_parm_s dfltparm;
1892
1893   memset (&dfltparm, 0, sizeof dfltparm);
1894   dfltparm.ctrl = ctrl;
1895   dfltparm.keyinfo.keyid       = keyid;
1896   dfltparm.keyinfo.mainkeyid   = mainkeyid;
1897   dfltparm.keyinfo.pubkey_algo = pubkey_algo;
1898
1899   *r_sigval = NULL;
1900   err = start_agent (ctrl, 0);
1901   if (err)
1902     return err;
1903   dfltparm.ctx = agent_ctx;
1904
1905   if (digestlen*2 + 50 > DIM(line))
1906     return gpg_error (GPG_ERR_GENERAL);
1907
1908   err = assuan_transact (agent_ctx, "RESET",
1909                          NULL, NULL, NULL, NULL, NULL, NULL);
1910   if (err)
1911     return err;
1912
1913   snprintf (line, DIM(line)-1, "SIGKEY %s", keygrip);
1914   line[DIM(line)-1] = 0;
1915   err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
1916   if (err)
1917     return err;
1918
1919   if (desc)
1920     {
1921       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
1922       line[DIM(line)-1] = 0;
1923       err = assuan_transact (agent_ctx, line,
1924                             NULL, NULL, NULL, NULL, NULL, NULL);
1925       if (err)
1926         return err;
1927     }
1928
1929   snprintf (line, sizeof line, "SETHASH %d ", digestalgo);
1930   bin2hex (digest, digestlen, line + strlen (line));
1931   err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
1932   if (err)
1933     return err;
1934
1935   init_membuf (&data, 1024);
1936
1937   snprintf (line, sizeof line, "PKSIGN%s%s",
1938             cache_nonce? " -- ":"",
1939             cache_nonce? cache_nonce:"");
1940   err = assuan_transact (agent_ctx, line,
1941                          membuf_data_cb, &data,
1942                          default_inq_cb, &dfltparm,
1943                          NULL, NULL);
1944   if (err)
1945     xfree (get_membuf (&data, NULL));
1946   else
1947     {
1948       unsigned char *buf;
1949       size_t len;
1950
1951       buf = get_membuf (&data, &len);
1952       if (!buf)
1953         err = gpg_error_from_syserror ();
1954       else
1955         {
1956           err = gcry_sexp_sscan (r_sigval, NULL, buf, len);
1957           xfree (buf);
1958         }
1959     }
1960   return err;
1961 }
1962
1963
1964 \f
1965 /* Handle a CIPHERTEXT inquiry.  Note, we only send the data,
1966    assuan_transact takes care of flushing and writing the END. */
1967 static gpg_error_t
1968 inq_ciphertext_cb (void *opaque, const char *line)
1969 {
1970   struct cipher_parm_s *parm = opaque;
1971   int rc;
1972
1973   if (has_leading_keyword (line, "CIPHERTEXT"))
1974     {
1975       assuan_begin_confidential (parm->ctx);
1976       rc = assuan_send_data (parm->dflt->ctx,
1977                              parm->ciphertext, parm->ciphertextlen);
1978       assuan_end_confidential (parm->ctx);
1979     }
1980   else
1981     rc = default_inq_cb (parm->dflt, line);
1982
1983   return rc;
1984 }
1985
1986
1987 /* Check whether there is any padding info from the agent.  */
1988 static gpg_error_t
1989 padding_info_cb (void *opaque, const char *line)
1990 {
1991   int *r_padding = opaque;
1992   const char *s;
1993
1994   if ((s=has_leading_keyword (line, "PADDING")))
1995     {
1996       *r_padding = atoi (s);
1997     }
1998
1999   return 0;
2000 }
2001
2002
2003 /* Call the agent to do a decrypt operation using the key identified
2004    by the hex string KEYGRIP and the input data S_CIPHERTEXT.  On the
2005    success the decoded value is stored verbatim at R_BUF and its
2006    length at R_BUF; the callers needs to release it.  KEYID, MAINKEYID
2007    and PUBKEY_ALGO are used to construct additional promots or status
2008    messages.   The padding information is stored at R_PADDING with -1
2009    for not known.  */
2010 gpg_error_t
2011 agent_pkdecrypt (ctrl_t ctrl, const char *keygrip, const char *desc,
2012                  u32 *keyid, u32 *mainkeyid, int pubkey_algo,
2013                  gcry_sexp_t s_ciphertext,
2014                  unsigned char **r_buf, size_t *r_buflen, int *r_padding)
2015 {
2016   gpg_error_t err;
2017   char line[ASSUAN_LINELENGTH];
2018   membuf_t data;
2019   size_t n, len;
2020   char *p, *buf, *endp;
2021   struct default_inq_parm_s dfltparm;
2022
2023   memset (&dfltparm, 0, sizeof dfltparm);
2024   dfltparm.ctrl = ctrl;
2025   dfltparm.keyinfo.keyid       = keyid;
2026   dfltparm.keyinfo.mainkeyid   = mainkeyid;
2027   dfltparm.keyinfo.pubkey_algo = pubkey_algo;
2028
2029   if (!keygrip || strlen(keygrip) != 40
2030       || !s_ciphertext || !r_buf || !r_buflen || !r_padding)
2031     return gpg_error (GPG_ERR_INV_VALUE);
2032
2033   *r_buf = NULL;
2034   *r_padding = -1;
2035
2036   err = start_agent (ctrl, 0);
2037   if (err)
2038     return err;
2039   dfltparm.ctx = agent_ctx;
2040
2041   err = assuan_transact (agent_ctx, "RESET",
2042                          NULL, NULL, NULL, NULL, NULL, NULL);
2043   if (err)
2044     return err;
2045
2046   snprintf (line, sizeof line, "SETKEY %s", keygrip);
2047   err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
2048   if (err)
2049     return err;
2050
2051   if (desc)
2052     {
2053       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
2054       line[DIM(line)-1] = 0;
2055       err = assuan_transact (agent_ctx, line,
2056                             NULL, NULL, NULL, NULL, NULL, NULL);
2057       if (err)
2058         return err;
2059     }
2060
2061   init_membuf_secure (&data, 1024);
2062   {
2063     struct cipher_parm_s parm;
2064
2065     parm.dflt = &dfltparm;
2066     parm.ctx = agent_ctx;
2067     err = make_canon_sexp (s_ciphertext, &parm.ciphertext, &parm.ciphertextlen);
2068     if (err)
2069       return err;
2070     err = assuan_transact (agent_ctx, "PKDECRYPT",
2071                            membuf_data_cb, &data,
2072                            inq_ciphertext_cb, &parm,
2073                            padding_info_cb, r_padding);
2074     xfree (parm.ciphertext);
2075   }
2076   if (err)
2077     {
2078       xfree (get_membuf (&data, &len));
2079       return err;
2080     }
2081
2082   put_membuf (&data, "", 1); /* Make sure it is 0 terminated.  */
2083   buf = get_membuf (&data, &len);
2084   if (!buf)
2085     return gpg_error_from_syserror ();
2086   assert (len); /* (we forced Nul termination.)  */
2087
2088   if (*buf != '(')
2089     {
2090       xfree (buf);
2091       return gpg_error (GPG_ERR_INV_SEXP);
2092     }
2093
2094   if (len < 13 || memcmp (buf, "(5:value", 8) ) /* "(5:valueN:D)\0" */
2095     {
2096       xfree (buf);
2097       return gpg_error (GPG_ERR_INV_SEXP);
2098     }
2099   len -= 10;   /* Count only the data of the second part. */
2100   p = buf + 8; /* Skip leading parenthesis and the value tag. */
2101
2102   n = strtoul (p, &endp, 10);
2103   if (!n || *endp != ':')
2104     {
2105       xfree (buf);
2106       return gpg_error (GPG_ERR_INV_SEXP);
2107     }
2108   endp++;
2109   if (endp-p+n > len)
2110     {
2111       xfree (buf);
2112       return gpg_error (GPG_ERR_INV_SEXP); /* Oops: Inconsistent S-Exp. */
2113     }
2114
2115   memmove (buf, endp, n);
2116
2117   *r_buflen = n;
2118   *r_buf = buf;
2119   return 0;
2120 }
2121
2122
2123 \f
2124 /* Retrieve a key encryption key from the agent.  With FOREXPORT true
2125    the key shall be used for export, with false for import.  On success
2126    the new key is stored at R_KEY and its length at R_KEKLEN.  */
2127 gpg_error_t
2128 agent_keywrap_key (ctrl_t ctrl, int forexport, void **r_kek, size_t *r_keklen)
2129 {
2130   gpg_error_t err;
2131   membuf_t data;
2132   size_t len;
2133   unsigned char *buf;
2134   char line[ASSUAN_LINELENGTH];
2135   struct default_inq_parm_s dfltparm;
2136
2137   memset (&dfltparm, 0, sizeof dfltparm);
2138   dfltparm.ctrl = ctrl;
2139
2140   *r_kek = NULL;
2141   err = start_agent (ctrl, 0);
2142   if (err)
2143     return err;
2144   dfltparm.ctx = agent_ctx;
2145
2146   snprintf (line, DIM(line)-1, "KEYWRAP_KEY %s",
2147             forexport? "--export":"--import");
2148
2149   init_membuf_secure (&data, 64);
2150   err = assuan_transact (agent_ctx, line,
2151                          membuf_data_cb, &data,
2152                          default_inq_cb, &dfltparm,
2153                          NULL, NULL);
2154   if (err)
2155     {
2156       xfree (get_membuf (&data, &len));
2157       return err;
2158     }
2159   buf = get_membuf (&data, &len);
2160   if (!buf)
2161     return gpg_error_from_syserror ();
2162   *r_kek = buf;
2163   *r_keklen = len;
2164   return 0;
2165 }
2166
2167
2168 \f
2169 /* Handle the inquiry for an IMPORT_KEY command.  */
2170 static gpg_error_t
2171 inq_import_key_parms (void *opaque, const char *line)
2172 {
2173   struct import_key_parm_s *parm = opaque;
2174   gpg_error_t err;
2175
2176   if (has_leading_keyword (line, "KEYDATA"))
2177     {
2178       err = assuan_send_data (parm->dflt->ctx, parm->key, parm->keylen);
2179     }
2180   else
2181     err = default_inq_cb (parm->dflt, line);
2182
2183   return err;
2184 }
2185
2186
2187 /* Call the agent to import a key into the agent.  */
2188 gpg_error_t
2189 agent_import_key (ctrl_t ctrl, const char *desc, char **cache_nonce_addr,
2190                   const void *key, size_t keylen, int unattended)
2191 {
2192   gpg_error_t err;
2193   struct import_key_parm_s parm;
2194   struct cache_nonce_parm_s cn_parm;
2195   char line[ASSUAN_LINELENGTH];
2196   struct default_inq_parm_s dfltparm;
2197
2198   memset (&dfltparm, 0, sizeof dfltparm);
2199   dfltparm.ctrl = ctrl;
2200
2201   err = start_agent (ctrl, 0);
2202   if (err)
2203     return err;
2204   dfltparm.ctx = agent_ctx;
2205
2206   if (desc)
2207     {
2208       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
2209       line[DIM(line)-1] = 0;
2210       err = assuan_transact (agent_ctx, line,
2211                             NULL, NULL, NULL, NULL, NULL, NULL);
2212       if (err)
2213         return err;
2214     }
2215
2216   parm.dflt   = &dfltparm;
2217   parm.key    = key;
2218   parm.keylen = keylen;
2219
2220   snprintf (line, sizeof line, "IMPORT_KEY%s%s%s",
2221             unattended? " --unattended":"",
2222             cache_nonce_addr && *cache_nonce_addr? " ":"",
2223             cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"");
2224   cn_parm.cache_nonce_addr = cache_nonce_addr;
2225   cn_parm.passwd_nonce_addr = NULL;
2226   err = assuan_transact (agent_ctx, line,
2227                          NULL, NULL,
2228                          inq_import_key_parms, &parm,
2229                          cache_nonce_status_cb, &cn_parm);
2230   return err;
2231 }
2232
2233
2234 \f
2235 /* Receive a secret key from the agent.  HEXKEYGRIP is the hexified
2236    keygrip, DESC a prompt to be displayed with the agent's passphrase
2237    question (needs to be plus+percent escaped).  If CACHE_NONCE_ADDR
2238    is not NULL the agent is advised to first try a passphrase
2239    associated with that nonce.  On success the key is stored as a
2240    canonical S-expression at R_RESULT and R_RESULTLEN.  */
2241 gpg_error_t
2242 agent_export_key (ctrl_t ctrl, const char *hexkeygrip, const char *desc,
2243                   char **cache_nonce_addr,
2244                   unsigned char **r_result, size_t *r_resultlen)
2245 {
2246   gpg_error_t err;
2247   struct cache_nonce_parm_s cn_parm;
2248   membuf_t data;
2249   size_t len;
2250   unsigned char *buf;
2251   char line[ASSUAN_LINELENGTH];
2252   struct default_inq_parm_s dfltparm;
2253
2254   memset (&dfltparm, 0, sizeof dfltparm);
2255   dfltparm.ctrl = ctrl;
2256
2257   *r_result = NULL;
2258
2259   err = start_agent (ctrl, 0);
2260   if (err)
2261     return err;
2262   dfltparm.ctx = agent_ctx;
2263
2264   if (desc)
2265     {
2266       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
2267       err = assuan_transact (agent_ctx, line,
2268                              NULL, NULL, NULL, NULL, NULL, NULL);
2269       if (err)
2270         return err;
2271     }
2272
2273   snprintf (line, DIM(line)-1, "EXPORT_KEY --openpgp %s%s %s",
2274             cache_nonce_addr && *cache_nonce_addr? "--cache-nonce=":"",
2275             cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"",
2276             hexkeygrip);
2277
2278   init_membuf_secure (&data, 1024);
2279   cn_parm.cache_nonce_addr = cache_nonce_addr;
2280   cn_parm.passwd_nonce_addr = NULL;
2281   err = assuan_transact (agent_ctx, line,
2282                          membuf_data_cb, &data,
2283                          default_inq_cb, &dfltparm,
2284                          cache_nonce_status_cb, &cn_parm);
2285   if (err)
2286     {
2287       xfree (get_membuf (&data, &len));
2288       return err;
2289     }
2290   buf = get_membuf (&data, &len);
2291   if (!buf)
2292     return gpg_error_from_syserror ();
2293   *r_result = buf;
2294   *r_resultlen = len;
2295   return 0;
2296 }
2297
2298
2299 \f
2300 /* Ask the agent to delete the key identified by HEXKEYGRIP.  If DESC
2301    is not NULL, display DESC instead of the default description
2302    message.  */
2303 gpg_error_t
2304 agent_delete_key (ctrl_t ctrl, const char *hexkeygrip, const char *desc)
2305 {
2306   gpg_error_t err;
2307   char line[ASSUAN_LINELENGTH];
2308   struct default_inq_parm_s dfltparm;
2309
2310   memset (&dfltparm, 0, sizeof dfltparm);
2311   dfltparm.ctrl = ctrl;
2312
2313   err = start_agent (ctrl, 0);
2314   if (err)
2315     return err;
2316
2317   if (!hexkeygrip || strlen (hexkeygrip) != 40)
2318     return gpg_error (GPG_ERR_INV_VALUE);
2319
2320   if (desc)
2321     {
2322       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
2323       err = assuan_transact (agent_ctx, line,
2324                              NULL, NULL, NULL, NULL, NULL, NULL);
2325       if (err)
2326         return err;
2327     }
2328
2329   snprintf (line, DIM(line)-1, "DELETE_KEY %s", hexkeygrip);
2330   err = assuan_transact (agent_ctx, line, NULL, NULL,
2331                          default_inq_cb, &dfltparm,
2332                          NULL, NULL);
2333   return err;
2334 }
2335
2336
2337 \f
2338 /* Ask the agent to change the passphrase of the key identified by
2339    HEXKEYGRIP.  If DESC is not NULL, display DESC instead of the
2340    default description message.  If CACHE_NONCE_ADDR is not NULL the
2341    agent is advised to first try a passphrase associated with that
2342    nonce.  If PASSWD_NONCE_ADDR is not NULL the agent will try to use
2343    the passphrase associated with that nonce.  */
2344 gpg_error_t
2345 agent_passwd (ctrl_t ctrl, const char *hexkeygrip, const char *desc,
2346               char **cache_nonce_addr, char **passwd_nonce_addr)
2347 {
2348   gpg_error_t err;
2349   struct cache_nonce_parm_s cn_parm;
2350   char line[ASSUAN_LINELENGTH];
2351   struct default_inq_parm_s dfltparm;
2352
2353   memset (&dfltparm, 0, sizeof dfltparm);
2354   dfltparm.ctrl = ctrl;
2355
2356   err = start_agent (ctrl, 0);
2357   if (err)
2358     return err;
2359   dfltparm.ctx = agent_ctx;
2360
2361   if (!hexkeygrip || strlen (hexkeygrip) != 40)
2362     return gpg_error (GPG_ERR_INV_VALUE);
2363
2364
2365   if (desc)
2366     {
2367       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
2368       err = assuan_transact (agent_ctx, line,
2369                              NULL, NULL, NULL, NULL, NULL, NULL);
2370       if (err)
2371         return err;
2372     }
2373
2374   snprintf (line, DIM(line)-1, "PASSWD %s%s %s%s %s",
2375             cache_nonce_addr && *cache_nonce_addr? "--cache-nonce=":"",
2376             cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"",
2377             passwd_nonce_addr && *passwd_nonce_addr? "--passwd-nonce=":"",
2378             passwd_nonce_addr && *passwd_nonce_addr? *passwd_nonce_addr:"",
2379             hexkeygrip);
2380   cn_parm.cache_nonce_addr = cache_nonce_addr;
2381   cn_parm.passwd_nonce_addr = passwd_nonce_addr;
2382   err = assuan_transact (agent_ctx, line, NULL, NULL,
2383                          default_inq_cb, &dfltparm,
2384                          cache_nonce_status_cb, &cn_parm);
2385   return err;
2386 }
2387
2388 /* Return the version reported by gpg-agent.  */
2389 gpg_error_t
2390 agent_get_version (ctrl_t ctrl, char **r_version)
2391 {
2392   gpg_error_t err;
2393   membuf_t data;
2394
2395   err = start_agent (ctrl, 0);
2396   if (err)
2397     return err;
2398
2399   init_membuf (&data, 64);
2400   err = assuan_transact (agent_ctx, "GETINFO version",
2401                         membuf_data_cb, &data,
2402                         NULL, NULL, NULL, NULL);
2403   if (err)
2404     {
2405       xfree (get_membuf (&data, NULL));
2406       *r_version = NULL;
2407     }
2408   else
2409     {
2410       put_membuf (&data, "", 1);
2411       *r_version = get_membuf (&data, NULL);
2412       if (!*r_version)
2413         err = gpg_error_from_syserror ();
2414     }
2415   return err;
2416 }