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