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