Implemented the --gen-key command as we can't use the gpgsm-gencert.sh under Windows.
[gnupg.git] / g10 / call-agent.c
1 /* call-agent.c - divert operations to the agent
2  * Copyright (C) 2001, 2002, 2003, 2006 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 #include <assuan.h>
34
35 #include "gpg.h"
36 #include "util.h"
37 #include "membuf.h"
38 #include "options.h"
39 #include "i18n.h"
40 #include "asshelp.h"
41 #include "call-agent.h"
42
43 #ifndef DBG_ASSUAN
44 # define DBG_ASSUAN 1
45 #endif
46
47 static assuan_context_t agent_ctx = NULL;
48
49 struct cipher_parm_s 
50 {
51   assuan_context_t ctx;
52   const char *ciphertext;
53   size_t ciphertextlen;
54 };
55
56 struct writekey_parm_s
57 {
58   assuan_context_t ctx;
59   const unsigned char *keydata;
60   size_t keydatalen;
61 };
62
63 struct genkey_parm_s 
64 {
65   assuan_context_t ctx;
66   const char *sexp;
67   size_t sexplen;
68 };
69
70
71 \f
72 /* Try to connect to the agent via socket or fork it off and work by
73    pipes.  Handle the server's initial greeting */
74 static int
75 start_agent (void)
76 {
77   if (agent_ctx)
78     return 0; /* Fixme: We need a context for each thread or serialize
79                  the access to the agent. */
80
81   return start_new_gpg_agent (&agent_ctx,
82                               GPG_ERR_SOURCE_DEFAULT,
83                               opt.homedir,
84                               opt.agent_program,
85                               opt.display, opt.ttyname, opt.ttytype,
86                               opt.lc_ctype, opt.lc_messages,
87                               opt.verbose, DBG_ASSUAN,
88                               NULL, NULL);
89 }
90
91
92 /* Return a new malloced string by unescaping the string S.  Escaping
93    is percent escaping and '+'/space mapping.  A binary nul will
94    silently be replaced by a 0xFF.  Function returns NULL to indicate
95    an out of memory status. */
96 static char *
97 unescape_status_string (const unsigned char *s)
98 {
99   char *buffer, *d;
100
101   buffer = d = xtrymalloc (strlen (s)+1);
102   if (!buffer)
103     return NULL;
104   while (*s)
105     {
106       if (*s == '%' && s[1] && s[2])
107         { 
108           s++;
109           *d = xtoi_2 (s);
110           if (!*d)
111             *d = '\xff';
112           d++;
113           s += 2;
114         }
115       else if (*s == '+')
116         {
117           *d++ = ' ';
118           s++;
119         }
120       else
121         *d++ = *s++;
122     }
123   *d = 0; 
124   return buffer;
125 }
126
127 /* Copy the text ATEXT into the buffer P and do plus '+' and percent
128    escaping.  Note that the provided buffer needs to be 3 times the
129    size of ATEXT plus 1.  Returns a pointer to the leading Nul in P. */
130 static char *
131 percent_plus_escape (char *p, const char *atext)
132 {
133   const unsigned char *s;
134
135   for (s=atext; *s; s++)
136     {
137       if (*s < ' ' || *s == '+')
138         {
139           sprintf (p, "%%%02X", *s);
140           p += 3;
141         }
142       else if (*s == ' ')
143         *p++ = '+';
144       else
145         *p++ = *s;
146     }
147   *p = 0;
148   return p;
149 }
150
151 /* Take a 20 byte hexencoded string and put it into the the provided
152    20 byte buffer FPR in binary format. */
153 static int
154 unhexify_fpr (const char *hexstr, unsigned char *fpr)
155 {
156   const char *s;
157   int n;
158
159   for (s=hexstr, n=0; hexdigitp (s); s++, n++)
160     ;
161   if (*s || (n != 40))
162     return 0; /* no fingerprint (invalid or wrong length). */
163   n /= 2;
164   for (s=hexstr, n=0; *s; s += 2, n++)
165     fpr[n] = xtoi_2 (s);
166   return 1; /* okay */
167 }
168
169 /* Take the serial number from LINE and return it verbatim in a newly
170    allocated string.  We make sure that only hex characters are
171    returned. */
172 static char *
173 store_serialno (const char *line)
174 {
175   const char *s;
176   char *p;
177
178   for (s=line; hexdigitp (s); s++)
179     ;
180   p = xtrymalloc (s + 1 - line);
181   if (p)
182     {
183       memcpy (p, line, s-line);
184       p[s-line] = 0;
185     }
186   return p;
187 }
188
189
190 \f
191 /* Release the card info structure INFO. */
192 void
193 agent_release_card_info (struct agent_card_info_s *info)
194 {
195   if (!info)
196     return;
197
198   xfree (info->serialno); info->serialno = NULL;
199   xfree (info->disp_name); info->disp_name = NULL;
200   xfree (info->disp_lang); info->disp_lang = NULL;
201   xfree (info->pubkey_url); info->pubkey_url = NULL;
202   xfree (info->login_data); info->login_data = NULL;
203   info->cafpr1valid = info->cafpr2valid = info->cafpr3valid = 0;
204   info->fpr1valid = info->fpr2valid = info->fpr3valid = 0;
205 }
206
207 static int
208 learn_status_cb (void *opaque, const char *line)
209 {
210   struct agent_card_info_s *parm = opaque;
211   const char *keyword = line;
212   int keywordlen;
213   int i;
214
215   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
216     ;
217   while (spacep (line))
218     line++;
219
220   if (keywordlen == 8 && !memcmp (keyword, "SERIALNO", keywordlen))
221     {
222       xfree (parm->serialno);
223       parm->serialno = store_serialno (line);
224     }
225   else if (keywordlen == 9 && !memcmp (keyword, "DISP-NAME", keywordlen))
226     {
227       xfree (parm->disp_name);
228       parm->disp_name = unescape_status_string (line);
229     }
230   else if (keywordlen == 9 && !memcmp (keyword, "DISP-LANG", keywordlen))
231     {
232       xfree (parm->disp_lang);
233       parm->disp_lang = unescape_status_string (line);
234     }
235   else if (keywordlen == 8 && !memcmp (keyword, "DISP-SEX", keywordlen))
236     {
237       parm->disp_sex = *line == '1'? 1 : *line == '2' ? 2: 0;
238     }
239   else if (keywordlen == 10 && !memcmp (keyword, "PUBKEY-URL", keywordlen))
240     {
241       xfree (parm->pubkey_url);
242       parm->pubkey_url = unescape_status_string (line);
243     }
244   else if (keywordlen == 10 && !memcmp (keyword, "LOGIN-DATA", keywordlen))
245     {
246       xfree (parm->login_data);
247       parm->login_data = unescape_status_string (line);
248     }
249   else if (keywordlen == 11 && !memcmp (keyword, "SIG-COUNTER", keywordlen))
250     {
251       parm->sig_counter = strtoul (line, NULL, 0);
252     }
253   else if (keywordlen == 10 && !memcmp (keyword, "CHV-STATUS", keywordlen))
254     {
255       char *p, *buf;
256
257       buf = p = unescape_status_string (line);
258       if (buf)
259         {
260           while (spacep (p))
261             p++;
262           parm->chv1_cached = atoi (p);
263           while (*p && !spacep (p))
264             p++;
265           while (spacep (p))
266             p++;
267           for (i=0; *p && i < 3; i++)
268             {
269               parm->chvmaxlen[i] = atoi (p);
270               while (*p && !spacep (p))
271                 p++;
272               while (spacep (p))
273                 p++;
274             }
275           for (i=0; *p && i < 3; i++)
276             {
277               parm->chvretry[i] = atoi (p);
278               while (*p && !spacep (p))
279                 p++;
280               while (spacep (p))
281                 p++;
282             }
283           xfree (buf);
284         }
285     }
286   else if (keywordlen == 7 && !memcmp (keyword, "KEY-FPR", keywordlen))
287     {
288       int no = atoi (line);
289       while (*line && !spacep (line))
290         line++;
291       while (spacep (line))
292         line++;
293       if (no == 1)
294         parm->fpr1valid = unhexify_fpr (line, parm->fpr1);
295       else if (no == 2)
296         parm->fpr2valid = unhexify_fpr (line, parm->fpr2);
297       else if (no == 3)
298         parm->fpr3valid = unhexify_fpr (line, parm->fpr3);
299     }
300   else if (keywordlen == 6 && !memcmp (keyword, "CA-FPR", keywordlen))
301     {
302       int no = atoi (line);
303       while (*line && !spacep (line))
304         line++;
305       while (spacep (line))
306         line++;
307       if (no == 1)
308         parm->cafpr1valid = unhexify_fpr (line, parm->cafpr1);
309       else if (no == 2)
310         parm->cafpr2valid = unhexify_fpr (line, parm->cafpr2);
311       else if (no == 3)
312         parm->cafpr3valid = unhexify_fpr (line, parm->cafpr3);
313     }
314   
315   return 0;
316 }
317
318 /* Call the agent to learn about a smartcard */
319 int
320 agent_learn (struct agent_card_info_s *info)
321 {
322   int rc;
323
324   rc = start_agent ();
325   if (rc)
326     return rc;
327
328   memset (info, 0, sizeof *info);
329   rc = assuan_transact (agent_ctx, "LEARN --send",
330                         NULL, NULL, NULL, NULL,
331                         learn_status_cb, info);
332   
333   return rc;
334 }
335
336 /* Call the agent to retrieve a data object.  This function returns
337    the data in the same structure as used by the learn command.  It is
338    allowed to update such a structure using this commmand. */
339 int
340 agent_scd_getattr (const char *name, struct agent_card_info_s *info)
341 {
342   int rc;
343   char line[ASSUAN_LINELENGTH];
344
345   if (!*name)
346     return gpg_error (GPG_ERR_INV_VALUE);
347
348   /* We assume that NAME does not need escaping. */
349   if (12 + strlen (name) > DIM(line)-1)
350     return gpg_error (GPG_ERR_TOO_LARGE);
351   stpcpy (stpcpy (line, "SCD GETATTR "), name); 
352
353   rc = start_agent ();
354   if (rc)
355     return rc;
356
357   rc = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL,
358                         learn_status_cb, info);
359   
360   return rc;
361 }
362
363 \f
364 /* Send an setattr command to the SCdaemon.  SERIALNO is not actually
365    used here but required by gpg 1.4's implementation of this code in
366    cardglue.c. */
367 int
368 agent_scd_setattr (const char *name,
369                    const unsigned char *value, size_t valuelen,
370                    const char *serialno)
371 {
372   int rc;
373   char line[ASSUAN_LINELENGTH];
374   char *p;
375
376   if (!*name || !valuelen)
377     return gpg_error (GPG_ERR_INV_VALUE);
378
379   /* We assume that NAME does not need escaping. */
380   if (12 + strlen (name) > DIM(line)-1)
381     return gpg_error (GPG_ERR_TOO_LARGE);
382       
383   p = stpcpy (stpcpy (line, "SCD SETATTR "), name); 
384   *p++ = ' ';
385   for (; valuelen; value++, valuelen--)
386     {
387       if (p >= line + DIM(line)-5 )
388         return gpg_error (GPG_ERR_TOO_LARGE);
389       if (*value < ' ' || *value == '+' || *value == '%')
390         {
391           sprintf (p, "%%%02X", *value);
392           p += 3;
393         }
394       else if (*value == ' ')
395         *p++ = '+';
396       else
397         *p++ = *value;
398     }
399   *p = 0;
400
401   rc = start_agent ();
402   if (rc)
403     return rc;
404
405   rc = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
406   return rc;
407 }
408
409
410 \f
411 /* Handle a KEYDATA inquiry.  Note, we only send the data,
412    assuan_transact takes care of flushing and writing the end */
413 static assuan_error_t
414 inq_writekey_parms (void *opaque, const char *keyword)
415 {
416   struct writekey_parm_s *parm = opaque; 
417
418   return assuan_send_data (parm->ctx, parm->keydata, parm->keydatalen);
419 }
420
421
422 /* Send a WRITEKEY command to the SCdaemon. */
423 int 
424 agent_scd_writekey (int keyno, const char *serialno,
425                     const unsigned char *keydata, size_t keydatalen)
426 {
427   int rc;
428   char line[ASSUAN_LINELENGTH];
429   struct writekey_parm_s parms;
430
431   rc = start_agent ();
432   if (rc)
433     return rc;
434
435   memset (&parms, 0, sizeof parms);
436
437   snprintf (line, DIM(line)-1, "SCD WRITEKEY --force OPENPGP.%d", keyno);
438   line[DIM(line)-1] = 0;
439   parms.ctx = agent_ctx;
440   parms.keydata = keydata;
441   parms.keydatalen = keydatalen;
442   
443   rc = assuan_transact (agent_ctx, line, NULL, NULL,
444                         inq_writekey_parms, &parms, NULL, NULL);
445
446   return rc;
447 }
448
449
450
451 \f
452 /* Status callback for the SCD GENKEY command. */
453 static int
454 scd_genkey_cb (void *opaque, const char *line)
455 {
456   struct agent_card_genkey_s *parm = opaque;
457   const char *keyword = line;
458   int keywordlen;
459   gpg_error_t rc;
460
461   log_debug ("got status line `%s'\n", line);
462   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
463     ;
464   while (spacep (line))
465     line++;
466
467   if (keywordlen == 7 && !memcmp (keyword, "KEY-FPR", keywordlen))
468     {
469       parm->fprvalid = unhexify_fpr (line, parm->fpr);
470     }
471   if (keywordlen == 8 && !memcmp (keyword, "KEY-DATA", keywordlen))
472     {
473       gcry_mpi_t a;
474       const char *name = line;
475
476       while (*line && !spacep (line))
477         line++;
478       while (spacep (line))
479         line++;
480
481       rc = gcry_mpi_scan (&a, GCRYMPI_FMT_HEX, line, 0, NULL);
482       if (rc)
483         log_error ("error parsing received key data: %s\n", gpg_strerror (rc));
484       else if (*name == 'n' && spacep (name+1))
485         parm->n = a;
486       else if (*name == 'e' && spacep (name+1))
487         parm->e = a;
488       else
489         {
490           log_info ("unknown parameter name in received key data\n");
491           gcry_mpi_release (a);
492         }
493     }
494   else if (keywordlen == 14 && !memcmp (keyword,"KEY-CREATED-AT", keywordlen))
495     {
496       parm->created_at = (u32)strtoul (line, NULL, 10);
497     }
498
499   return 0;
500 }
501
502 /* Send a GENKEY command to the SCdaemon.  SERIALNO is not used in
503    this implementation. */
504 int
505 agent_scd_genkey (struct agent_card_genkey_s *info, int keyno, int force,
506                   const char *serialno)
507 {
508   int rc;
509   char line[ASSUAN_LINELENGTH];
510
511   rc = start_agent ();
512   if (rc)
513     return rc;
514
515   memset (info, 0, sizeof *info);
516   snprintf (line, DIM(line)-1, "SCD GENKEY %s%d",
517             force? "--force ":"", keyno);
518   line[DIM(line)-1] = 0;
519
520   memset (info, 0, sizeof *info);
521   rc = assuan_transact (agent_ctx, line,
522                         NULL, NULL, NULL, NULL,
523                         scd_genkey_cb, info);
524   
525   return rc;
526 }
527
528 \f
529 static int
530 membuf_data_cb (void *opaque, const void *buffer, size_t length)
531 {
532   membuf_t *data = opaque;
533
534   if (buffer)
535     put_membuf (data, buffer, length);
536   return 0;
537 }
538   
539 /* Send a sign command to the scdaemon via gpg-agent's pass thru
540    mechanism. */
541 int
542 agent_scd_pksign (const char *serialno, int hashalgo,
543                   const unsigned char *indata, size_t indatalen,
544                   unsigned char **r_buf, size_t *r_buflen)
545 {
546   int rc, i;
547   char *p, line[ASSUAN_LINELENGTH];
548   membuf_t data;
549   size_t len;
550
551   /* Note, hashalgo is not yet used but hardwired to SHA1 in SCdaemon. */
552
553   *r_buf = NULL;
554   *r_buflen = 0;
555
556   rc = start_agent ();
557   if (rc)
558     return rc;
559
560   if (indatalen*2 + 50 > DIM(line))
561     return gpg_error (GPG_ERR_GENERAL);
562
563   sprintf (line, "SCD SETDATA ");
564   p = line + strlen (line);
565   for (i=0; i < indatalen ; i++, p += 2 )
566     sprintf (p, "%02X", indata[i]);
567   rc = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
568   if (rc)
569     return rc;
570
571   init_membuf (&data, 1024);
572 #if 0
573   if (!hashalgo) /* Temporary test hack. */
574     snprintf (line, DIM(line)-1, "SCD PKAUTH %s", serialno);
575   else
576 #endif
577     snprintf (line, DIM(line)-1, "SCD PKSIGN %s%s",
578               hashalgo == GCRY_MD_RMD160? "--hash=rmd160 " : "",
579               serialno);
580   line[DIM(line)-1] = 0;
581   rc = assuan_transact (agent_ctx, line, membuf_data_cb, &data,
582                         NULL, NULL, NULL, NULL);
583   if (rc)
584     {
585       xfree (get_membuf (&data, &len));
586       return rc;
587     }
588   *r_buf = get_membuf (&data, r_buflen);
589
590   return 0;
591 }
592
593
594 /* Decrypt INDATA of length INDATALEN using the card identified by
595    SERIALNO.  Return the plaintext in a nwly allocated buffer stored
596    at the address of R_BUF. 
597
598    Note, we currently support only RSA or more exactly algorithms
599    taking one input data element. */
600 int
601 agent_scd_pkdecrypt (const char *serialno,
602                      const unsigned char *indata, size_t indatalen,
603                      unsigned char **r_buf, size_t *r_buflen)
604 {
605   int rc, i;
606   char *p, line[ASSUAN_LINELENGTH];
607   membuf_t data;
608   size_t len;
609
610   *r_buf = NULL;
611   rc = start_agent ();
612   if (rc)
613     return rc;
614
615   /* FIXME: use secure memory where appropriate */
616   if (indatalen*2 + 50 > DIM(line))
617     return gpg_error (GPG_ERR_GENERAL);
618
619   sprintf (line, "SCD SETDATA ");
620   p = line + strlen (line);
621   for (i=0; i < indatalen ; i++, p += 2 )
622     sprintf (p, "%02X", indata[i]);
623   rc = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
624   if (rc)
625     return rc;
626
627   init_membuf (&data, 1024);
628   snprintf (line, DIM(line)-1, "SCD PKDECRYPT %s", serialno);
629   line[DIM(line)-1] = 0;
630   rc = assuan_transact (agent_ctx, line,
631                         membuf_data_cb, &data,
632                         NULL, NULL, NULL, NULL);
633   if (rc)
634     {
635       xfree (get_membuf (&data, &len));
636       return rc;
637     }
638   *r_buf = get_membuf (&data, r_buflen);
639   if (!*r_buf)
640     return gpg_error (GPG_ERR_ENOMEM);
641
642   return 0;
643 }
644
645
646 /* Change the PIN of an OpenPGP card or reset the retry counter.
647    CHVNO 1: Change the PIN
648          2: Same as 1
649          3: Change the admin PIN
650        101: Set a new PIN and reset the retry counter
651        102: Same as 101
652    SERIALNO is not used.
653  */
654 int
655 agent_scd_change_pin (int chvno, const char *serialno)
656 {
657   int rc;
658   char line[ASSUAN_LINELENGTH];
659   const char *reset = "";
660
661   if (chvno >= 100)
662     reset = "--reset";
663   chvno %= 100;
664
665   rc = start_agent ();
666   if (rc)
667     return rc;
668
669   snprintf (line, DIM(line)-1, "SCD PASSWD %s %d", reset, chvno);
670   line[DIM(line)-1] = 0;
671   rc = assuan_transact (agent_ctx, line, NULL, NULL,
672                         NULL, NULL, NULL, NULL);
673   return rc;
674 }
675
676
677 /* Perform a CHECKPIN operation.  SERIALNO should be the serial
678    number of the card - optionally followed by the fingerprint;
679    however the fingerprint is ignored here. */
680 int
681 agent_scd_checkpin  (const char *serialno)
682 {
683   int rc;
684   char line[ASSUAN_LINELENGTH];
685
686   rc = start_agent ();
687   if (rc)
688     return rc;
689
690   snprintf (line, DIM(line)-1, "SCD CHECKPIN %s", serialno);
691   line[DIM(line)-1] = 0;
692   return assuan_transact (agent_ctx, line,
693                           NULL, NULL,
694                           NULL, NULL, NULL, NULL);
695 }
696
697
698 /* Dummy function, only used by the gpg 1.4 implementation. */
699 void
700 agent_clear_pin_cache (const char *sn)
701 {
702
703 }
704
705
706
707 \f
708 /* Note: All strings shall be UTF-8. On success the caler needs to
709    free the string stored at R_PASSPHRASE. On error NULL will be
710    stored at R_PASSPHRASE and an appropriate fpf error code
711    returned. */
712 gpg_error_t
713 agent_get_passphrase (const char *cache_id,
714                       const char *err_msg,
715                       const char *prompt,
716                       const char *desc_msg,
717                       char **r_passphrase)
718 {
719   int rc;
720   char *line, *p;
721   char cmd[] = "GET_PASSPHRASE --data -- ";
722   membuf_t data;
723
724   *r_passphrase = NULL;
725
726   rc = start_agent ();
727   if (rc)
728     return rc;
729
730   /* We allocate 3 times the needed space for the texts so that
731      there is enough space for escaping. */
732   line = xtrymalloc ( strlen (cmd) + 1
733                       + (cache_id? 3*strlen (cache_id): 1) + 1
734                       + (err_msg?  3*strlen (err_msg): 1) + 1
735                       + (prompt?   3*strlen (prompt): 1) + 1
736                       + (desc_msg? 3*strlen (desc_msg): 1) + 1
737                       + 1);
738   if (!line)
739     return gpg_error_from_syserror ();
740
741   p = stpcpy (line, cmd);
742   if (cache_id && *cache_id)
743     p = percent_plus_escape (p, cache_id);
744   else
745     *p++ = 'X';
746   *p++ = ' ';
747
748   if (err_msg && *err_msg)
749     p = percent_plus_escape (p, err_msg);
750   else
751     *p++ = 'X';
752   *p++ = ' ';
753
754   if (prompt && *prompt)
755     p = percent_plus_escape (p, prompt);
756   else
757     *p++ = 'X'; 
758   *p++ = ' ';
759
760   if (desc_msg && *desc_msg)
761     p = percent_plus_escape (p, desc_msg);
762   else
763     *p++ = 'X';
764   *p = 0;
765
766   init_membuf_secure (&data, 64);
767   rc = assuan_transact (agent_ctx, line, 
768                         membuf_data_cb, &data, NULL, NULL, NULL, NULL);
769
770   if (rc)
771     xfree (get_membuf (&data, NULL));
772   else 
773     {
774       put_membuf (&data, "", 1);
775       *r_passphrase = get_membuf (&data, NULL);
776       if (!*r_passphrase)
777         rc = gpg_error_from_syserror ();
778     }
779   xfree (line);
780   return rc;
781 }
782
783
784 gpg_error_t
785 agent_clear_passphrase (const char *cache_id)
786 {
787   int rc;
788   char line[ASSUAN_LINELENGTH];
789
790   if (!cache_id || !*cache_id)
791     return 0;
792
793   rc = start_agent ();
794   if (rc)
795     return rc;
796
797   snprintf (line, DIM(line)-1, "CLEAR_PASSPHRASE %s", cache_id);
798   line[DIM(line)-1] = 0;
799   return assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
800 }