A whole bunch of changes to allow building for Windows.
[gnupg.git] / sm / call-agent.c
1 /* call-agent.c - divert operations to the agent
2  *      Copyright (C) 2001, 2002, 2003, 2005 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
19  * USA.
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <errno.h>
27 #include <unistd.h> 
28 #include <time.h>
29 #include <assert.h>
30 #ifdef HAVE_LOCALE_H
31 #include <locale.h>
32 #endif
33
34 #include "gpgsm.h"
35 #include <gcrypt.h>
36 #include <assuan.h>
37 #include "i18n.h"
38 #include "asshelp.h"
39 #include "keydb.h" /* fixme: Move this to import.c */
40 #include "../common/membuf.h"
41
42
43 static assuan_context_t agent_ctx = NULL;
44 static int force_pipe_server = 0;
45
46 struct cipher_parm_s
47 {
48   assuan_context_t ctx;
49   const unsigned char *ciphertext;
50   size_t ciphertextlen;
51 };
52
53 struct genkey_parm_s
54 {
55   assuan_context_t ctx;
56   const unsigned char *sexp;
57   size_t sexplen;
58 };
59
60 struct learn_parm_s
61 {
62   int error;
63   assuan_context_t ctx;
64   membuf_t *data;
65 };
66
67
68 \f
69 /* Try to connect to the agent via socket or fork it off and work by
70    pipes.  Handle the server's initial greeting */
71 static int
72 start_agent (ctrl_t ctrl)
73 {
74   int rc = 0;
75   char *infostr, *p;
76   assuan_context_t ctx;
77
78   if (agent_ctx)
79     return 0; /* fixme: We need a context for each thread or serialize
80                  the access to the agent (which is suitable given that
81                  the agent is not MT. */
82
83   infostr = force_pipe_server? NULL : getenv ("GPG_AGENT_INFO");
84   if (!infostr || !*infostr)
85     {
86       const char *pgmname;
87       const char *argv[3];
88       char *sockname;
89       int no_close_list[3];
90       int i;
91
92       /* First check whether we can connect at the standard
93          socket.  */
94       sockname = make_filename (opt.homedir, "S.gpg-agent", NULL);
95       rc = assuan_socket_connect (&ctx, sockname, 0);
96       xfree (sockname);
97 #ifdef HAVE_W32_SYSTEM
98 #      warning Print a warning if connecting is not possible
99       /* and offer to fire up the agent.  */
100 #endif
101
102       if (rc)
103         {
104           /* With no success start a new server.  */
105           if (opt.verbose)
106             log_info (_("no running gpg-agent - starting one\n"));
107           
108           gpgsm_status (ctrl, STATUS_PROGRESS, "starting_agent ? 0 0");
109           
110           if (fflush (NULL))
111             {
112               gpg_error_t tmperr = gpg_error (gpg_err_code_from_errno (errno));
113               log_error ("error flushing pending output: %s\n",
114                          strerror (errno));
115               return tmperr;
116             }
117           
118           if (!opt.agent_program || !*opt.agent_program)
119             opt.agent_program = gnupg_module_name (GNUPG_MODULE_NAME_AGENT);
120           if ( !(pgmname = strrchr (opt.agent_program, '/')))
121             pgmname = opt.agent_program;
122           else
123             pgmname++;
124
125           argv[0] = pgmname;
126           argv[1] = "--server";
127           argv[2] = NULL;
128
129           i=0;
130           if (log_get_fd () != -1)
131             no_close_list[i++] = log_get_fd ();
132           no_close_list[i++] = fileno (stderr);
133           no_close_list[i] = -1;
134
135           /* Connect to the agent and perform initial handshaking. */
136           rc = assuan_pipe_connect (&ctx, opt.agent_program, argv,
137                                     no_close_list);
138         }
139     }
140   else
141     {
142       int prot;
143       int pid;
144
145       infostr = xstrdup (infostr);
146       if ( !(p = strchr (infostr, PATHSEP_C)) || p == infostr)
147         {
148           log_error (_("malformed GPG_AGENT_INFO environment variable\n"));
149           xfree (infostr);
150           force_pipe_server = 1;
151           return start_agent (ctrl);
152         }
153       *p++ = 0;
154       pid = atoi (p);
155       while (*p && *p != PATHSEP_C)
156         p++;
157       prot = *p? atoi (p+1) : 0;
158       if (prot != 1)
159         {
160           log_error (_("gpg-agent protocol version %d is not supported\n"),
161                      prot);
162           xfree (infostr);
163           force_pipe_server = 1;
164           return start_agent (ctrl);
165         }
166
167       rc = assuan_socket_connect (&ctx, infostr, pid);
168       xfree (infostr);
169       if (gpg_err_code (rc) == GPG_ERR_ASS_CONNECT_FAILED)
170         {
171           log_info (_("can't connect to the agent - trying fall back\n"));
172           force_pipe_server = 1;
173           return start_agent (ctrl);
174         }
175     }
176
177   if (rc)
178     {
179       log_error ("can't connect to the agent: %s\n", gpg_strerror (rc));
180       return gpg_error (GPG_ERR_NO_AGENT);
181     }
182   agent_ctx = ctx;
183
184   if (DBG_ASSUAN)
185     log_debug ("connection to agent established\n");
186
187   rc = assuan_transact (agent_ctx, "RESET", NULL, NULL, NULL, NULL, NULL, NULL);
188   if (rc)
189     return rc;
190
191   return send_pinentry_environment (agent_ctx, GPG_ERR_SOURCE_DEFAULT,
192                                     opt.display, opt.ttyname, opt.ttytype,
193                                     opt.lc_ctype, opt.lc_messages);
194 }
195
196
197 static int
198 membuf_data_cb (void *opaque, const void *buffer, size_t length)
199 {
200   membuf_t *data = opaque;
201
202   if (buffer)
203     put_membuf (data, buffer, length);
204   return 0;
205 }
206   
207
208
209 \f
210 /* Call the agent to do a sign operation using the key identified by
211    the hex string KEYGRIP. */
212 int
213 gpgsm_agent_pksign (ctrl_t ctrl, const char *keygrip, const char *desc,
214                     unsigned char *digest, size_t digestlen, int digestalgo,
215                     unsigned char **r_buf, size_t *r_buflen )
216 {
217   int rc, i;
218   char *p, line[ASSUAN_LINELENGTH];
219   membuf_t data;
220   size_t len;
221
222   *r_buf = NULL;
223   rc = start_agent (ctrl);
224   if (rc)
225     return rc;
226
227   if (digestlen*2 + 50 > DIM(line))
228     return gpg_error (GPG_ERR_GENERAL);
229
230   rc = assuan_transact (agent_ctx, "RESET", NULL, NULL, NULL, NULL, NULL, NULL);
231   if (rc)
232     return rc;
233
234   snprintf (line, DIM(line)-1, "SIGKEY %s", keygrip);
235   line[DIM(line)-1] = 0;
236   rc = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
237   if (rc)
238     return rc;
239
240   if (desc)
241     {
242       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
243       line[DIM(line)-1] = 0;
244       rc = assuan_transact (agent_ctx, line,
245                             NULL, NULL, NULL, NULL, NULL, NULL);
246       if (rc)
247         return rc;
248     }
249
250   sprintf (line, "SETHASH %d ", digestalgo);
251   p = line + strlen (line);
252   for (i=0; i < digestlen ; i++, p += 2 )
253     sprintf (p, "%02X", digest[i]);
254   rc = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
255   if (rc)
256     return rc;
257
258   init_membuf (&data, 1024);
259   rc = assuan_transact (agent_ctx, "PKSIGN",
260                         membuf_data_cb, &data, NULL, NULL, NULL, NULL);
261   if (rc)
262     {
263       xfree (get_membuf (&data, &len));
264       return rc;
265     }
266   *r_buf = get_membuf (&data, r_buflen);
267
268   if (!gcry_sexp_canon_len (*r_buf, *r_buflen, NULL, NULL))
269     {
270       xfree (*r_buf); *r_buf = NULL;
271       return gpg_error (GPG_ERR_INV_VALUE);
272     }
273
274   return *r_buf? 0 : out_of_core ();
275 }
276
277
278 /* Call the scdaemon to do a sign operation using the key identified by
279    the hex string KEYID. */
280 int
281 gpgsm_scd_pksign (ctrl_t ctrl, const char *keyid, const char *desc,
282                   unsigned char *digest, size_t digestlen, int digestalgo,
283                   unsigned char **r_buf, size_t *r_buflen )
284 {
285   int rc, i;
286   char *p, line[ASSUAN_LINELENGTH];
287   membuf_t data;
288   size_t len;
289   const char *hashopt;
290   unsigned char *sigbuf;
291   size_t sigbuflen;
292
293   *r_buf = NULL;
294
295   switch(digestalgo)
296     {
297     case GCRY_MD_SHA1:  hashopt = "--hash=sha1"; break;
298     case GCRY_MD_RMD160:hashopt = "--hash=rmd160"; break;
299     case GCRY_MD_MD5:   hashopt = "--hash=md5"; break;
300     case GCRY_MD_SHA256:hashopt = "--hash=sha256"; break;
301     default: 
302       return gpg_error (GPG_ERR_DIGEST_ALGO);
303     }
304
305   rc = start_agent (ctrl);
306   if (rc)
307     return rc;
308
309   if (digestlen*2 + 50 > DIM(line))
310     return gpg_error (GPG_ERR_GENERAL);
311
312   p = stpcpy (line, "SCD SETDATA " );
313   for (i=0; i < digestlen ; i++, p += 2 )
314     sprintf (p, "%02X", digest[i]);
315   rc = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
316   if (rc)
317     return rc;
318
319   init_membuf (&data, 1024);
320
321   snprintf (line, DIM(line)-1, "SCD PKSIGN %s %s", hashopt, keyid);
322   line[DIM(line)-1] = 0;
323   rc = assuan_transact (agent_ctx, line,
324                         membuf_data_cb, &data, NULL, NULL, NULL, NULL);
325   if (rc)
326     {
327       xfree (get_membuf (&data, &len));
328       return rc;
329     }
330   sigbuf = get_membuf (&data, &sigbuflen);
331
332   /* Create an S-expression from it which is formatted like this:
333      "(7:sig-val(3:rsa(1:sSIGBUFLEN:SIGBUF)))" Fixme: If a card ever
334      creates non-RSA keys we need to change things. */
335   *r_buflen = 21 + 11 + sigbuflen + 4;
336   p = xtrymalloc (*r_buflen);
337   *r_buf = (unsigned char*)p;
338   if (!p)
339     {
340       xfree (sigbuf);
341       return 0;
342     }
343   p = stpcpy (p, "(7:sig-val(3:rsa(1:s" );
344   sprintf (p, "%u:", (unsigned int)sigbuflen);
345   p += strlen (p);
346   memcpy (p, sigbuf, sigbuflen);
347   p += sigbuflen;
348   strcpy (p, ")))");
349   xfree (sigbuf);
350
351   assert (gcry_sexp_canon_len (*r_buf, *r_buflen, NULL, NULL));
352   return  0;
353 }
354
355
356
357 \f
358 /* Handle a CIPHERTEXT inquiry.  Note, we only send the data,
359    assuan_transact talkes care of flushing and writing the end */
360 static int
361 inq_ciphertext_cb (void *opaque, const char *keyword)
362 {
363   struct cipher_parm_s *parm = opaque; 
364   int rc;
365
366   assuan_begin_confidential (parm->ctx);
367   rc = assuan_send_data (parm->ctx, parm->ciphertext, parm->ciphertextlen);
368   assuan_end_confidential (parm->ctx);
369   return rc; 
370 }
371
372
373 /* Call the agent to do a decrypt operation using the key identified by
374    the hex string KEYGRIP. */
375 int
376 gpgsm_agent_pkdecrypt (ctrl_t ctrl, const char *keygrip, const char *desc,
377                        ksba_const_sexp_t ciphertext, 
378                        char **r_buf, size_t *r_buflen )
379 {
380   int rc;
381   char line[ASSUAN_LINELENGTH];
382   membuf_t data;
383   struct cipher_parm_s cipher_parm;
384   size_t n, len;
385   char *p, *buf, *endp;
386   size_t ciphertextlen;
387   
388   if (!keygrip || strlen(keygrip) != 40 || !ciphertext || !r_buf || !r_buflen)
389     return gpg_error (GPG_ERR_INV_VALUE);
390   *r_buf = NULL;
391
392   ciphertextlen = gcry_sexp_canon_len (ciphertext, 0, NULL, NULL);
393   if (!ciphertextlen)
394     return gpg_error (GPG_ERR_INV_VALUE);
395
396   rc = start_agent (ctrl);
397   if (rc)
398     return rc;
399
400   rc = assuan_transact (agent_ctx, "RESET", NULL, NULL, NULL, NULL, NULL, NULL);
401   if (rc)
402     return rc;
403
404   assert ( DIM(line) >= 50 );
405   snprintf (line, DIM(line)-1, "SETKEY %s", keygrip);
406   line[DIM(line)-1] = 0;
407   rc = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
408   if (rc)
409     return rc;
410
411   if (desc)
412     {
413       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
414       line[DIM(line)-1] = 0;
415       rc = assuan_transact (agent_ctx, line,
416                             NULL, NULL, NULL, NULL, NULL, NULL);
417       if (rc)
418         return rc;
419     }
420
421   init_membuf (&data, 1024);
422   cipher_parm.ctx = agent_ctx;
423   cipher_parm.ciphertext = ciphertext;
424   cipher_parm.ciphertextlen = ciphertextlen;
425   rc = assuan_transact (agent_ctx, "PKDECRYPT",
426                         membuf_data_cb, &data,
427                         inq_ciphertext_cb, &cipher_parm, NULL, NULL);
428   if (rc)
429     {
430       xfree (get_membuf (&data, &len));
431       return rc;
432     }
433
434   put_membuf (&data, "", 1); /* Make sure it is 0 terminated. */
435   buf = get_membuf (&data, &len);
436   if (!buf)
437     return gpg_error (GPG_ERR_ENOMEM);
438   assert (len); /* (we forced Nul termination.)  */
439
440   if (*buf == '(')
441     {
442       if (len < 13 || memcmp (buf, "(5:value", 8) ) /* "(5:valueN:D)\0" */
443         return gpg_error (GPG_ERR_INV_SEXP);
444       len -= 11;   /* Count only the data of the second part. */
445       p = buf + 8; /* Skip leading parenthesis and the value tag. */
446     }
447   else
448     {
449       /* For compatibility with older gpg-agents handle the old style
450          incomplete S-exps. */
451       len--;      /* Do not count the Nul. */
452       p = buf;
453     }
454
455   n = strtoul (p, &endp, 10);
456   if (!n || *endp != ':')
457     return gpg_error (GPG_ERR_INV_SEXP);
458   endp++;
459   if (endp-p+n > len)
460     return gpg_error (GPG_ERR_INV_SEXP); /* Oops: Inconsistent S-Exp. */
461   
462   memmove (buf, endp, n);
463
464   *r_buflen = n;
465   *r_buf = buf;
466   return 0;
467 }
468
469
470
471
472 \f
473 /* Handle a KEYPARMS inquiry.  Note, we only send the data,
474    assuan_transact takes care of flushing and writing the end */
475 static int
476 inq_genkey_parms (void *opaque, const char *keyword)
477 {
478   struct genkey_parm_s *parm = opaque; 
479   int rc;
480
481   rc = assuan_send_data (parm->ctx, parm->sexp, parm->sexplen);
482   return rc; 
483 }
484
485
486 \f
487 /* Call the agent to generate a newkey */
488 int
489 gpgsm_agent_genkey (ctrl_t ctrl,
490                     ksba_const_sexp_t keyparms, ksba_sexp_t *r_pubkey)
491 {
492   int rc;
493   struct genkey_parm_s gk_parm;
494   membuf_t data;
495   size_t len;
496   unsigned char *buf;
497
498   *r_pubkey = NULL;
499   rc = start_agent (ctrl);
500   if (rc)
501     return rc;
502
503   rc = assuan_transact (agent_ctx, "RESET", NULL, NULL, NULL, NULL, NULL, NULL);
504   if (rc)
505     return rc;
506
507   init_membuf (&data, 1024);
508   gk_parm.ctx = agent_ctx;
509   gk_parm.sexp = keyparms;
510   gk_parm.sexplen = gcry_sexp_canon_len (keyparms, 0, NULL, NULL);
511   if (!gk_parm.sexplen)
512     return gpg_error (GPG_ERR_INV_VALUE);
513   rc = assuan_transact (agent_ctx, "GENKEY",
514                         membuf_data_cb, &data, 
515                         inq_genkey_parms, &gk_parm, NULL, NULL);
516   if (rc)
517     {
518       xfree (get_membuf (&data, &len));
519       return rc;
520     }
521   buf = get_membuf (&data, &len);
522   if (!buf)
523     return gpg_error (GPG_ERR_ENOMEM);
524   if (!gcry_sexp_canon_len (buf, len, NULL, NULL))
525     {
526       xfree (buf);
527       return gpg_error (GPG_ERR_INV_SEXP);
528     }
529   *r_pubkey = buf;
530   return 0;
531 }
532
533 \f
534 /* Call the agent to read the public key part for a given keygrip.  If
535    FROMCARD is true, the key is directly read from the current
536    smartcard. In this case HEXKEYGRIP should be the keyID
537    (e.g. OPENPGP.3). */
538 int
539 gpgsm_agent_readkey (ctrl_t ctrl, int fromcard, const char *hexkeygrip,
540                      ksba_sexp_t *r_pubkey)
541 {
542   int rc;
543   membuf_t data;
544   size_t len;
545   unsigned char *buf;
546   char line[ASSUAN_LINELENGTH];
547
548   *r_pubkey = NULL;
549   rc = start_agent (ctrl);
550   if (rc)
551     return rc;
552
553   rc = assuan_transact (agent_ctx, "RESET",NULL, NULL, NULL, NULL, NULL, NULL);
554   if (rc)
555     return rc;
556
557   snprintf (line, DIM(line)-1, "%sREADKEY %s",
558             fromcard? "SCD ":"", hexkeygrip);
559   line[DIM(line)-1] = 0;
560
561   init_membuf (&data, 1024);
562   rc = assuan_transact (agent_ctx, line,
563                         membuf_data_cb, &data, 
564                         NULL, NULL, NULL, NULL);
565   if (rc)
566     {
567       xfree (get_membuf (&data, &len));
568       return rc;
569     }
570   buf = get_membuf (&data, &len);
571   if (!buf)
572     return gpg_error (GPG_ERR_ENOMEM);
573   if (!gcry_sexp_canon_len (buf, len, NULL, NULL))
574     {
575       xfree (buf);
576       return gpg_error (GPG_ERR_INV_SEXP);
577     }
578   *r_pubkey = buf;
579   return 0;
580 }
581
582 \f
583
584 static int
585 istrusted_status_cb (void *opaque, const char *line)
586 {
587   struct rootca_flags_s *flags = opaque;
588
589   if (!strncmp (line, "TRUSTLISTFLAG", 13) && (line[13]==' ' || !line[13]))
590     {
591       for (line += 13; *line == ' '; line++)
592         ;
593       if (!strncmp (line, "relax", 5) && (line[5] == ' ' || !line[5]))
594         flags->relax = 1;
595     }
596   return 0;
597 }
598
599
600
601 /* Ask the agent whether the certificate is in the list of trusted
602    keys.  ROOTCA_FLAGS is guaranteed to be cleared on error. */
603 int
604 gpgsm_agent_istrusted (ctrl_t ctrl, ksba_cert_t cert,
605                        struct rootca_flags_s *rootca_flags)
606 {
607   int rc;
608   char *fpr;
609   char line[ASSUAN_LINELENGTH];
610
611   memset (rootca_flags, 0, sizeof *rootca_flags);
612
613   rc = start_agent (ctrl);
614   if (rc)
615     return rc;
616
617   fpr = gpgsm_get_fingerprint_hexstring (cert, GCRY_MD_SHA1);
618   if (!fpr)
619     {
620       log_error ("error getting the fingerprint\n");
621       return gpg_error (GPG_ERR_GENERAL);
622     }
623
624   snprintf (line, DIM(line)-1, "ISTRUSTED %s", fpr);
625   line[DIM(line)-1] = 0;
626   xfree (fpr);
627
628   rc = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL,
629                         istrusted_status_cb, rootca_flags);
630   return rc;
631 }
632
633 /* Ask the agent to mark CERT as a trusted Root-CA one */
634 int
635 gpgsm_agent_marktrusted (ctrl_t ctrl, ksba_cert_t cert)
636 {
637   int rc;
638   char *fpr, *dn;
639   char line[ASSUAN_LINELENGTH];
640
641   rc = start_agent (ctrl);
642   if (rc)
643     return rc;
644
645   fpr = gpgsm_get_fingerprint_hexstring (cert, GCRY_MD_SHA1);
646   if (!fpr)
647     {
648       log_error ("error getting the fingerprint\n");
649       return gpg_error (GPG_ERR_GENERAL);
650     }
651
652   dn = ksba_cert_get_issuer (cert, 0);
653   if (!dn)
654     {
655       xfree (fpr);
656       return gpg_error (GPG_ERR_GENERAL);
657     }
658   snprintf (line, DIM(line)-1, "MARKTRUSTED %s S %s", fpr, dn);
659   line[DIM(line)-1] = 0;
660   ksba_free (dn);
661   xfree (fpr);
662
663   rc = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
664   return rc;
665 }
666
667
668 \f
669 /* Ask the agent whether the a corresponding secret key is available
670    for the given keygrip */
671 int
672 gpgsm_agent_havekey (ctrl_t ctrl, const char *hexkeygrip)
673 {
674   int rc;
675   char line[ASSUAN_LINELENGTH];
676
677   rc = start_agent (ctrl);
678   if (rc)
679     return rc;
680
681   if (!hexkeygrip || strlen (hexkeygrip) != 40)
682     return gpg_error (GPG_ERR_INV_VALUE);
683
684   snprintf (line, DIM(line)-1, "HAVEKEY %s", hexkeygrip);
685   line[DIM(line)-1] = 0;
686
687   rc = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
688   return rc;
689 }
690
691 \f
692 static int
693 learn_cb (void *opaque, const void *buffer, size_t length)
694 {
695   struct learn_parm_s *parm = opaque;
696   size_t len;
697   char *buf;
698   ksba_cert_t cert;
699   int rc;
700
701   if (parm->error)
702     return 0;
703
704   if (buffer)
705     {
706       put_membuf (parm->data, buffer, length);
707       return 0;
708     }
709   /* END encountered - process what we have */
710   buf = get_membuf (parm->data, &len);
711   if (!buf)
712     {
713       parm->error = gpg_error (GPG_ERR_ENOMEM);
714       return 0;
715     }
716
717
718   /* FIXME: this should go into import.c */
719   rc = ksba_cert_new (&cert);
720   if (rc)
721     {
722       parm->error = rc;
723       return 0;
724     }
725   rc = ksba_cert_init_from_mem (cert, buf, len);
726   if (rc)
727     {
728       log_error ("failed to parse a certificate: %s\n", gpg_strerror (rc));
729       ksba_cert_release (cert);
730       parm->error = rc;
731       return 0;
732     }
733
734   rc = gpgsm_basic_cert_check (cert);
735   if (gpg_err_code (rc) == GPG_ERR_MISSING_CERT)
736     { /* For later use we store it in the ephemeral database. */
737       log_info ("issuer certificate missing - storing as ephemeral\n");
738       keydb_store_cert (cert, 1, NULL);
739     }
740   else if (rc)
741     log_error ("invalid certificate: %s\n", gpg_strerror (rc));
742   else
743     {
744       int existed;
745
746       if (!keydb_store_cert (cert, 0, &existed))
747         {
748           if (opt.verbose > 1 && existed)
749             log_info ("certificate already in DB\n");
750           else if (opt.verbose && !existed)
751             log_info ("certificate imported\n");
752         }
753     }
754
755   ksba_cert_release (cert);
756   init_membuf (parm->data, 4096);
757   return 0;
758 }
759   
760 /* Call the agent to learn about a smartcard */
761 int
762 gpgsm_agent_learn (ctrl_t ctrl)
763 {
764   int rc;
765   struct learn_parm_s learn_parm;
766   membuf_t data;
767   size_t len;
768
769   rc = start_agent (ctrl);
770   if (rc)
771     return rc;
772
773   init_membuf (&data, 4096);
774   learn_parm.error = 0;
775   learn_parm.ctx = agent_ctx;
776   learn_parm.data = &data;
777   rc = assuan_transact (agent_ctx, "LEARN --send",
778                         learn_cb, &learn_parm, 
779                         NULL, NULL, NULL, NULL);
780   xfree (get_membuf (&data, &len));
781   if (rc)
782     return rc;
783   return learn_parm.error;
784 }
785
786 \f
787 /* Ask the agent to change the passphrase of the key identified by
788    HEXKEYGRIP. If DESC is not NULL, display instead of the default
789    description message. */
790 int
791 gpgsm_agent_passwd (ctrl_t ctrl, const char *hexkeygrip, const char *desc)
792 {
793   int rc;
794   char line[ASSUAN_LINELENGTH];
795
796   rc = start_agent (ctrl);
797   if (rc)
798     return rc;
799
800   if (!hexkeygrip || strlen (hexkeygrip) != 40)
801     return gpg_error (GPG_ERR_INV_VALUE);
802
803   if (desc)
804     {
805       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
806       line[DIM(line)-1] = 0;
807       rc = assuan_transact (agent_ctx, line,
808                             NULL, NULL, NULL, NULL, NULL, NULL);
809       if (rc)
810         return rc;
811     }
812
813   snprintf (line, DIM(line)-1, "PASSWD %s", hexkeygrip);
814   line[DIM(line)-1] = 0;
815
816   rc = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
817   return rc;
818 }
819
820
821 \f
822 /* Ask the agent to pop up a confirmation dialog with the text DESC
823    and an okay and cancel button.  */
824 gpg_error_t
825 gpgsm_agent_get_confirmation (ctrl_t ctrl, const char *desc)
826 {
827   int rc;
828   char line[ASSUAN_LINELENGTH];
829
830   rc = start_agent (ctrl);
831   if (rc)
832     return rc;
833
834   snprintf (line, DIM(line)-1, "GET_CONFIRMATION %s", desc);
835   line[DIM(line)-1] = 0;
836
837   rc = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
838   return rc;
839 }