Minor fixes.
[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 <string_or_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   char *grip_clear = NULL;
1108   char *passphrase = NULL;
1109   int ttl;
1110   size_t len;
1111
1112   if (!opt.allow_preset_passphrase)
1113     return set_error (GPG_ERR_NOT_SUPPORTED, "no --allow-preset-passphrase");
1114
1115   grip_clear = line;
1116   while (*line && (*line != ' ' && *line != '\t'))
1117     line++;
1118   if (!*line)
1119     return gpg_error (GPG_ERR_MISSING_VALUE);
1120   *line = '\0';
1121   line++;
1122   while (*line && (*line == ' ' || *line == '\t'))
1123     line++;
1124   
1125   /* Currently, only infinite timeouts are allowed.  */
1126   ttl = -1;
1127   if (line[0] != '-' || line[1] != '1')
1128     return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1129   line++;
1130   line++;
1131   while (!(*line != ' ' && *line != '\t'))
1132     line++;
1133
1134   /* Syntax check the hexstring.  */
1135   rc = parse_hexstring (ctx, line, &len);
1136   if (rc)
1137     return rc;
1138   line[len] = '\0';
1139
1140   /* If there is a passphrase, use it.  Currently, a passphrase is
1141      required.  */
1142   if (*line)
1143     {
1144       /* Do in-place conversion.  */
1145       passphrase = line;
1146       if (!hex2str (passphrase, passphrase, strlen (passphrase)+1, NULL))
1147         rc = set_error (GPG_ERR_ASS_PARAMETER, "invalid hexstring");
1148     }
1149   else
1150     rc = set_error (GPG_ERR_NOT_IMPLEMENTED, "passphrase is required");
1151
1152   if (!rc)
1153     rc = agent_put_cache (grip_clear, CACHE_MODE_ANY, passphrase, ttl);
1154
1155   if (rc)
1156     log_error ("command preset_passwd failed: %s\n", gpg_strerror (rc));
1157
1158   return rc;
1159 }
1160
1161 \f
1162 /* SCD <commands to pass to the scdaemon>
1163   
1164    This is a general quote command to redirect everything to the
1165    SCDAEMON. */
1166 static int
1167 cmd_scd (assuan_context_t ctx, char *line)
1168 {
1169   ctrl_t ctrl = assuan_get_pointer (ctx);
1170   int rc;
1171
1172   rc = divert_generic_cmd (ctrl, line, ctx);
1173
1174   return rc;
1175 }
1176
1177
1178 \f
1179 /* GETVAL <key>
1180
1181    Return the value for KEY from the special environment as created by
1182    PUTVAL.
1183  */
1184 static int
1185 cmd_getval (assuan_context_t ctx, char *line)
1186 {
1187   int rc = 0;
1188   char *key = NULL;
1189   char *p;
1190   struct putval_item_s *vl;
1191
1192   for (p=line; *p == ' '; p++)
1193     ;
1194   key = p;
1195   p = strchr (key, ' ');
1196   if (p)
1197     {
1198       *p++ = 0; 
1199       for (; *p == ' '; p++)
1200         ;
1201       if (*p)
1202         return set_error (GPG_ERR_ASS_PARAMETER, "too many arguments");
1203     }
1204   if (!key || !*key)
1205     return set_error (GPG_ERR_ASS_PARAMETER, "no key given");
1206
1207
1208   for (vl=putval_list; vl; vl = vl->next)
1209     if ( !strcmp (vl->d, key) )
1210       break;
1211
1212   if (vl) /* Got an entry. */
1213     rc = assuan_send_data (ctx, vl->d+vl->off, vl->len);
1214   else
1215     return gpg_error (GPG_ERR_NO_DATA);
1216
1217   if (rc)
1218     log_error ("command getval failed: %s\n", gpg_strerror (rc));
1219   return rc;
1220 }
1221
1222
1223 /* PUTVAL <key> [<percent_escaped_value>]
1224
1225    The gpg-agent maintains a kind of environment which may be used to
1226    store key/value pairs in it, so that they can be retrieved later.
1227    This may be used by helper daemons to daemonize themself on
1228    invocation and register them with gpg-agent.  Callers of the
1229    daemon's service may now first try connect to get the information
1230    for that service from gpg-agent through the GETVAL command and then
1231    try to connect to that daemon.  Only if that fails they may start
1232    an own instance of the service daemon. 
1233
1234    KEY is an an arbitrary symbol with the same syntax rules as keys
1235    for shell environment variables.  PERCENT_ESCAPED_VALUE is the
1236    corresponsing value; they should be similar to the values of
1237    envronment variables but gpg-agent does not enforce any
1238    restrictions.  If that value is not given any value under that KEY
1239    is removed from this special environment.
1240 */
1241 static int
1242 cmd_putval (assuan_context_t ctx, char *line)
1243 {
1244   int rc = 0;
1245   char *key = NULL;
1246   char *value = NULL;
1247   size_t valuelen = 0;
1248   char *p;
1249   struct putval_item_s *vl, *vlprev;
1250
1251   for (p=line; *p == ' '; p++)
1252     ;
1253   key = p;
1254   p = strchr (key, ' ');
1255   if (p)
1256     {
1257       *p++ = 0; 
1258       for (; *p == ' '; p++)
1259         ;
1260       if (*p)
1261         {
1262           value = p;
1263           p = strchr (value, ' ');
1264           if (p)
1265             *p = 0;
1266           valuelen = percent_plus_unescape (value);
1267         }
1268     }
1269   if (!key || !*key)
1270     return set_error (GPG_ERR_ASS_PARAMETER, "no key given");
1271
1272
1273   for (vl=putval_list,vlprev=NULL; vl; vlprev=vl, vl = vl->next)
1274     if ( !strcmp (vl->d, key) )
1275       break;
1276
1277   if (vl) /* Delete old entry. */
1278     {
1279       if (vlprev)
1280         vlprev->next = vl->next;
1281       else
1282         putval_list = vl->next;
1283       xfree (vl);
1284     }
1285
1286   if (valuelen) /* Add entry. */  
1287     {
1288       vl = xtrymalloc (sizeof *vl + strlen (key) + valuelen);
1289       if (!vl)
1290         rc = gpg_error_from_syserror ();
1291       else
1292         {
1293           vl->len = valuelen;
1294           vl->off = strlen (key) + 1;
1295           strcpy (vl->d, key);
1296           memcpy (vl->d + vl->off, value, valuelen);
1297           vl->next = putval_list;
1298           putval_list = vl;
1299         }
1300     }
1301
1302   if (rc)
1303     log_error ("command putval failed: %s\n", gpg_strerror (rc));
1304   return rc;
1305 }
1306
1307
1308
1309 \f
1310 /* UPDATESTARTUPTTY 
1311   
1312   Set startup TTY and X DISPLAY variables to the values of this
1313   session.  This command is useful to pull future pinentries to
1314   another screen.  It is only required because there is no way in the
1315   ssh-agent protocol to convey this information.  */
1316 static int
1317 cmd_updatestartuptty (assuan_context_t ctx, char *line)
1318 {
1319   ctrl_t ctrl = assuan_get_pointer (ctx);
1320
1321   (void)line;
1322
1323   xfree (opt.startup_display); opt.startup_display = NULL;
1324   xfree (opt.startup_ttyname); opt.startup_ttyname = NULL;
1325   xfree (opt.startup_ttytype); opt.startup_ttytype = NULL;
1326   xfree (opt.startup_lc_ctype); opt.startup_lc_ctype = NULL;
1327   xfree (opt.startup_lc_messages); opt.startup_lc_messages = NULL;
1328   xfree (opt.startup_xauthority); opt.startup_xauthority = NULL;
1329
1330   if (ctrl->display)
1331     opt.startup_display = xtrystrdup (ctrl->display);
1332   if (ctrl->ttyname)
1333     opt.startup_ttyname = xtrystrdup (ctrl->ttyname);
1334   if (ctrl->ttytype)
1335     opt.startup_ttytype = xtrystrdup (ctrl->ttytype);
1336   if (ctrl->lc_ctype) 
1337     opt.startup_lc_ctype = xtrystrdup (ctrl->lc_ctype);
1338   if (ctrl->lc_messages)
1339     opt.startup_lc_messages = xtrystrdup (ctrl->lc_messages);
1340   if (ctrl->xauthority)
1341     opt.startup_xauthority = xtrystrdup (ctrl->xauthority);
1342   if (ctrl->pinentry_user_data)
1343     opt.startup_pinentry_user_data = xtrystrdup (ctrl->pinentry_user_data);
1344
1345   return 0;
1346 }
1347
1348
1349 \f
1350 #ifdef HAVE_W32_SYSTEM
1351 /* KILLAGENT
1352
1353    Under Windows we start the agent on the fly.  Thus it also make
1354    sense to allow a client to stop the agent. */
1355 static int
1356 cmd_killagent (assuan_context_t ctx, char *line)
1357 {
1358   ctrl_t ctrl = assuan_get_pointer (ctx);
1359
1360   (void)line;
1361
1362   ctrl->server_local->stopme = 1;
1363   return gpg_error (GPG_ERR_EOF);
1364 }
1365
1366 /* RELOADAGENT
1367
1368    As signals are inconvenient under Windows, we provide this command
1369    to allow reloading of the configuration.  */
1370 static int
1371 cmd_reloadagent (assuan_context_t ctx, char *line)
1372 {
1373   (void)ctx;
1374   (void)line;
1375
1376   agent_sighup_action ();
1377   return 0;
1378 }
1379 #endif /*HAVE_W32_SYSTEM*/
1380
1381
1382 \f
1383 /* GETINFO <what>
1384
1385    Multipurpose function to return a variety of information.
1386    Supported values for WHAT are:
1387
1388      version     - Return the version of the program.
1389      pid         - Return the process id of the server.
1390      socket_name - Return the name of the socket.
1391      ssh_socket_name - Return the name of the ssh socket.
1392
1393  */
1394 static int
1395 cmd_getinfo (assuan_context_t ctx, char *line)
1396 {
1397   int rc = 0;
1398
1399   if (!strcmp (line, "version"))
1400     {
1401       const char *s = VERSION;
1402       rc = assuan_send_data (ctx, s, strlen (s));
1403     }
1404   else if (!strcmp (line, "pid"))
1405     {
1406       char numbuf[50];
1407
1408       snprintf (numbuf, sizeof numbuf, "%lu", (unsigned long)getpid ());
1409       rc = assuan_send_data (ctx, numbuf, strlen (numbuf));
1410     }
1411   else if (!strcmp (line, "socket_name"))
1412     {
1413       const char *s = get_agent_socket_name ();
1414
1415       if (s)
1416         rc = assuan_send_data (ctx, s, strlen (s));
1417       else
1418         rc = gpg_error (GPG_ERR_NO_DATA);
1419     }
1420   else if (!strcmp (line, "ssh_socket_name"))
1421     {
1422       const char *s = get_agent_ssh_socket_name ();
1423
1424       if (s)
1425         rc = assuan_send_data (ctx, s, strlen (s));
1426       else
1427         rc = gpg_error (GPG_ERR_NO_DATA);
1428     }
1429   else
1430     rc = set_error (GPG_ERR_ASS_PARAMETER, "unknown value for WHAT");
1431   return rc;
1432 }
1433
1434
1435 \f
1436 static int
1437 option_handler (assuan_context_t ctx, const char *key, const char *value)
1438 {
1439   ctrl_t ctrl = assuan_get_pointer (ctx);
1440
1441   if (!strcmp (key, "display"))
1442     {
1443       if (ctrl->display)
1444         xfree (ctrl->display);
1445       ctrl->display = xtrystrdup (value);
1446       if (!ctrl->display)
1447         return out_of_core ();
1448     }
1449   else if (!strcmp (key, "ttyname"))
1450     {
1451       if (!opt.keep_tty)
1452         {
1453           if (ctrl->ttyname)
1454             xfree (ctrl->ttyname);
1455           ctrl->ttyname = xtrystrdup (value);
1456           if (!ctrl->ttyname)
1457             return out_of_core ();
1458         }
1459     }
1460   else if (!strcmp (key, "ttytype"))
1461     {
1462       if (!opt.keep_tty)
1463         {
1464           if (ctrl->ttytype)
1465             xfree (ctrl->ttytype);
1466           ctrl->ttytype = xtrystrdup (value);
1467           if (!ctrl->ttytype)
1468             return out_of_core ();
1469         }
1470     }
1471   else if (!strcmp (key, "lc-ctype"))
1472     {
1473       if (ctrl->lc_ctype)
1474         xfree (ctrl->lc_ctype);
1475       ctrl->lc_ctype = xtrystrdup (value);
1476       if (!ctrl->lc_ctype)
1477         return out_of_core ();
1478     }
1479   else if (!strcmp (key, "lc-messages"))
1480     {
1481       if (ctrl->lc_messages)
1482         xfree (ctrl->lc_messages);
1483       ctrl->lc_messages = xtrystrdup (value);
1484       if (!ctrl->lc_messages)
1485         return out_of_core ();
1486     }
1487   else if (!strcmp (key, "xauthority"))
1488     {
1489       if (ctrl->xauthority)
1490         xfree (ctrl->xauthority);
1491       ctrl->xauthority = xtrystrdup (value);
1492       if (!ctrl->xauthority)
1493         return out_of_core ();
1494     }
1495   else if (!strcmp (key, "pinentry-user-data"))
1496     {
1497       if (ctrl->pinentry_user_data)
1498         xfree (ctrl->pinentry_user_data);
1499       ctrl->pinentry_user_data = xtrystrdup (value);
1500       if (!ctrl->pinentry_user_data)
1501         return out_of_core ();
1502     }
1503   else if (!strcmp (key, "use-cache-for-signing"))
1504     ctrl->server_local->use_cache_for_signing = *value? atoi (value) : 0;
1505   else if (!strcmp (key, "allow-pinentry-notify"))
1506     ctrl->server_local->allow_pinentry_notify = 1;
1507   else
1508     return gpg_error (GPG_ERR_UNKNOWN_OPTION);
1509
1510   return 0;
1511 }
1512
1513
1514
1515 \f
1516 /* Called by libassuan after all commands. ERR is the error from the
1517    last assuan operation and not the one returned from the command. */
1518 static void
1519 post_cmd_notify (assuan_context_t ctx, int err)
1520 {
1521   ctrl_t ctrl = assuan_get_pointer (ctx);
1522   
1523   (void)err;
1524
1525   /* Switch off any I/O monitor controlled logging pausing. */
1526   ctrl->server_local->pause_io_logging = 0;
1527 }
1528
1529
1530 /* This function is called by libassuan for all I/O.  We use it here
1531    to disable logging for the GETEVENTCOUNTER commands.  This is so
1532    that the debug output won't get cluttered by this primitive
1533    command.  */
1534 static unsigned int
1535 io_monitor (assuan_context_t ctx, int direction,
1536             const char *line, size_t linelen)
1537 {
1538   ctrl_t ctrl = assuan_get_pointer (ctx);
1539   
1540   /* Note that we only check for the uppercase name.  This allows to
1541      see the logging for debugging if using a non-upercase command
1542      name. */
1543   if (ctx && !direction 
1544       && linelen >= 15
1545       && !strncmp (line, "GETEVENTCOUNTER", 15)
1546       && (linelen == 15 || spacep (line+15)))
1547     {
1548       ctrl->server_local->pause_io_logging = 1;
1549     }
1550
1551   return ctrl->server_local->pause_io_logging? 1:0;
1552 }
1553
1554
1555 /* Tell the assuan library about our commands */
1556 static int
1557 register_commands (assuan_context_t ctx)
1558 {
1559   static struct {
1560     const char *name;
1561     int (*handler)(assuan_context_t, char *line);
1562   } table[] = {
1563     { "GETEVENTCOUNTER",cmd_geteventcounter },
1564     { "ISTRUSTED",      cmd_istrusted },
1565     { "HAVEKEY",        cmd_havekey },
1566     { "SIGKEY",         cmd_sigkey },
1567     { "SETKEY",         cmd_sigkey },
1568     { "SETKEYDESC",     cmd_setkeydesc },
1569     { "SETHASH",        cmd_sethash },
1570     { "PKSIGN",         cmd_pksign },
1571     { "PKDECRYPT",      cmd_pkdecrypt },
1572     { "GENKEY",         cmd_genkey },
1573     { "READKEY",        cmd_readkey },
1574     { "GET_PASSPHRASE", cmd_get_passphrase },
1575     { "PRESET_PASSPHRASE", cmd_preset_passphrase },
1576     { "CLEAR_PASSPHRASE", cmd_clear_passphrase },
1577     { "GET_CONFIRMATION", cmd_get_confirmation },
1578     { "LISTTRUSTED",    cmd_listtrusted },
1579     { "MARKTRUSTED",    cmd_marktrusted },
1580     { "LEARN",          cmd_learn },
1581     { "PASSWD",         cmd_passwd },
1582     { "INPUT",          NULL }, 
1583     { "OUTPUT",         NULL }, 
1584     { "SCD",            cmd_scd },
1585     { "GETVAL",         cmd_getval },
1586     { "PUTVAL",         cmd_putval },
1587     { "UPDATESTARTUPTTY",  cmd_updatestartuptty },
1588 #ifdef HAVE_W32_SYSTEM
1589     { "KILLAGENT",      cmd_killagent },
1590     { "RELOADAGENT",    cmd_reloadagent },
1591 #endif
1592     { "GETINFO",        cmd_getinfo },
1593     { NULL }
1594   };
1595   int i, rc;
1596
1597   for (i=0; table[i].name; i++)
1598     {
1599       rc = assuan_register_command (ctx, table[i].name, table[i].handler);
1600       if (rc)
1601         return rc;
1602     } 
1603 #ifdef HAVE_ASSUAN_SET_IO_MONITOR
1604   assuan_register_post_cmd_notify (ctx, post_cmd_notify);
1605 #endif
1606   assuan_register_reset_notify (ctx, reset_notify);
1607   assuan_register_option_handler (ctx, option_handler);
1608   return 0;
1609 }
1610
1611
1612 /* Startup the server.  If LISTEN_FD and FD is given as -1, this is a
1613    simple piper server, otherwise it is a regular server.  CTRL is the
1614    control structure for this connection; it has only the basic
1615    intialization. */
1616 void
1617 start_command_handler (ctrl_t ctrl, gnupg_fd_t listen_fd, gnupg_fd_t fd)
1618 {
1619   int rc;
1620   assuan_context_t ctx;
1621
1622   if (listen_fd == GNUPG_INVALID_FD && fd == GNUPG_INVALID_FD)
1623     {
1624       int filedes[2];
1625
1626       filedes[0] = 0;
1627       filedes[1] = 1;
1628       rc = assuan_init_pipe_server (&ctx, filedes);
1629     }
1630   else if (listen_fd != GNUPG_INVALID_FD)
1631     {
1632       rc = assuan_init_socket_server_ext (&ctx, listen_fd, 0);
1633     }
1634   else 
1635     {
1636       rc = assuan_init_socket_server_ext (&ctx, fd, 2);
1637     }
1638   if (rc)
1639     {
1640       log_error ("failed to initialize the server: %s\n",
1641                  gpg_strerror(rc));
1642       agent_exit (2);
1643     }
1644   rc = register_commands (ctx);
1645   if (rc)
1646     {
1647       log_error ("failed to register commands with Assuan: %s\n",
1648                  gpg_strerror(rc));
1649       agent_exit (2);
1650     }
1651
1652   assuan_set_pointer (ctx, ctrl);
1653   ctrl->server_local = xcalloc (1, sizeof *ctrl->server_local);
1654   ctrl->server_local->assuan_ctx = ctx;
1655   ctrl->server_local->message_fd = -1;
1656   ctrl->server_local->use_cache_for_signing = 1;
1657   ctrl->digest.raw_value = 0;
1658
1659   if (DBG_ASSUAN)
1660     assuan_set_log_stream (ctx, log_get_stream ());
1661
1662 #ifdef HAVE_ASSUAN_SET_IO_MONITOR
1663   assuan_set_io_monitor (ctx, io_monitor);
1664 #endif
1665
1666   for (;;)
1667     {
1668       rc = assuan_accept (ctx);
1669       if (gpg_err_code (rc) == GPG_ERR_EOF || rc == -1)
1670         {
1671           break;
1672         }
1673       else if (rc)
1674         {
1675           log_info ("Assuan accept problem: %s\n", gpg_strerror (rc));
1676           break;
1677         }
1678       
1679       rc = assuan_process (ctx);
1680       if (rc)
1681         {
1682           log_info ("Assuan processing failed: %s\n", gpg_strerror (rc));
1683           continue;
1684         }
1685     }
1686
1687   /* Reset the SCD if needed. */
1688   agent_reset_scd (ctrl);
1689
1690   /* Reset the pinentry (in case of popup messages). */
1691   agent_reset_query (ctrl);
1692
1693   /* Cleanup.  */
1694   assuan_deinit_server (ctx);
1695 #ifdef HAVE_W32_SYSTEM
1696   if (ctrl->server_local->stopme)
1697     agent_exit (0);
1698 #endif
1699   xfree (ctrl->server_local);
1700   ctrl->server_local = NULL;
1701 }
1702