Make gpgconf aware of --p12-charset.
[gnupg.git] / agent / command.c
1 /* command.c - gpg-agent command handler
2  * Copyright (C) 2001, 2002, 2003, 2004, 2005,
3  *               2006  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 2 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, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
20  * USA.
21  */
22
23 /* FIXME: we should not use the default assuan buffering but setup
24    some buffering in secure mempory to protect session keys etc. */
25
26 #include <config.h>
27
28 #include <errno.h>
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <ctype.h>
33 #include <unistd.h>
34 #include <assert.h>
35
36 #include <assuan.h>
37
38 #include "agent.h"
39
40 /* maximum allowed size of the inquired ciphertext */
41 #define MAXLEN_CIPHERTEXT 4096
42 /* maximum allowed size of the key parameters */
43 #define MAXLEN_KEYPARAM 1024
44
45 #define set_error(e,t) assuan_set_error (ctx, gpg_error (e), (t))
46
47
48 #if MAX_DIGEST_LEN < 20
49 #error MAX_DIGEST_LEN shorter than keygrip
50 #endif
51
52 /* Data used to associate an Assuan context with local server data */
53 struct server_local_s
54 {
55   assuan_context_t assuan_ctx;
56   int message_fd;
57   int use_cache_for_signing;
58   char *keydesc;  /* Allocated description for the next key
59                      operation. */
60   int pause_io_logging; /* Used to suppress I/O logging during a command */
61 };
62
63
64 /* An entry for the getval/putval commands. */
65 struct putval_item_s
66 {
67   struct putval_item_s *next;
68   size_t off;  /* Offset to the value into DATA.  */
69   size_t len;  /* Length of the value.  */
70   char d[1];   /* Key | Nul | value.  */ 
71 };
72
73
74 /* A list of key value pairs fpr the getval/putval commands.  */
75 static struct putval_item_s *putval_list;
76
77
78 \f
79 /* To help polling clients, we keep tarck of the number of certain
80    events.  This structure keeps those counters.  The counters are
81    integers and there should be no problem if they are overflowing as
82    callers need to check only whether a counter changed.  The actual
83    values are not meaningful. */
84 struct 
85 {
86   /* Incremented if any of the other counters below changed. */
87   unsigned int any;
88
89   /* Incremented if a key is added or removed from the internal privat
90      key database. */
91   unsigned int key; 
92
93   /* Incremented if a change of the card readers stati has been
94      detected. */
95   unsigned int card;
96
97 } eventcounter;
98
99
100
101
102 \f
103 /* Release the memory buffer MB but first wipe out the used memory. */
104 static void
105 clear_outbuf (membuf_t *mb)
106 {
107   void *p;
108   size_t n;
109
110   p = get_membuf (mb, &n);
111   if (p)
112     {
113       memset (p, 0, n);
114       xfree (p);
115     }
116 }
117
118
119 /* Write the content of memory buffer MB as assuan data to CTX and
120    wipe the buffer out afterwards. */
121 static gpg_error_t
122 write_and_clear_outbuf (assuan_context_t ctx, membuf_t *mb)
123 {
124   assuan_error_t ae;
125   void *p;
126   size_t n;
127
128   p = get_membuf (mb, &n);
129   if (!p)
130     return out_of_core ();
131   ae = assuan_send_data (ctx, p, n);
132   memset (p, 0, n);
133   xfree (p);
134   return ae;
135 }
136
137
138 static void
139 reset_notify (assuan_context_t ctx)
140 {
141   ctrl_t ctrl = assuan_get_pointer (ctx);
142
143   memset (ctrl->keygrip, 0, 20);
144   ctrl->have_keygrip = 0;
145   ctrl->digest.valuelen = 0;
146
147   xfree (ctrl->server_local->keydesc);
148   ctrl->server_local->keydesc = NULL;
149 }
150
151
152 /* Check whether the option NAME appears in LINE */
153 static int
154 has_option (const char *line, const char *name)
155 {
156   const char *s;
157   int n = strlen (name);
158
159   s = strstr (line, name);
160   return (s && (s == line || spacep (s-1)) && (!s[n] || spacep (s+n)));
161 }
162
163 /* Same as has_option but does only test for the name of the option
164    and ignores an argument, i.e. with NAME being "--hash" it would
165    return true for "--hash" as well as for "--hash=foo". */
166 static int
167 has_option_name (const char *line, const char *name)
168 {
169   const char *s;
170   int n = strlen (name);
171
172   s = strstr (line, name);
173   return (s && (s == line || spacep (s-1))
174           && (!s[n] || spacep (s+n) || s[n] == '='));
175 }
176
177
178 /* Skip over options.  It is assumed that leading spaces have been
179    removed (this is the case for lines passed to a handler from
180    assuan).  Blanks after the options are also removed. */
181 static char *
182 skip_options (char *line)
183 {
184   while ( *line == '-' && line[1] == '-' )
185     {
186       while (*line && !spacep (line))
187         line++;
188       while (spacep (line))
189         line++;
190     }
191   return line;
192 }
193
194
195 /* Replace all '+' by a blank. */
196 static void
197 plus_to_blank (char *s)
198 {
199   for (; *s; s++)
200     {
201       if (*s == '+')
202         *s = ' ';
203     }
204 }
205
206
207 /* Do the percent and plus/space unescaping in place and return the
208    length of the valid buffer. */
209 static size_t
210 percent_plus_unescape (char *string)
211 {
212   unsigned char *p = (unsigned char *)string;
213   size_t n = 0;
214
215   while (*string)
216     {
217       if (*string == '%' && string[1] && string[2])
218         { 
219           string++;
220           *p++ = xtoi_2 (string);
221           n++;
222           string+= 2;
223         }
224       else if (*string == '+')
225         {
226           *p++ = ' ';
227           n++;
228           string++;
229         }
230       else
231         {
232           *p++ = *string++;
233           n++;
234         }
235     }
236
237   return n;
238 }
239
240
241
242
243 /* Parse a hex string.  Return an Assuan error code or 0 on success and the
244    length of the parsed string in LEN. */
245 static int
246 parse_hexstring (assuan_context_t ctx, const char *string, size_t *len)
247 {
248   const char *p;
249   size_t n;
250
251   /* parse the hash value */
252   for (p=string, n=0; hexdigitp (p); p++, n++)
253     ;
254   if (*p != ' ' && *p != '\t' && *p)
255     return set_error (GPG_ERR_ASS_PARAMETER, "invalid hexstring");
256   if ((n&1))
257     return set_error (GPG_ERR_ASS_PARAMETER, "odd number of digits");
258   *len = n;
259   return 0;
260 }
261
262 /* Parse the keygrip in STRING into the provided buffer BUF.  BUF must
263    provide space for 20 bytes. BUF is not changed if the function
264    returns an error. */
265 static int
266 parse_keygrip (assuan_context_t ctx, const char *string, unsigned char *buf)
267 {
268   int rc;
269   size_t n;
270   const unsigned char *p;
271
272   rc = parse_hexstring (ctx, string, &n);
273   if (rc)
274     return rc;
275   n /= 2;
276   if (n != 20)
277     return set_error (GPG_ERR_ASS_PARAMETER, "invalid length of keygrip");
278
279   for (p=(const unsigned char*)string, n=0; n < 20; p += 2, n++)
280     buf[n] = xtoi_2 (p);
281
282   return 0;
283 }
284
285
286 /* Write an assuan status line. */
287 gpg_error_t
288 agent_write_status (ctrl_t ctrl, const char *keyword, ...)
289 {
290   gpg_error_t err = 0;
291   va_list arg_ptr;
292   const char *text;
293   assuan_context_t ctx = ctrl->server_local->assuan_ctx;
294   char buf[950], *p;
295   size_t n;
296
297   va_start (arg_ptr, keyword);
298
299   p = buf; 
300   n = 0;
301   while ( (text = va_arg (arg_ptr, const char *)) )
302     {
303       if (n)
304         {
305           *p++ = ' ';
306           n++;
307         }
308       for ( ; *text && n < DIM (buf)-2; n++)
309         *p++ = *text++;
310     }
311   *p = 0;
312   err = assuan_write_status (ctx, keyword, buf);
313
314   va_end (arg_ptr);
315   return err;
316 }
317
318
319 \f
320 /* GETEVENTCOUNTER
321
322    Return a a status line named EVENTCOUNTER with the current values
323    of all event counters.  The values are decimal numbers in the range
324    0 to UINT_MAX and wrapping around to 0.  The actual values should
325    not be relied upon, they shall only be used to detect a change.
326
327    The currently defined counters are:
328
329    ANY  - Incremented with any change of any of the other counters.
330    KEY  - Incremented for added or removed private keys.
331    CARD - Incremented for changes of the card readers stati.
332 */
333 static int
334 cmd_geteventcounter (assuan_context_t ctx, char *line)
335 {
336   ctrl_t ctrl = assuan_get_pointer (ctx);
337   char any_counter[25];
338   char key_counter[25];
339   char card_counter[25];
340
341   snprintf (any_counter, sizeof any_counter, "%u", eventcounter.any);
342   snprintf (key_counter, sizeof key_counter, "%u", eventcounter.key);
343   snprintf (card_counter, sizeof card_counter, "%u", eventcounter.card);
344
345   return agent_write_status (ctrl, "EVENTCOUNTER",
346                              any_counter,
347                              key_counter,
348                              card_counter,
349                              NULL);
350 }
351
352
353 /* This function should be called once for all key removals or
354    additions.  Thus function is assured not to do any context
355    switches. */
356 void
357 bump_key_eventcounter (void)
358 {
359   eventcounter.key++;
360   eventcounter.any++;
361 }
362
363 /* This function should be called for all card reader status
364    changes. Thus function is assured not to do any context
365    switches. */
366 void
367 bump_card_eventcounter (void)
368 {
369   eventcounter.card++;
370   eventcounter.any++;
371 }
372
373
374
375 \f
376 /* ISTRUSTED <hexstring_with_fingerprint>
377
378    Return OK when we have an entry with this fingerprint in our
379    trustlist */
380 static int
381 cmd_istrusted (assuan_context_t ctx, char *line)
382 {
383   ctrl_t ctrl = assuan_get_pointer (ctx);
384   int rc, n, i;
385   char *p;
386   char fpr[41];
387
388   /* Parse the fingerprint value. */
389   for (p=line,n=0; hexdigitp (p); p++, n++)
390     ;
391   if (*p || !(n == 40 || n == 32))
392     return set_error (GPG_ERR_ASS_PARAMETER, "invalid fingerprint");
393   i = 0;
394   if (n==32)
395     {
396       strcpy (fpr, "00000000");
397       i += 8;
398     }
399   for (p=line; i < 40; p++, i++)
400     fpr[i] = *p >= 'a'? (*p & 0xdf): *p;
401   fpr[i] = 0;
402   rc = agent_istrusted (ctrl, fpr);
403   if (!rc || gpg_err_code (rc) == GPG_ERR_NOT_TRUSTED)
404     return rc;
405   else if (rc == -1 || gpg_err_code (rc) == GPG_ERR_EOF )
406     return gpg_error (GPG_ERR_NOT_TRUSTED);
407   else
408     {
409       log_error ("command is_trusted failed: %s\n", gpg_strerror (rc));
410       return rc;
411     }
412 }
413
414 /* LISTTRUSTED 
415
416    List all entries from the trustlist */
417 static int
418 cmd_listtrusted (assuan_context_t ctx, char *line)
419 {
420   int rc = agent_listtrusted (ctx);
421   if (rc)
422     log_error ("command listtrusted failed: %s\n", gpg_strerror (rc));
423   return rc;
424 }
425
426
427 /* MARKTRUSTED <hexstring_with_fingerprint> <flag> <display_name>
428
429    Store a new key in into the trustlist*/
430 static int
431 cmd_marktrusted (assuan_context_t ctx, char *line)
432 {
433   ctrl_t ctrl = assuan_get_pointer (ctx);
434   int rc, n, i;
435   char *p;
436   char fpr[41];
437   int flag;
438
439   /* parse the fingerprint value */
440   for (p=line,n=0; hexdigitp (p); p++, n++)
441     ;
442   if (!spacep (p) || !(n == 40 || n == 32))
443     return set_error (GPG_ERR_ASS_PARAMETER, "invalid fingerprint");
444   i = 0;
445   if (n==32)
446     {
447       strcpy (fpr, "00000000");
448       i += 8;
449     }
450   for (p=line; i < 40; p++, i++)
451     fpr[i] = *p >= 'a'? (*p & 0xdf): *p;
452   fpr[i] = 0;
453   
454   while (spacep (p))
455     p++;
456   flag = *p++;
457   if ( (flag != 'S' && flag != 'P') || !spacep (p) )
458     return set_error (GPG_ERR_ASS_PARAMETER, "invalid flag - must be P or S");
459   while (spacep (p))
460     p++;
461
462   rc = agent_marktrusted (ctrl, p, fpr, flag);
463   if (rc)
464     log_error ("command marktrusted failed: %s\n", gpg_strerror (rc));
465   return rc;
466 }
467
468
469
470 \f
471 /* HAVEKEY <hexstring_with_keygrip>
472   
473    Return success when the secret key is available */
474 static int
475 cmd_havekey (assuan_context_t ctx, char *line)
476 {
477   int rc;
478   unsigned char buf[20];
479
480   rc = parse_keygrip (ctx, line, buf);
481   if (rc)
482     return rc;
483
484   if (agent_key_available (buf))
485     return gpg_error (GPG_ERR_NO_SECKEY);
486
487   return 0;
488 }
489
490
491 /* SIGKEY <hexstring_with_keygrip>
492    SETKEY <hexstring_with_keygrip>
493   
494    Set the  key used for a sign or decrypt operation */
495 static int
496 cmd_sigkey (assuan_context_t ctx, char *line)
497 {
498   int rc;
499   ctrl_t ctrl = assuan_get_pointer (ctx);
500
501   rc = parse_keygrip (ctx, line, ctrl->keygrip);
502   if (rc)
503     return rc;
504   ctrl->have_keygrip = 1;
505   return 0;
506 }
507
508
509 /* SETKEYDESC plus_percent_escaped_string
510
511    Set a description to be used for the next PKSIGN or PKDECRYPT
512    operation if this operation requires the entry of a passphrase.  If
513    this command is not used a default text will be used.  Note, that
514    this description implictly selects the label used for the entry
515    box; if the string contains the string PIN (which in general will
516    not be translated), "PIN" is used, otherwise the translation of
517    "passphrase" is used.  The description string should not contain
518    blanks unless they are percent or '+' escaped.
519
520    The description is only valid for the next PKSIGN or PKDECRYPT
521    operation.
522 */
523 static int
524 cmd_setkeydesc (assuan_context_t ctx, char *line)
525 {
526   ctrl_t ctrl = assuan_get_pointer (ctx);
527   char *desc, *p;
528
529   for (p=line; *p == ' '; p++)
530     ;
531   desc = p;
532   p = strchr (desc, ' ');
533   if (p)
534     *p = 0; /* We ignore any garbage; we might late use it for other args. */
535
536   if (!desc || !*desc)
537     return set_error (GPG_ERR_ASS_PARAMETER, "no description given");
538
539   /* Note, that we only need to replace the + characters and should
540      leave the other escaping in place because the escaped string is
541      send verbatim to the pinentry which does the unescaping (but not
542      the + replacing) */
543   plus_to_blank (desc);
544
545   xfree (ctrl->server_local->keydesc);
546   ctrl->server_local->keydesc = xtrystrdup (desc);
547   if (!ctrl->server_local->keydesc)
548     return out_of_core ();
549   return 0;
550 }
551
552
553 /* SETHASH --hash=<name>|<algonumber> <hexstring> 
554
555   The client can use this command to tell the server about the data
556   (which usually is a hash) to be signed. */
557 static int
558 cmd_sethash (assuan_context_t ctx, char *line)
559 {
560   int rc;
561   size_t n;
562   char *p;
563   ctrl_t ctrl = assuan_get_pointer (ctx);
564   unsigned char *buf;
565   char *endp;
566   int algo;
567
568   /* Parse the alternative hash options which may be used instead of
569      the algo number.  */
570   if (has_option_name (line, "--hash"))
571     {
572       if (has_option (line, "--hash=sha1"))
573         algo = GCRY_MD_SHA1;
574       else if (has_option (line, "--hash=sha256"))
575         algo = GCRY_MD_SHA256;
576       else if (has_option (line, "--hash=rmd160"))
577         algo = GCRY_MD_RMD160;
578       else if (has_option (line, "--hash=md5"))
579         algo = GCRY_MD_MD5;
580       else if (has_option (line, "--hash=tls-md5sha1"))
581         algo = GCRY_MD_USER_TLS_MD5SHA1;
582       else
583         return set_error (GPG_ERR_ASS_PARAMETER, "invalid hash algorithm");
584     }
585   else
586     algo = 0;
587
588   line = skip_options (line);
589   
590   if (!algo)
591     {
592       /* No hash option has been given: require an algo number instead  */
593       algo = (int)strtoul (line, &endp, 10);
594       for (line = endp; *line == ' ' || *line == '\t'; line++)
595         ;
596       if (!algo || gcry_md_test_algo (algo))
597         return set_error (GPG_ERR_UNSUPPORTED_ALGORITHM, NULL);
598     }
599   ctrl->digest.algo = algo;
600
601   /* Parse the hash value. */
602   rc = parse_hexstring (ctx, line, &n);
603   if (rc)
604     return rc;
605   n /= 2;
606   if (algo == GCRY_MD_USER_TLS_MD5SHA1 && n == 36)
607     ;
608   else if (n != 16 && n != 20 && n != 24 && n != 32)
609     return set_error (GPG_ERR_ASS_PARAMETER, "unsupported length of hash");
610
611   if (n > MAX_DIGEST_LEN)
612     return set_error (GPG_ERR_ASS_PARAMETER, "hash value to long");
613
614   buf = ctrl->digest.value;
615   ctrl->digest.valuelen = n;
616   for (p=line, n=0; n < ctrl->digest.valuelen; p += 2, n++)
617     buf[n] = xtoi_2 (p);
618   for (; n < ctrl->digest.valuelen; n++)
619     buf[n] = 0;
620   return 0;
621 }
622
623
624 /* PKSIGN <options>
625
626    Perform the actual sign operation. Neither input nor output are
627    sensitive to eavesdropping. */
628 static int
629 cmd_pksign (assuan_context_t ctx, char *line)
630 {
631   int rc;
632   cache_mode_t cache_mode = CACHE_MODE_NORMAL;
633   ctrl_t ctrl = assuan_get_pointer (ctx);
634   membuf_t outbuf;
635   
636   if (opt.ignore_cache_for_signing)
637     cache_mode = CACHE_MODE_IGNORE;
638   else if (!ctrl->server_local->use_cache_for_signing)
639     cache_mode = CACHE_MODE_IGNORE;
640
641   init_membuf (&outbuf, 512);
642
643   rc = agent_pksign (ctrl, ctrl->server_local->keydesc,
644                      &outbuf, cache_mode);
645   if (rc)
646     clear_outbuf (&outbuf);
647   else
648     rc = write_and_clear_outbuf (ctx, &outbuf);
649   if (rc)
650     log_error ("command pksign failed: %s\n", gpg_strerror (rc));
651   xfree (ctrl->server_local->keydesc);
652   ctrl->server_local->keydesc = NULL;
653   return rc;
654 }
655
656 /* PKDECRYPT <options>
657
658    Perform the actual decrypt operation.  Input is not 
659    sensitive to eavesdropping */
660 static int
661 cmd_pkdecrypt (assuan_context_t ctx, char *line)
662 {
663   int rc;
664   ctrl_t ctrl = assuan_get_pointer (ctx);
665   unsigned char *value;
666   size_t valuelen;
667   membuf_t outbuf;
668
669   /* First inquire the data to decrypt */
670   rc = assuan_inquire (ctx, "CIPHERTEXT",
671                        &value, &valuelen, MAXLEN_CIPHERTEXT);
672   if (rc)
673     return rc;
674
675   init_membuf (&outbuf, 512);
676
677   rc = agent_pkdecrypt (ctrl, ctrl->server_local->keydesc,
678                         value, valuelen, &outbuf);
679   xfree (value);
680   if (rc)
681     clear_outbuf (&outbuf);
682   else
683     rc = write_and_clear_outbuf (ctx, &outbuf);
684   if (rc)
685     log_error ("command pkdecrypt failed: %s\n", gpg_strerror (rc));
686   xfree (ctrl->server_local->keydesc);
687   ctrl->server_local->keydesc = NULL;
688   return rc;
689 }
690
691
692 /* GENKEY
693
694    Generate a new key, store the secret part and return the public
695    part.  Here is an example transaction:
696
697    C: GENKEY
698    S: INQUIRE KEYPARM
699    C: D (genkey (rsa (nbits  1024)))
700    C: END
701    S: D (public-key
702    S: D   (rsa (n 326487324683264) (e 10001)))
703    S  OK key created
704 */
705
706 static int
707 cmd_genkey (assuan_context_t ctx, char *line)
708 {
709   ctrl_t ctrl = assuan_get_pointer (ctx);
710   int rc;
711   unsigned char *value;
712   size_t valuelen;
713   membuf_t outbuf;
714
715   /* First inquire the parameters */
716   rc = assuan_inquire (ctx, "KEYPARAM", &value, &valuelen, MAXLEN_KEYPARAM);
717   if (rc)
718     return rc;
719
720   init_membuf (&outbuf, 512);
721
722   rc = agent_genkey (ctrl, (char*)value, valuelen, &outbuf);
723   xfree (value);
724   if (rc)
725     clear_outbuf (&outbuf);
726   else
727     rc = write_and_clear_outbuf (ctx, &outbuf);
728   if (rc)
729     log_error ("command genkey failed: %s\n", gpg_strerror (rc));
730   return rc;
731 }
732
733
734
735 \f
736 /* READKEY <hexstring_with_keygrip>
737   
738    Return the public key for the given keygrip.  */
739 static int
740 cmd_readkey (assuan_context_t ctx, char *line)
741 {
742   ctrl_t ctrl = assuan_get_pointer (ctx);
743   int rc;
744   unsigned char grip[20];
745   gcry_sexp_t s_pkey = NULL;
746
747   rc = parse_keygrip (ctx, line, grip);
748   if (rc)
749     return rc; /* Return immediately as this is already an Assuan error code.*/
750
751   rc = agent_public_key_from_file (ctrl, grip, &s_pkey);
752   if (!rc)
753     {
754       size_t len;
755       unsigned char *buf;
756
757       len = gcry_sexp_sprint (s_pkey, GCRYSEXP_FMT_CANON, NULL, 0);
758       assert (len);
759       buf = xtrymalloc (len);
760       if (!buf)
761         rc = gpg_error_from_syserror ();
762       else
763         {
764           len = gcry_sexp_sprint (s_pkey, GCRYSEXP_FMT_CANON, buf, len);
765           assert (len);
766           rc = assuan_send_data (ctx, buf, len);
767           xfree (buf);
768         }
769       gcry_sexp_release (s_pkey);
770     }
771
772   if (rc)
773     log_error ("command readkey failed: %s\n", gpg_strerror (rc));
774   return rc;
775 }
776
777
778
779
780
781 \f
782 static int
783 send_back_passphrase (assuan_context_t ctx, int via_data, const char *pw)
784 {
785   size_t n;
786   int rc;
787
788   assuan_begin_confidential (ctx);
789   n = strlen (pw);
790   if (via_data)
791     rc = assuan_send_data (ctx, pw, n);
792   else
793     {
794       char *p = xtrymalloc_secure (n*2+1);
795       if (!p)
796         rc = gpg_error_from_syserror ();
797       else
798         {
799           bin2hex (pw, n, p);
800           rc = assuan_set_okay_line (ctx, p);
801           xfree (p);
802         }
803     }
804   return rc;
805 }
806
807
808 /* GET_PASSPHRASE [--data] [--check] <cache_id>
809                   [<error_message> <prompt> <description>]
810
811    This function is usually used to ask for a passphrase to be used
812    for conventional encryption, but may also be used by programs which
813    need specal handling of passphrases.  This command uses a syntax
814    which helps clients to use the agent with minimum effort.  The
815    agent either returns with an error or with a OK followed by the hex
816    encoded passphrase.  Note that the length of the strings is
817    implicitly limited by the maximum length of a command.
818
819    If the option "--data" is used the passphrase is returned by usual
820    data lines and not on the okay line.
821
822    If the option "--check" is used the passphrase constraints checks as
823    implemented by gpg-agent are applied.  A check is not done if the
824    passphrase has been found in the cache.
825 */
826
827 static int
828 cmd_get_passphrase (assuan_context_t ctx, char *line)
829 {
830   ctrl_t ctrl = assuan_get_pointer (ctx);
831   int rc;
832   const char *pw;
833   char *response;
834   char *cacheid = NULL, *desc = NULL, *prompt = NULL, *errtext = NULL;
835   char *p;
836   void *cache_marker;
837   int opt_data, opt_check;
838
839   opt_data = has_option (line, "--data");
840   opt_check = has_option (line, "--check");
841   line = skip_options (line);
842
843   cacheid = line;
844   p = strchr (cacheid, ' ');
845   if (p)
846     {
847       *p++ = 0;
848       while (*p == ' ')
849         p++;
850       errtext = p;
851       p = strchr (errtext, ' ');
852       if (p)
853         {
854           *p++ = 0;
855           while (*p == ' ')
856             p++;
857           prompt = p;
858           p = strchr (prompt, ' ');
859           if (p)
860             {
861               *p++ = 0;
862               while (*p == ' ')
863                 p++;
864               desc = p;
865               p = strchr (desc, ' ');
866               if (p)
867                 *p = 0; /* Ignore trailing garbage. */
868             }
869         }
870     }
871   if (!cacheid || !*cacheid || strlen (cacheid) > 50)
872     return set_error (GPG_ERR_ASS_PARAMETER, "invalid length of cacheID");
873   if (!desc)
874     return set_error (GPG_ERR_ASS_PARAMETER, "no description given");
875
876   if (!strcmp (cacheid, "X"))
877     cacheid = NULL;
878   if (!strcmp (errtext, "X"))
879     errtext = NULL;
880   if (!strcmp (prompt, "X"))
881     prompt = NULL;
882   if (!strcmp (desc, "X"))
883     desc = NULL;
884
885   pw = cacheid ? agent_get_cache (cacheid, CACHE_MODE_NORMAL, &cache_marker)
886                : NULL;
887   if (pw)
888     {
889       rc = send_back_passphrase (ctx, opt_data, pw);
890       agent_unlock_cache_entry (&cache_marker);
891     }
892   else
893     {
894       /* Note, that we only need to replace the + characters and
895          should leave the other escaping in place because the escaped
896          string is send verbatim to the pinentry which does the
897          unescaping (but not the + replacing) */
898       if (errtext)
899         plus_to_blank (errtext);
900       if (prompt)
901         plus_to_blank (prompt);
902       if (desc)
903         plus_to_blank (desc);
904
905       response = NULL;
906       do
907         {
908           xfree (response);
909           rc = agent_get_passphrase (ctrl, &response, desc, prompt, errtext);
910         }
911       while (!rc
912              && opt_check
913              && check_passphrase_constraints (ctrl, response));
914
915       if (!rc)
916         {
917           if (cacheid)
918             agent_put_cache (cacheid, CACHE_MODE_USER, response, 0);
919           rc = send_back_passphrase (ctx, opt_data, response);
920           xfree (response);
921         }
922     }
923
924   if (rc)
925     log_error ("command get_passphrase failed: %s\n", gpg_strerror (rc));
926   return rc;
927 }
928
929
930 /* CLEAR_PASSPHRASE <cache_id>
931
932    may be used to invalidate the cache entry for a passphrase.  The
933    function returns with OK even when there is no cached passphrase.
934 */
935
936 static int
937 cmd_clear_passphrase (assuan_context_t ctx, char *line)
938 {
939   char *cacheid = NULL;
940   char *p;
941
942   /* parse the stuff */
943   for (p=line; *p == ' '; p++)
944     ;
945   cacheid = p;
946   p = strchr (cacheid, ' ');
947   if (p)
948     *p = 0; /* ignore garbage */
949   if (!cacheid || !*cacheid || strlen (cacheid) > 50)
950     return set_error (GPG_ERR_ASS_PARAMETER, "invalid length of cacheID");
951
952   agent_put_cache (cacheid, CACHE_MODE_USER, NULL, 0);
953   return 0;
954 }
955
956
957 /* GET_CONFIRMATION <description>
958
959    This command may be used to ask for a simple confirmation.
960    DESCRIPTION is displayed along with a Okay and Cancel button.  This
961    command uses a syntax which helps clients to use the agent with
962    minimum effort.  The agent either returns with an error or with a
963    OK.  Note, that the length of DESCRIPTION is implicitly limited by
964    the maximum length of a command. DESCRIPTION should not contain
965    any spaces, those must be encoded either percent escaped or simply
966    as '+'.
967 */
968
969 static int
970 cmd_get_confirmation (assuan_context_t ctx, char *line)
971 {
972   ctrl_t ctrl = assuan_get_pointer (ctx);
973   int rc;
974   char *desc = NULL;
975   char *p;
976
977   /* parse the stuff */
978   for (p=line; *p == ' '; p++)
979     ;
980   desc = p;
981   p = strchr (desc, ' ');
982   if (p)
983     *p = 0; /* We ignore any garbage -may be later used for other args. */
984
985   if (!desc || !*desc)
986     return set_error (GPG_ERR_ASS_PARAMETER, "no description given");
987
988   if (!strcmp (desc, "X"))
989     desc = NULL;
990
991   /* Note, that we only need to replace the + characters and should
992      leave the other escaping in place because the escaped string is
993      send verbatim to the pinentry which does the unescaping (but not
994      the + replacing) */
995   if (desc)
996     plus_to_blank (desc);
997
998   rc = agent_get_confirmation (ctrl, desc, NULL, NULL);
999   if (rc)
1000     log_error ("command get_confirmation failed: %s\n", gpg_strerror (rc));
1001   return rc;
1002 }
1003
1004
1005 \f
1006 /* LEARN [--send]
1007
1008    Learn something about the currently inserted smartcard.  With
1009    --send the new certificates are send back.  */
1010 static int
1011 cmd_learn (assuan_context_t ctx, char *line)
1012 {
1013   ctrl_t ctrl = assuan_get_pointer (ctx);
1014   int rc;
1015
1016   rc = agent_handle_learn (ctrl, has_option (line, "--send")? ctx : NULL);
1017   if (rc)
1018     log_error ("command learn failed: %s\n", gpg_strerror (rc));
1019   return rc;
1020 }
1021
1022
1023 \f
1024 /* PASSWD <hexstring_with_keygrip>
1025   
1026    Change the passphrase/PID for the key identified by keygrip in LINE. */
1027 static int
1028 cmd_passwd (assuan_context_t ctx, char *line)
1029 {
1030   ctrl_t ctrl = assuan_get_pointer (ctx);
1031   int rc;
1032   unsigned char grip[20];
1033   gcry_sexp_t s_skey = NULL;
1034   unsigned char *shadow_info = NULL;
1035
1036   rc = parse_keygrip (ctx, line, grip);
1037   if (rc)
1038     goto leave;
1039
1040   rc = agent_key_from_file (ctrl, ctrl->server_local->keydesc,
1041                             grip, &shadow_info, CACHE_MODE_IGNORE, &s_skey);
1042   if (rc)
1043     ;
1044   else if (!s_skey)
1045     {
1046       log_error ("changing a smartcard PIN is not yet supported\n");
1047       rc = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1048     }
1049   else
1050     rc = agent_protect_and_store (ctrl, s_skey);
1051
1052   xfree (ctrl->server_local->keydesc);
1053   ctrl->server_local->keydesc = NULL;
1054
1055  leave:
1056   gcry_sexp_release (s_skey);
1057   xfree (shadow_info);
1058   if (rc)
1059     log_error ("command passwd failed: %s\n", gpg_strerror (rc));
1060   return rc;
1061 }
1062
1063 /* PRESET_PASSPHRASE <hexstring_with_keygrip> <timeout> <hexstring>
1064   
1065    Set the cached passphrase/PIN for the key identified by the keygrip
1066    to passwd for the given time, where -1 means infinite and 0 means
1067    the default (currently only a timeout of -1 is allowed, which means
1068    to never expire it).  If passwd is not provided, ask for it via the
1069    pinentry module.  */
1070 static int
1071 cmd_preset_passphrase (assuan_context_t ctx, char *line)
1072 {
1073   int rc;
1074   unsigned char grip[20];
1075   char *grip_clear = NULL;
1076   char *passphrase = NULL;
1077   int ttl;
1078   size_t len;
1079
1080   if (!opt.allow_preset_passphrase)
1081     return gpg_error (GPG_ERR_NOT_SUPPORTED);
1082
1083   rc = parse_keygrip (ctx, line, grip);
1084   if (rc)
1085     return rc;
1086
1087   /* FIXME: parse_keygrip should return a tail pointer.  */
1088   grip_clear = line;
1089   while (*line && (*line != ' ' && *line != '\t'))
1090     line++;
1091   if (!*line)
1092     return gpg_error (GPG_ERR_MISSING_VALUE);
1093   *line = '\0';
1094   line++;
1095   while (*line && (*line == ' ' || *line == '\t'))
1096     line++;
1097   
1098   /* Currently, only infinite timeouts are allowed.  */
1099   ttl = -1;
1100   if (line[0] != '-' || line[1] != '1')
1101     return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1102   line++;
1103   line++;
1104   while (!(*line != ' ' && *line != '\t'))
1105     line++;
1106
1107   /* Syntax check the hexstring.  */
1108   rc = parse_hexstring (ctx, line, &len);
1109   if (rc)
1110     return rc;
1111   line[len] = '\0';
1112
1113   /* If there is a passphrase, use it.  Currently, a passphrase is
1114      required.  */
1115   if (*line)
1116     passphrase = line;
1117   else
1118     return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1119
1120   rc = agent_put_cache (grip_clear, CACHE_MODE_ANY, passphrase, ttl);
1121
1122   if (rc)
1123     log_error ("command preset_passwd failed: %s\n", gpg_strerror (rc));
1124
1125   return rc;
1126 }
1127
1128 \f
1129 /* SCD <commands to pass to the scdaemon>
1130   
1131    This is a general quote command to redirect everything to the
1132    SCDAEMON. */
1133 static int
1134 cmd_scd (assuan_context_t ctx, char *line)
1135 {
1136   ctrl_t ctrl = assuan_get_pointer (ctx);
1137   int rc;
1138
1139   rc = divert_generic_cmd (ctrl, line, ctx);
1140
1141   return rc;
1142 }
1143
1144
1145 \f
1146 /* GETVAL <key>
1147
1148    Return the value for KEY from the special environment as created by
1149    PUTVAL.
1150  */
1151 static int
1152 cmd_getval (assuan_context_t ctx, char *line)
1153 {
1154   int rc = 0;
1155   char *key = NULL;
1156   char *p;
1157   struct putval_item_s *vl;
1158
1159   for (p=line; *p == ' '; p++)
1160     ;
1161   key = p;
1162   p = strchr (key, ' ');
1163   if (p)
1164     {
1165       *p++ = 0; 
1166       for (; *p == ' '; p++)
1167         ;
1168       if (*p)
1169         return set_error (GPG_ERR_ASS_PARAMETER, "too many arguments");
1170     }
1171   if (!key || !*key)
1172     return set_error (GPG_ERR_ASS_PARAMETER, "no key given");
1173
1174
1175   for (vl=putval_list; vl; vl = vl->next)
1176     if ( !strcmp (vl->d, key) )
1177       break;
1178
1179   if (vl) /* Got an entry. */
1180     rc = assuan_send_data (ctx, vl->d+vl->off, vl->len);
1181   else
1182     return gpg_error (GPG_ERR_NO_DATA);
1183
1184   if (rc)
1185     log_error ("command getval failed: %s\n", gpg_strerror (rc));
1186   return rc;
1187 }
1188
1189
1190 /* PUTVAL <key> [<percent_escaped_value>]
1191
1192    The gpg-agent maintains a kind of environment which may be used to
1193    store key/value pairs in it, so that they can be retrieved later.
1194    This may be used by helper daemons to daemonize themself on
1195    invocation and register them with gpg-agent.  Callers of the
1196    daemon's service may now first try connect to get the information
1197    for that service from gpg-agent through the GETVAL command and then
1198    try to connect to that daemon.  Only if that fails they may start
1199    an own instance of the service daemon. 
1200
1201    KEY is an an arbitrary symbol with the same syntax rules as keys
1202    for shell environment variables.  PERCENT_ESCAPED_VALUE is the
1203    corresponsing value; they should be similar to the values of
1204    envronment variables but gpg-agent does not enforce any
1205    restrictions.  If that value is not given any value under that KEY
1206    is removed from this special environment.
1207 */
1208 static int
1209 cmd_putval (assuan_context_t ctx, char *line)
1210 {
1211   int rc = 0;
1212   char *key = NULL;
1213   char *value = NULL;
1214   size_t valuelen = 0;
1215   char *p;
1216   struct putval_item_s *vl, *vlprev;
1217
1218   for (p=line; *p == ' '; p++)
1219     ;
1220   key = p;
1221   p = strchr (key, ' ');
1222   if (p)
1223     {
1224       *p++ = 0; 
1225       for (; *p == ' '; p++)
1226         ;
1227       if (*p)
1228         {
1229           value = p;
1230           p = strchr (value, ' ');
1231           if (p)
1232             *p = 0;
1233           valuelen = percent_plus_unescape (value);
1234         }
1235     }
1236   if (!key || !*key)
1237     return set_error (GPG_ERR_ASS_PARAMETER, "no key given");
1238
1239
1240   for (vl=putval_list,vlprev=NULL; vl; vlprev=vl, vl = vl->next)
1241     if ( !strcmp (vl->d, key) )
1242       break;
1243
1244   if (vl) /* Delete old entry. */
1245     {
1246       if (vlprev)
1247         vlprev->next = vl->next;
1248       else
1249         putval_list = vl->next;
1250       xfree (vl);
1251     }
1252
1253   if (valuelen) /* Add entry. */  
1254     {
1255       vl = xtrymalloc (sizeof *vl + strlen (key) + valuelen);
1256       if (!vl)
1257         rc = gpg_error_from_syserror ();
1258       else
1259         {
1260           vl->len = valuelen;
1261           vl->off = strlen (key) + 1;
1262           strcpy (vl->d, key);
1263           memcpy (vl->d + vl->off, value, valuelen);
1264           vl->next = putval_list;
1265           putval_list = vl;
1266         }
1267     }
1268
1269   if (rc)
1270     log_error ("command putval failed: %s\n", gpg_strerror (rc));
1271   return rc;
1272 }
1273
1274
1275
1276 \f
1277 /* UPDATESTARTUPTTY 
1278   
1279   Set startup TTY and X DISPLAY variables to the values of this
1280   session.  This command is useful to pull future pinentries to
1281   another screen.  It is only required because there is no way in the
1282   ssh-agent protocol to convey this information.  */
1283 static int
1284 cmd_updatestartuptty (assuan_context_t ctx, char *line)
1285 {
1286   ctrl_t ctrl = assuan_get_pointer (ctx);
1287
1288   xfree (opt.startup_display); opt.startup_display = NULL;
1289   xfree (opt.startup_ttyname); opt.startup_ttyname = NULL;
1290   xfree (opt.startup_ttytype); opt.startup_ttytype = NULL;
1291   xfree (opt.startup_lc_ctype); opt.startup_lc_ctype = NULL;
1292   xfree (opt.startup_lc_messages); opt.startup_lc_messages = NULL;
1293
1294   if (ctrl->display)
1295     opt.startup_display = xtrystrdup (ctrl->display);
1296   if (ctrl->ttyname)
1297     opt.startup_ttyname = xtrystrdup (ctrl->ttyname);
1298   if (ctrl->ttytype)
1299     opt.startup_ttytype = xtrystrdup (ctrl->ttytype);
1300   if (ctrl->lc_ctype) 
1301     opt.startup_lc_ctype = xtrystrdup (ctrl->lc_ctype);
1302   if (ctrl->lc_messages)
1303     opt.startup_lc_messages = xtrystrdup (ctrl->lc_messages);
1304
1305   return 0;
1306 }
1307
1308
1309 \f
1310 static int
1311 option_handler (assuan_context_t ctx, const char *key, const char *value)
1312 {
1313   ctrl_t ctrl = assuan_get_pointer (ctx);
1314
1315   if (!strcmp (key, "display"))
1316     {
1317       if (ctrl->display)
1318         free (ctrl->display);
1319       ctrl->display = strdup (value);
1320       if (!ctrl->display)
1321         return out_of_core ();
1322     }
1323   else if (!strcmp (key, "ttyname"))
1324     {
1325       if (!opt.keep_tty)
1326         {
1327           if (ctrl->ttyname)
1328             free (ctrl->ttyname);
1329           ctrl->ttyname = strdup (value);
1330           if (!ctrl->ttyname)
1331             return out_of_core ();
1332         }
1333     }
1334   else if (!strcmp (key, "ttytype"))
1335     {
1336       if (!opt.keep_tty)
1337         {
1338           if (ctrl->ttytype)
1339             free (ctrl->ttytype);
1340           ctrl->ttytype = strdup (value);
1341           if (!ctrl->ttytype)
1342             return out_of_core ();
1343         }
1344     }
1345   else if (!strcmp (key, "lc-ctype"))
1346     {
1347       if (ctrl->lc_ctype)
1348         free (ctrl->lc_ctype);
1349       ctrl->lc_ctype = strdup (value);
1350       if (!ctrl->lc_ctype)
1351         return out_of_core ();
1352     }
1353   else if (!strcmp (key, "lc-messages"))
1354     {
1355       if (ctrl->lc_messages)
1356         free (ctrl->lc_messages);
1357       ctrl->lc_messages = strdup (value);
1358       if (!ctrl->lc_messages)
1359         return out_of_core ();
1360     }
1361   else if (!strcmp (key, "use-cache-for-signing"))
1362     ctrl->server_local->use_cache_for_signing = *value? atoi (value) : 0;
1363   else
1364     return gpg_error (GPG_ERR_UNKNOWN_OPTION);
1365
1366   return 0;
1367 }
1368
1369
1370
1371 \f
1372 /* Called by libassuan after all commands. ERR is the error from the
1373    last assuan operation and not the one returned from the command. */
1374 static void
1375 post_cmd_notify (assuan_context_t ctx, int err)
1376 {
1377   ctrl_t ctrl = assuan_get_pointer (ctx);
1378
1379   /* Switch off any I/O monitor controlled logging pausing. */
1380   ctrl->server_local->pause_io_logging = 0;
1381 }
1382
1383
1384 /* This function is called by libassuan for all I/O.  We use it here
1385    to disable logging for the GETEVENTCOUNTER commands.  This is so
1386    that the debug output won't get cluttered by this primitive
1387    command.  */
1388 static unsigned int
1389 io_monitor (assuan_context_t ctx, int direction,
1390             const char *line, size_t linelen)
1391 {
1392   ctrl_t ctrl = assuan_get_pointer (ctx);
1393
1394   /* Note that we only check for the uppercase name.  This allows to
1395      see the logging for debugging if using a non-upercase command
1396      name. */
1397   if (ctx && !direction 
1398       && linelen >= 15
1399       && !strncmp (line, "GETEVENTCOUNTER", 15)
1400       && (linelen == 15 || spacep (line+15)))
1401     {
1402       ctrl->server_local->pause_io_logging = 1;
1403     }
1404
1405   return ctrl->server_local->pause_io_logging? 1:0;
1406 }
1407
1408
1409 /* Tell the assuan library about our commands */
1410 static int
1411 register_commands (assuan_context_t ctx)
1412 {
1413   static struct {
1414     const char *name;
1415     int (*handler)(assuan_context_t, char *line);
1416   } table[] = {
1417     { "GETEVENTCOUNTER",cmd_geteventcounter },
1418     { "ISTRUSTED",      cmd_istrusted },
1419     { "HAVEKEY",        cmd_havekey },
1420     { "SIGKEY",         cmd_sigkey },
1421     { "SETKEY",         cmd_sigkey },
1422     { "SETKEYDESC",     cmd_setkeydesc },
1423     { "SETHASH",        cmd_sethash },
1424     { "PKSIGN",         cmd_pksign },
1425     { "PKDECRYPT",      cmd_pkdecrypt },
1426     { "GENKEY",         cmd_genkey },
1427     { "READKEY",        cmd_readkey },
1428     { "GET_PASSPHRASE", cmd_get_passphrase },
1429     { "PRESET_PASSPHRASE", cmd_preset_passphrase },
1430     { "CLEAR_PASSPHRASE", cmd_clear_passphrase },
1431     { "GET_CONFIRMATION", cmd_get_confirmation },
1432     { "LISTTRUSTED",    cmd_listtrusted },
1433     { "MARKTRUSTED",    cmd_marktrusted },
1434     { "LEARN",          cmd_learn },
1435     { "PASSWD",         cmd_passwd },
1436     { "INPUT",          NULL }, 
1437     { "OUTPUT",         NULL }, 
1438     { "SCD",            cmd_scd },
1439     { "GETVAL",         cmd_getval },
1440     { "PUTVAL",         cmd_putval },
1441     { "UPDATESTARTUPTTY",  cmd_updatestartuptty },
1442     { NULL }
1443   };
1444   int i, rc;
1445
1446   for (i=0; table[i].name; i++)
1447     {
1448       rc = assuan_register_command (ctx, table[i].name, table[i].handler);
1449       if (rc)
1450         return rc;
1451     } 
1452 #ifdef HAVE_ASSUAN_SET_IO_MONITOR
1453   assuan_register_post_cmd_notify (ctx, post_cmd_notify);
1454 #endif
1455   assuan_register_reset_notify (ctx, reset_notify);
1456   assuan_register_option_handler (ctx, option_handler);
1457   return 0;
1458 }
1459
1460
1461 /* Startup the server.  If LISTEN_FD and FD is given as -1, this is a
1462    simple piper server, otherwise it is a regular server.  CTRL is the
1463    control structure for this connection; it has only the basic
1464    intialization. */
1465 void
1466 start_command_handler (ctrl_t ctrl, int listen_fd, int fd)
1467 {
1468   int rc;
1469   assuan_context_t ctx;
1470
1471   if (listen_fd == -1 && fd == -1)
1472     {
1473       int filedes[2];
1474
1475       filedes[0] = 0;
1476       filedes[1] = 1;
1477       rc = assuan_init_pipe_server (&ctx, filedes);
1478     }
1479   else if (listen_fd != -1)
1480     {
1481       rc = assuan_init_socket_server_ext (&ctx, listen_fd, 0);
1482     }
1483   else 
1484     {
1485       rc = assuan_init_socket_server_ext (&ctx, fd, 2);
1486       ctrl->connection_fd = fd;
1487     }
1488   if (rc)
1489     {
1490       log_error ("failed to initialize the server: %s\n",
1491                  gpg_strerror(rc));
1492       agent_exit (2);
1493     }
1494   rc = register_commands (ctx);
1495   if (rc)
1496     {
1497       log_error ("failed to register commands with Assuan: %s\n",
1498                  gpg_strerror(rc));
1499       agent_exit (2);
1500     }
1501
1502   assuan_set_pointer (ctx, ctrl);
1503   ctrl->server_local = xcalloc (1, sizeof *ctrl->server_local);
1504   ctrl->server_local->assuan_ctx = ctx;
1505   ctrl->server_local->message_fd = -1;
1506   ctrl->server_local->use_cache_for_signing = 1;
1507   ctrl->digest.raw_value = 0;
1508
1509   if (DBG_ASSUAN)
1510     assuan_set_log_stream (ctx, log_get_stream ());
1511
1512 #ifdef HAVE_ASSUAN_SET_IO_MONITOR
1513   assuan_set_io_monitor (ctx, io_monitor);
1514 #endif
1515
1516   for (;;)
1517     {
1518       rc = assuan_accept (ctx);
1519       if (rc == -1)
1520         {
1521           break;
1522         }
1523       else if (rc)
1524         {
1525           log_info ("Assuan accept problem: %s\n", gpg_strerror (rc));
1526           break;
1527         }
1528       
1529       rc = assuan_process (ctx);
1530       if (rc)
1531         {
1532           log_info ("Assuan processing failed: %s\n", gpg_strerror (rc));
1533           continue;
1534         }
1535     }
1536
1537   /* Reset the SCD if needed. */
1538   agent_reset_scd (ctrl);
1539
1540   /* Reset the pinentry (in case of popup messages). */
1541   agent_reset_query (ctrl);
1542
1543   /* Cleanup.  */
1544   assuan_deinit_server (ctx);
1545   xfree (ctrl->server_local);
1546   ctrl->server_local = NULL;
1547 }
1548