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