Add "gpgconf --kill dirmngr" and avoid useless launch before a kill.
[gnupg.git] / tools / gpg-connect-agent.c
1 /* gpg-connect-agent.c - Tool to connect to the agent.
2  * Copyright (C) 2005, 2007, 2008, 2010 Free Software Foundation, Inc.
3  * Copyright (C) 2014 Werner Koch
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 #include <config.h>
22
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <errno.h>
27 #include <ctype.h>
28 #include <assuan.h>
29 #include <unistd.h>
30 #include <assert.h>
31
32 #include "i18n.h"
33 #include "../common/util.h"
34 #include "../common/asshelp.h"
35 #include "../common/sysutils.h"
36 #include "../common/membuf.h"
37 #include "../common/ttyio.h"
38 #ifdef HAVE_W32_SYSTEM
39 #  include "../common/exechelp.h"
40 #endif
41 #include "../common/init.h"
42
43
44 #define CONTROL_D ('D' - 'A' + 1)
45 #define octdigitp(p) (*(p) >= '0' && *(p) <= '7')
46
47 /* Constants to identify the commands and options. */
48 enum cmd_and_opt_values
49   {
50     aNull = 0,
51     oQuiet      = 'q',
52     oVerbose    = 'v',
53     oRawSocket  = 'S',
54     oTcpSocket  = 'T',
55     oExec       = 'E',
56     oRun        = 'r',
57     oSubst      = 's',
58
59     oNoVerbose  = 500,
60     oHomedir,
61     oAgentProgram,
62     oDirmngrProgram,
63     oHex,
64     oDecode,
65     oNoExtConnect,
66     oDirmngr,
67     oNoAutostart,
68
69   };
70
71
72 /* The list of commands and options. */
73 static ARGPARSE_OPTS opts[] = {
74   ARGPARSE_group (301, N_("@\nOptions:\n ")),
75
76   ARGPARSE_s_n (oVerbose, "verbose", N_("verbose")),
77   ARGPARSE_s_n (oQuiet, "quiet",     N_("quiet")),
78   ARGPARSE_s_n (oHex,   "hex",       N_("print data out hex encoded")),
79   ARGPARSE_s_n (oDecode,"decode",    N_("decode received data lines")),
80   ARGPARSE_s_n (oDirmngr,"dirmngr",  N_("connect to the dirmngr")),
81   ARGPARSE_s_s (oRawSocket, "raw-socket",
82                 N_("|NAME|connect to Assuan socket NAME")),
83   ARGPARSE_s_s (oTcpSocket, "tcp-socket",
84                 N_("|ADDR|connect to Assuan server at ADDR")),
85   ARGPARSE_s_n (oExec, "exec",
86                 N_("run the Assuan server given on the command line")),
87   ARGPARSE_s_n (oNoExtConnect, "no-ext-connect",
88                 N_("do not use extended connect mode")),
89   ARGPARSE_s_s (oRun,  "run",
90                 N_("|FILE|run commands from FILE on startup")),
91   ARGPARSE_s_n (oSubst, "subst",     N_("run /subst on startup")),
92
93   ARGPARSE_s_n (oNoAutostart, "no-autostart", "@"),
94   ARGPARSE_s_n (oNoVerbose, "no-verbose", "@"),
95   ARGPARSE_s_s (oHomedir, "homedir", "@" ),
96   ARGPARSE_s_s (oAgentProgram, "agent-program", "@"),
97   ARGPARSE_s_s (oDirmngrProgram, "dirmngr-program", "@"),
98
99   ARGPARSE_end ()
100 };
101
102
103 /* We keep all global options in the structure OPT.  */
104 struct
105 {
106   int verbose;          /* Verbosity level.  */
107   int quiet;            /* Be extra quiet.  */
108   int autostart;        /* Start the server if not running.  */
109   const char *homedir;  /* Configuration directory name */
110   const char *agent_program;  /* Value of --agent-program.  */
111   const char *dirmngr_program;  /* Value of --dirmngr-program.  */
112   int hex;              /* Print data lines in hex format. */
113   int decode;           /* Decode received data lines.  */
114   int use_dirmngr;      /* Use the dirmngr and not gpg-agent.  */
115   const char *raw_socket; /* Name of socket to connect in raw mode. */
116   const char *tcp_socket; /* Name of server to connect in tcp mode. */
117   int exec;             /* Run the pgm given on the command line. */
118   unsigned int connect_flags;    /* Flags used for connecting. */
119   int enable_varsubst;  /* Set if variable substitution is enabled.  */
120   int trim_leading_spaces;
121 } opt;
122
123
124
125 /* Definitions for /definq commands and a global linked list with all
126    the definitions. */
127 struct definq_s
128 {
129   struct definq_s *next;
130   char *name;     /* Name of inquiry or NULL for any name. */
131   int is_var;     /* True if FILE is a variable name. */
132   int is_prog;    /* True if FILE is a program to run. */
133   char file[1];   /* Name of file or program. */
134 };
135 typedef struct definq_s *definq_t;
136
137 static definq_t definq_list;
138 static definq_t *definq_list_tail = &definq_list;
139
140
141 /* Variable definitions and glovbal table.  */
142 struct variable_s
143 {
144   struct variable_s *next;
145   char *value;  /* Malloced value - always a string.  */
146   char name[1]; /* Name of the variable.  */
147 };
148 typedef struct variable_s *variable_t;
149
150 static variable_t variable_table;
151
152
153 /* To implement loops we store entire lines in a linked list.  */
154 struct loopline_s
155 {
156   struct loopline_s *next;
157   char line[1];
158 };
159 typedef struct loopline_s *loopline_t;
160
161
162 /* This is used to store the pid of the server.  */
163 static pid_t server_pid = (pid_t)(-1);
164
165 /* The current datasink file or NULL.  */
166 static FILE *current_datasink;
167
168 /* A list of open file descriptors. */
169 static struct
170 {
171   int inuse;
172 #ifdef HAVE_W32_SYSTEM
173   HANDLE handle;
174 #endif
175 } open_fd_table[256];
176
177
178 /*-- local prototypes --*/
179 static char *substitute_line_copy (const char *buffer);
180 static int read_and_print_response (assuan_context_t ctx, int withhash,
181                                     int *r_goterr);
182 static assuan_context_t start_agent (void);
183
184
185
186 \f
187 /* Print usage information and and provide strings for help. */
188 static const char *
189 my_strusage( int level )
190 {
191   const char *p;
192
193   switch (level)
194     {
195     case 11: p = "@GPG@-connect-agent (@GNUPG@)";
196       break;
197     case 13: p = VERSION; break;
198     case 17: p = PRINTABLE_OS_NAME; break;
199     case 19: p = _("Please report bugs to <@EMAIL@>.\n"); break;
200
201     case 1:
202     case 40: p = _("Usage: @GPG@-connect-agent [options] (-h for help)");
203       break;
204     case 41:
205       p = _("Syntax: @GPG@-connect-agent [options]\n"
206             "Connect to a running agent and send commands\n");
207       break;
208     case 31: p = "\nHome: "; break;
209     case 32: p = opt.homedir; break;
210     case 33: p = "\n"; break;
211
212     default: p = NULL; break;
213     }
214   return p;
215 }
216
217
218 /* Unescape STRING and returned the malloced result.  The surrounding
219    quotes must already be removed from STRING.  */
220 static char *
221 unescape_string (const char *string)
222 {
223   const unsigned char *s;
224   int esc;
225   size_t n;
226   char *buffer;
227   unsigned char *d;
228
229   n = 0;
230   for (s = (const unsigned char*)string, esc=0; *s; s++)
231     {
232       if (esc)
233         {
234           switch (*s)
235             {
236             case 'b':
237             case 't':
238             case 'v':
239             case 'n':
240             case 'f':
241             case 'r':
242             case '"':
243             case '\'':
244             case '\\': n++; break;
245             case 'x':
246               if (s[1] && s[2] && hexdigitp (s+1) && hexdigitp (s+2))
247                 n++;
248               break;
249
250             default:
251               if (s[1] && s[2]
252                   && octdigitp (s) && octdigitp (s+1) && octdigitp (s+2))
253                 n++;
254               break;
255             }
256           esc = 0;
257         }
258       else if (*s == '\\')
259         esc = 1;
260       else
261         n++;
262     }
263
264   buffer = xmalloc (n+1);
265   d = (unsigned char*)buffer;
266   for (s = (const unsigned char*)string, esc=0; *s; s++)
267     {
268       if (esc)
269         {
270           switch (*s)
271             {
272             case 'b':  *d++ = '\b'; break;
273             case 't':  *d++ = '\t'; break;
274             case 'v':  *d++ = '\v'; break;
275             case 'n':  *d++ = '\n'; break;
276             case 'f':  *d++ = '\f'; break;
277             case 'r':  *d++ = '\r'; break;
278             case '"':  *d++ = '\"'; break;
279             case '\'': *d++ = '\''; break;
280             case '\\': *d++ = '\\'; break;
281             case 'x':
282               if (s[1] && s[2] && hexdigitp (s+1) && hexdigitp (s+2))
283                 {
284                   s++;
285                   *d++ = xtoi_2 (s);
286                   s++;
287                 }
288               break;
289
290             default:
291               if (s[1] && s[2]
292                   && octdigitp (s) && octdigitp (s+1) && octdigitp (s+2))
293                 {
294                   *d++ = (atoi_1 (s)*64) + (atoi_1 (s+1)*8) + atoi_1 (s+2);
295                   s += 2;
296                 }
297               break;
298             }
299           esc = 0;
300         }
301       else if (*s == '\\')
302         esc = 1;
303       else
304         *d++ = *s;
305     }
306   *d = 0;
307   return buffer;
308 }
309
310
311 /* Do the percent unescaping and return a newly malloced string.
312    If WITH_PLUS is set '+' characters will be changed to space. */
313 static char *
314 unpercent_string (const char *string, int with_plus)
315 {
316   const unsigned char *s;
317   unsigned char *buffer, *p;
318   size_t n;
319
320   n = 0;
321   for (s=(const unsigned char *)string; *s; s++)
322     {
323       if (*s == '%' && s[1] && s[2])
324         {
325           s++;
326           n++;
327           s++;
328         }
329       else if (with_plus && *s == '+')
330         n++;
331       else
332         n++;
333     }
334
335   buffer = xmalloc (n+1);
336   p = buffer;
337   for (s=(const unsigned char *)string; *s; s++)
338     {
339       if (*s == '%' && s[1] && s[2])
340         {
341           s++;
342           *p++ = xtoi_2 (s);
343           s++;
344         }
345       else if (with_plus && *s == '+')
346         *p++ = ' ';
347       else
348         *p++ = *s;
349     }
350   *p = 0;
351   return (char*)buffer;
352 }
353
354
355
356
357 \f
358 static const char *
359 set_var (const char *name, const char *value)
360 {
361   variable_t var;
362
363   for (var = variable_table; var; var = var->next)
364     if (!strcmp (var->name, name))
365       break;
366   if (!var)
367     {
368       var = xmalloc (sizeof *var + strlen (name));
369       var->value = NULL;
370       strcpy (var->name, name);
371       var->next = variable_table;
372       variable_table = var;
373     }
374   xfree (var->value);
375   var->value = value? xstrdup (value) : NULL;
376   return var->value;
377 }
378
379
380 static void
381 set_int_var (const char *name, int value)
382 {
383   char numbuf[35];
384
385   snprintf (numbuf, sizeof numbuf, "%d", value);
386   set_var (name, numbuf);
387 }
388
389
390 /* Return the value of a variable.  That value is valid until a
391    variable of the name is changed.  Return NULL if not found.  Note
392    that envvars are copied to our variable list at the first access
393    and not at oprogram start.  */
394 static const char *
395 get_var (const char *name)
396 {
397   variable_t var;
398   const char *s;
399
400   if (!*name)
401     return "";
402   for (var = variable_table; var; var = var->next)
403     if (!strcmp (var->name, name))
404       break;
405   if (!var && (s = getenv (name)))
406     return set_var (name, s);
407   if (!var || !var->value)
408     return NULL;
409   return var->value;
410 }
411
412
413 /* Perform some simple arithmentic operations.  Caller must release
414    the return value.  On error the return value is NULL.  */
415 static char *
416 arithmetic_op (int operator, const char *operands)
417 {
418   long result, value;
419   char numbuf[35];
420
421   while ( spacep (operands) )
422     operands++;
423   if (!*operands)
424     return NULL;
425   result = strtol (operands, NULL, 0);
426   while (*operands && !spacep (operands) )
427     operands++;
428   if (operator == '!')
429     result = !result;
430
431   while (*operands)
432     {
433       while ( spacep (operands) )
434         operands++;
435       if (!*operands)
436         break;
437       value = strtol (operands, NULL, 0);
438       while (*operands && !spacep (operands) )
439         operands++;
440       switch (operator)
441         {
442         case '+': result += value; break;
443         case '-': result -= value; break;
444         case '*': result *= value; break;
445         case '/':
446           if (!value)
447             return NULL;
448           result /= value;
449           break;
450         case '%':
451           if (!value)
452             return NULL;
453           result %= value;
454           break;
455         case '!': result = !value; break;
456         case '|': result = result || value; break;
457         case '&': result = result && value; break;
458         default:
459           log_error ("unknown arithmetic operator '%c'\n", operator);
460           return NULL;
461         }
462     }
463   snprintf (numbuf, sizeof numbuf, "%ld", result);
464   return xstrdup (numbuf);
465 }
466
467
468
469 /* Extended version of get_var.  This returns a malloced string and
470    understand the function syntax: "func args".
471
472    Defined functions are
473
474      get - Return a value described by the next argument:
475            cwd        - The current working directory.
476            homedir    - The gnupg homedir.
477            sysconfdir - GnuPG's system configuration directory.
478            bindir     - GnuPG's binary directory.
479            libdir     - GnuPG's library directory.
480            libexecdir - GnuPG's library directory for executable files.
481            datadir    - GnuPG's data directory.
482            serverpid  - The PID of the current server.
483
484      unescape ARGS
485            Remove C-style escapes from string.  Note that "\0" and
486            "\x00" terminate the string implictly.  Use "\x7d" to
487            represent the closing brace.  The args start right after
488            the first space after the function name.
489
490      unpercent ARGS
491      unpercent+ ARGS
492            Remove percent style ecaping from string.  Note that "%00
493            terminates the string implicitly.  Use "%7d" to represetn
494            the closing brace.  The args start right after the first
495            space after the function name.  "unpercent+" also maps '+'
496            to space.
497
498      percent ARGS
499      percent+ ARGS
500            Escape the args using the percent style.  Tabs, formfeeds,
501            linefeeds and carriage returns are also escaped.
502            "percent+" also maps spaces to plus characters.
503
504      errcode ARG
505            Assuming ARG is an integer, return the gpg-error code.
506
507      errsource ARG
508            Assuming ARG is an integer, return the gpg-error source.
509
510      errstring ARG
511            Assuming ARG is an integer return a formatted fpf error string.
512
513
514    Example: get_var_ext ("get sysconfdir") -> "/etc/gnupg"
515
516   */
517 static char *
518 get_var_ext (const char *name)
519 {
520   static int recursion_count;
521   const char *s;
522   char *result;
523   char *p;
524   char *free_me = NULL;
525   int intvalue;
526
527   if (recursion_count > 50)
528     {
529       log_error ("variables nested too deeply\n");
530       return NULL;
531     }
532
533   recursion_count++;
534   free_me = opt.enable_varsubst? substitute_line_copy (name) : NULL;
535   if (free_me)
536     name = free_me;
537   for (s=name; *s && !spacep (s); s++)
538     ;
539   if (!*s)
540     {
541       s = get_var (name);
542       result = s? xstrdup (s): NULL;
543     }
544   else if ( (s - name) == 3 && !strncmp (name, "get", 3))
545     {
546       while ( spacep (s) )
547         s++;
548       if (!strcmp (s, "cwd"))
549         {
550           result = gnupg_getcwd ();
551           if (!result)
552             log_error ("getcwd failed: %s\n", strerror (errno));
553         }
554       else if (!strcmp (s, "homedir"))
555         result = make_filename (opt.homedir, NULL);
556       else if (!strcmp (s, "sysconfdir"))
557         result = xstrdup (gnupg_sysconfdir ());
558       else if (!strcmp (s, "bindir"))
559         result = xstrdup (gnupg_bindir ());
560       else if (!strcmp (s, "libdir"))
561         result = xstrdup (gnupg_libdir ());
562       else if (!strcmp (s, "libexecdir"))
563         result = xstrdup (gnupg_libexecdir ());
564       else if (!strcmp (s, "datadir"))
565         result = xstrdup (gnupg_datadir ());
566       else if (!strcmp (s, "serverpid"))
567         result = xasprintf ("%d", (int)server_pid);
568       else
569         {
570           log_error ("invalid argument '%s' for variable function 'get'\n", s);
571           log_info  ("valid are: cwd, "
572                      "{home,bin,lib,libexec,data}dir, serverpid\n");
573           result = NULL;
574         }
575     }
576   else if ( (s - name) == 8 && !strncmp (name, "unescape", 8))
577     {
578       s++;
579       result = unescape_string (s);
580     }
581   else if ( (s - name) == 9 && !strncmp (name, "unpercent", 9))
582     {
583       s++;
584       result = unpercent_string (s, 0);
585     }
586   else if ( (s - name) == 10 && !strncmp (name, "unpercent+", 10))
587     {
588       s++;
589       result = unpercent_string (s, 1);
590     }
591   else if ( (s - name) == 7 && !strncmp (name, "percent", 7))
592     {
593       s++;
594       result = percent_escape (s, "\t\r\n\f\v");
595     }
596   else if ( (s - name) == 8 && !strncmp (name, "percent+", 8))
597     {
598       s++;
599       result = percent_escape (s, "\t\r\n\f\v");
600       for (p=result; *p; p++)
601         if (*p == ' ')
602           *p = '+';
603     }
604   else if ( (s - name) == 7 && !strncmp (name, "errcode", 7))
605     {
606       s++;
607       intvalue = (int)strtol (s, NULL, 0);
608       result = xasprintf ("%d", gpg_err_code (intvalue));
609     }
610   else if ( (s - name) == 9 && !strncmp (name, "errsource", 9))
611     {
612       s++;
613       intvalue = (int)strtol (s, NULL, 0);
614       result = xasprintf ("%d", gpg_err_source (intvalue));
615     }
616   else if ( (s - name) == 9 && !strncmp (name, "errstring", 9))
617     {
618       s++;
619       intvalue = (int)strtol (s, NULL, 0);
620       result = xasprintf ("%s <%s>",
621                           gpg_strerror (intvalue), gpg_strsource (intvalue));
622     }
623   else if ( (s - name) == 1 && strchr ("+-*/%!|&", *name))
624     {
625       result = arithmetic_op (*name, s+1);
626     }
627   else
628     {
629       log_error ("unknown variable function '%.*s'\n", (int)(s-name), name);
630       result = NULL;
631     }
632
633   xfree (free_me);
634   recursion_count--;
635   return result;
636 }
637
638
639 /* Substitute variables in LINE and return a new allocated buffer if
640    required.  The function might modify LINE if the expanded version
641    fits into it.  */
642 static char *
643 substitute_line (char *buffer)
644 {
645   char *line = buffer;
646   char *p, *pend;
647   const char *value;
648   size_t valuelen, n;
649   char *result = NULL;
650   char *freeme = NULL;
651
652   while (*line)
653     {
654       p = strchr (line, '$');
655       if (!p)
656         return result; /* No more variables.  */
657
658       if (p[1] == '$') /* Escaped dollar sign. */
659         {
660           memmove (p, p+1, strlen (p+1)+1);
661           line = p + 1;
662           continue;
663         }
664       if (p[1] == '{')
665         {
666           int count = 0;
667
668           for (pend=p+2; *pend; pend++)
669             {
670               if (*pend == '{')
671                 count++;
672               else if (*pend == '}')
673                 {
674                   if (--count < 0)
675                     break;
676                 }
677             }
678           if (!*pend)
679             return result; /* Unclosed - don't substitute.  */
680         }
681       else
682         {
683           for (pend=p+1; *pend && !spacep (pend) && *pend != '$' ; pend++)
684             ;
685         }
686       if (p[1] == '{' && *pend == '}')
687         {
688           int save = *pend;
689           *pend = 0;
690           freeme = get_var_ext (p+2);
691           value = freeme;
692           *pend++ = save;
693         }
694       else if (*pend)
695         {
696           int save = *pend;
697           *pend = 0;
698           value = get_var (p+1);
699           *pend = save;
700         }
701       else
702         value = get_var (p+1);
703       if (!value)
704         value = "";
705       valuelen = strlen (value);
706       if (valuelen <= pend - p)
707         {
708           memcpy (p, value, valuelen);
709           p += valuelen;
710           n = pend - p;
711           if (n)
712             memmove (p, p+n, strlen (p+n)+1);
713           line = p;
714         }
715       else
716         {
717           char *src = result? result : buffer;
718           char *dst;
719
720           dst = xmalloc (strlen (src) + valuelen + 1);
721           n = p - src;
722           memcpy (dst, src, n);
723           memcpy (dst + n, value, valuelen);
724           n += valuelen;
725           strcpy (dst + n, pend);
726           line = dst + n;
727           xfree (result);
728           result = dst;
729         }
730       xfree (freeme);
731       freeme = NULL;
732     }
733   return result;
734 }
735
736 /* Same as substitute_line but do not modify BUFFER.  */
737 static char *
738 substitute_line_copy (const char *buffer)
739 {
740   char *result, *p;
741
742   p = xstrdup (buffer?buffer:"");
743   result = substitute_line (p);
744   if (!result)
745     result = p;
746   else
747     xfree (p);
748   return result;
749 }
750
751
752 static void
753 assign_variable (char *line, int syslet)
754 {
755   char *name, *p, *tmp, *free_me, *buffer;
756
757   /* Get the  name. */
758   name = line;
759   for (p=name; *p && !spacep (p); p++)
760     ;
761   if (*p)
762     *p++ = 0;
763   while (spacep (p))
764     p++;
765
766   if (!*p)
767     set_var (name, NULL); /* Remove variable.  */
768   else if (syslet)
769     {
770       free_me = opt.enable_varsubst? substitute_line_copy (p) : NULL;
771       if (free_me)
772         p = free_me;
773       buffer = xmalloc (4 + strlen (p) + 1);
774       strcpy (stpcpy (buffer, "get "), p);
775       tmp = get_var_ext (buffer);
776       xfree (buffer);
777       set_var (name, tmp);
778       xfree (tmp);
779       xfree (free_me);
780     }
781   else
782     {
783       tmp = opt.enable_varsubst? substitute_line_copy (p) : NULL;
784       if (tmp)
785         {
786           set_var (name, tmp);
787           xfree (tmp);
788         }
789       else
790         set_var (name, p);
791     }
792 }
793
794
795 static void
796 show_variables (void)
797 {
798   variable_t var;
799
800   for (var = variable_table; var; var = var->next)
801     if (var->value)
802       printf ("%-20s %s\n", var->name, var->value);
803 }
804
805
806 /* Store an inquire response pattern.  Note, that this function may
807    change the content of LINE.  We assume that leading white spaces
808    are already removed. */
809 static void
810 add_definq (char *line, int is_var, int is_prog)
811 {
812   definq_t d;
813   char *name, *p;
814
815   /* Get name. */
816   name = line;
817   for (p=name; *p && !spacep (p); p++)
818     ;
819   if (*p)
820     *p++ = 0;
821   while (spacep (p))
822     p++;
823
824   d = xmalloc (sizeof *d + strlen (p) );
825   strcpy (d->file, p);
826   d->is_var  = is_var;
827   d->is_prog = is_prog;
828   if ( !strcmp (name, "*"))
829     d->name = NULL;
830   else
831     d->name = xstrdup (name);
832
833   d->next = NULL;
834   *definq_list_tail = d;
835   definq_list_tail = &d->next;
836 }
837
838
839 /* Show all inquiry defintions. */
840 static void
841 show_definq (void)
842 {
843   definq_t d;
844
845   for (d=definq_list; d; d = d->next)
846     if (d->name)
847       printf ("%-20s %c %s\n",
848               d->name, d->is_var? 'v' : d->is_prog? 'p':'f', d->file);
849   for (d=definq_list; d; d = d->next)
850     if (!d->name)
851       printf ("%-20s %c %s\n", "*",
852               d->is_var? 'v': d->is_prog? 'p':'f', d->file);
853 }
854
855
856 /* Clear all inquiry definitions. */
857 static void
858 clear_definq (void)
859 {
860   while (definq_list)
861     {
862       definq_t tmp = definq_list->next;
863       xfree (definq_list->name);
864       xfree (definq_list);
865       definq_list = tmp;
866     }
867   definq_list_tail = &definq_list;
868 }
869
870
871 static void
872 do_sendfd (assuan_context_t ctx, char *line)
873 {
874   FILE *fp;
875   char *name, *mode, *p;
876   int rc, fd;
877
878   /* Get file name. */
879   name = line;
880   for (p=name; *p && !spacep (p); p++)
881     ;
882   if (*p)
883     *p++ = 0;
884   while (spacep (p))
885     p++;
886
887   /* Get mode.  */
888   mode = p;
889   if (!*mode)
890     mode = "r";
891   else
892     {
893       for (p=mode; *p && !spacep (p); p++)
894         ;
895       if (*p)
896         *p++ = 0;
897     }
898
899   /* Open and send. */
900   fp = fopen (name, mode);
901   if (!fp)
902     {
903       log_error ("can't open '%s' in \"%s\" mode: %s\n",
904                  name, mode, strerror (errno));
905       return;
906     }
907   fd = fileno (fp);
908
909   if (opt.verbose)
910     log_error ("file '%s' opened in \"%s\" mode, fd=%d\n",
911                name, mode, fd);
912
913   rc = assuan_sendfd (ctx, INT2FD (fd) );
914   if (rc)
915     log_error ("sending descriptor %d failed: %s\n", fd, gpg_strerror (rc));
916   fclose (fp);
917 }
918
919
920 static void
921 do_recvfd (assuan_context_t ctx, char *line)
922 {
923   (void)ctx;
924   (void)line;
925   log_info ("This command has not yet been implemented\n");
926 }
927
928
929 static void
930 do_open (char *line)
931 {
932   FILE *fp;
933   char *varname, *name, *mode, *p;
934   int fd;
935
936 #ifdef HAVE_W32_SYSTEM
937   if (server_pid == (pid_t)(-1))
938     {
939       log_error ("the pid of the server is unknown\n");
940       log_info ("use command \"/serverpid\" first\n");
941       return;
942     }
943 #endif
944
945   /* Get variable name. */
946   varname = line;
947   for (p=varname; *p && !spacep (p); p++)
948     ;
949   if (*p)
950     *p++ = 0;
951   while (spacep (p))
952     p++;
953
954   /* Get file name. */
955   name = p;
956   for (p=name; *p && !spacep (p); p++)
957     ;
958   if (*p)
959     *p++ = 0;
960   while (spacep (p))
961     p++;
962
963   /* Get mode.  */
964   mode = p;
965   if (!*mode)
966     mode = "r";
967   else
968     {
969       for (p=mode; *p && !spacep (p); p++)
970         ;
971       if (*p)
972         *p++ = 0;
973     }
974
975   /* Open and send. */
976   fp = fopen (name, mode);
977   if (!fp)
978     {
979       log_error ("can't open '%s' in \"%s\" mode: %s\n",
980                  name, mode, strerror (errno));
981       return;
982     }
983   fd = fileno (fp);
984   if (fd >= 0 && fd < DIM (open_fd_table))
985     {
986       open_fd_table[fd].inuse = 1;
987 #ifdef HAVE_W32CE_SYSTEM
988 # warning fixme: implement our pipe emulation.
989 #endif
990 #if defined(HAVE_W32_SYSTEM) && !defined(HAVE_W32CE_SYSTEM)
991       {
992         HANDLE prochandle, handle, newhandle;
993
994         handle = (void*)_get_osfhandle (fd);
995
996         prochandle = OpenProcess (PROCESS_DUP_HANDLE, FALSE, server_pid);
997         if (!prochandle)
998           {
999             log_error ("failed to open the server process\n");
1000             close (fd);
1001             return;
1002           }
1003
1004         if (!DuplicateHandle (GetCurrentProcess(), handle,
1005                               prochandle, &newhandle, 0,
1006                               TRUE, DUPLICATE_SAME_ACCESS ))
1007           {
1008             log_error ("failed to duplicate the handle\n");
1009             close (fd);
1010             CloseHandle (prochandle);
1011             return;
1012           }
1013         CloseHandle (prochandle);
1014         open_fd_table[fd].handle = newhandle;
1015       }
1016       if (opt.verbose)
1017         log_info ("file '%s' opened in \"%s\" mode, fd=%d  (libc=%d)\n",
1018                    name, mode, (int)open_fd_table[fd].handle, fd);
1019       set_int_var (varname, (int)open_fd_table[fd].handle);
1020 #else
1021       if (opt.verbose)
1022         log_info ("file '%s' opened in \"%s\" mode, fd=%d\n",
1023                    name, mode, fd);
1024       set_int_var (varname, fd);
1025 #endif
1026     }
1027   else
1028     {
1029       log_error ("can't put fd %d into table\n", fd);
1030       close (fd);
1031     }
1032 }
1033
1034
1035 static void
1036 do_close (char *line)
1037 {
1038   int fd = atoi (line);
1039
1040 #ifdef HAVE_W32_SYSTEM
1041   int i;
1042
1043   for (i=0; i < DIM (open_fd_table); i++)
1044     if ( open_fd_table[i].inuse && open_fd_table[i].handle == (void*)fd)
1045       break;
1046   if (i < DIM (open_fd_table))
1047     fd = i;
1048   else
1049     {
1050       log_error ("given fd (system handle) has not been opened\n");
1051       return;
1052     }
1053 #endif
1054
1055   if (fd < 0 || fd >= DIM (open_fd_table))
1056     {
1057       log_error ("invalid fd\n");
1058       return;
1059     }
1060
1061   if (!open_fd_table[fd].inuse)
1062     {
1063       log_error ("given fd has not been opened\n");
1064       return;
1065     }
1066 #ifdef HAVE_W32_SYSTEM
1067   CloseHandle (open_fd_table[fd].handle); /* Close duped handle.  */
1068 #endif
1069   close (fd);
1070   open_fd_table[fd].inuse = 0;
1071 }
1072
1073
1074 static void
1075 do_showopen (void)
1076 {
1077   int i;
1078
1079   for (i=0; i < DIM (open_fd_table); i++)
1080     if (open_fd_table[i].inuse)
1081       {
1082 #ifdef HAVE_W32_SYSTEM
1083         printf ("%-15d (libc=%d)\n", (int)open_fd_table[i].handle, i);
1084 #else
1085         printf ("%-15d\n", i);
1086 #endif
1087       }
1088 }
1089
1090
1091
1092 static gpg_error_t
1093 getinfo_pid_cb (void *opaque, const void *buffer, size_t length)
1094 {
1095   membuf_t *mb = opaque;
1096   put_membuf (mb, buffer, length);
1097   return 0;
1098 }
1099
1100 /* Get the pid of the server and store it locally.  */
1101 static void
1102 do_serverpid (assuan_context_t ctx)
1103 {
1104   int rc;
1105   membuf_t mb;
1106   char *buffer;
1107
1108   init_membuf (&mb, 100);
1109   rc = assuan_transact (ctx, "GETINFO pid", getinfo_pid_cb, &mb,
1110                         NULL, NULL, NULL, NULL);
1111   put_membuf (&mb, "", 1);
1112   buffer = get_membuf (&mb, NULL);
1113   if (rc || !buffer)
1114     log_error ("command \"%s\" failed: %s\n",
1115                "GETINFO pid", gpg_strerror (rc));
1116   else
1117     {
1118       server_pid = (pid_t)strtoul (buffer, NULL, 10);
1119       if (opt.verbose)
1120         log_info ("server's PID is %lu\n", (unsigned long)server_pid);
1121     }
1122   xfree (buffer);
1123 }
1124
1125
1126 /* Return true if the command is either "HELP" or "SCD HELP".  */
1127 static int
1128 help_cmd_p (const char *line)
1129 {
1130   if (!ascii_strncasecmp (line, "SCD", 3)
1131       && (spacep (line+3) || !line[3]))
1132     {
1133       for (line += 3; spacep (line); line++)
1134         ;
1135     }
1136
1137   return (!ascii_strncasecmp (line, "HELP", 4)
1138           && (spacep (line+4) || !line[4]));
1139 }
1140
1141
1142 /* gpg-connect-agent's entry point. */
1143 int
1144 main (int argc, char **argv)
1145 {
1146   ARGPARSE_ARGS pargs;
1147   int no_more_options = 0;
1148   assuan_context_t ctx;
1149   char *line, *p;
1150   char *tmpline;
1151   size_t linesize;
1152   int rc;
1153   int cmderr;
1154   const char *opt_run = NULL;
1155   FILE *script_fp = NULL;
1156   int use_tty, keep_line;
1157   struct {
1158     int collecting;
1159     loopline_t head;
1160     loopline_t *tail;
1161     loopline_t current;
1162     unsigned int nestlevel;
1163     int oneshot;
1164     char *condition;
1165   } loopstack[20];
1166   int        loopidx;
1167   char **cmdline_commands = NULL;
1168
1169   gnupg_rl_initialize ();
1170   set_strusage (my_strusage);
1171   log_set_prefix ("gpg-connect-agent", 1);
1172
1173   /* Make sure that our subsystems are ready.  */
1174   i18n_init();
1175   init_common_subsystems (&argc, &argv);
1176
1177   assuan_set_gpg_err_source (0);
1178
1179
1180   opt.homedir = default_homedir ();
1181   opt.autostart = 1;
1182   opt.connect_flags = 1;
1183
1184   /* Parse the command line. */
1185   pargs.argc  = &argc;
1186   pargs.argv  = &argv;
1187   pargs.flags =  1;  /* Do not remove the args.  */
1188   while (!no_more_options && optfile_parse (NULL, NULL, NULL, &pargs, opts))
1189     {
1190       switch (pargs.r_opt)
1191         {
1192         case oQuiet:     opt.quiet = 1; break;
1193         case oVerbose:   opt.verbose++; break;
1194         case oNoVerbose: opt.verbose = 0; break;
1195         case oHomedir:   opt.homedir = pargs.r.ret_str; break;
1196         case oAgentProgram: opt.agent_program = pargs.r.ret_str;  break;
1197         case oDirmngrProgram: opt.dirmngr_program = pargs.r.ret_str;  break;
1198         case oNoAutostart:    opt.autostart = 0; break;
1199         case oHex:       opt.hex = 1; break;
1200         case oDecode:    opt.decode = 1; break;
1201         case oDirmngr:   opt.use_dirmngr = 1; break;
1202         case oRawSocket: opt.raw_socket = pargs.r.ret_str; break;
1203         case oTcpSocket: opt.tcp_socket = pargs.r.ret_str; break;
1204         case oExec:      opt.exec = 1; break;
1205         case oNoExtConnect: opt.connect_flags &= ~(1); break;
1206         case oRun:       opt_run = pargs.r.ret_str; break;
1207         case oSubst:
1208           opt.enable_varsubst = 1;
1209           opt.trim_leading_spaces = 1;
1210           break;
1211
1212         default: pargs.err = 2; break;
1213         }
1214     }
1215
1216   if (log_get_errorcount (0))
1217     exit (2);
1218
1219
1220   /* Print a warning if an argument looks like an option.  */
1221   if (!opt.quiet && !(pargs.flags & ARGPARSE_FLAG_STOP_SEEN))
1222     {
1223       int i;
1224
1225       for (i=0; i < argc; i++)
1226         if (argv[i][0] == '-' && argv[i][1] == '-')
1227           log_info (_("Note: '%s' is not considered an option\n"), argv[i]);
1228     }
1229
1230
1231   use_tty = (gnupg_isatty (fileno (stdin)) && gnupg_isatty (fileno (stdout)));
1232
1233   if (opt.exec)
1234     {
1235       if (!argc)
1236         {
1237           log_error (_("option \"%s\" requires a program "
1238                        "and optional arguments\n"), "--exec" );
1239           exit (1);
1240         }
1241     }
1242   else if (argc)
1243     cmdline_commands = argv;
1244
1245   if (opt.exec && opt.raw_socket)
1246     {
1247       opt.raw_socket = NULL;
1248       log_info (_("option \"%s\" ignored due to \"%s\"\n"),
1249                 "--raw-socket", "--exec");
1250     }
1251   if (opt.exec && opt.tcp_socket)
1252     {
1253       opt.tcp_socket = NULL;
1254       log_info (_("option \"%s\" ignored due to \"%s\"\n"),
1255                 "--tcp-socket", "--exec");
1256     }
1257   if (opt.tcp_socket && opt.raw_socket)
1258     {
1259       opt.tcp_socket = NULL;
1260       log_info (_("option \"%s\" ignored due to \"%s\"\n"),
1261                 "--tcp-socket", "--raw-socket");
1262     }
1263
1264   if (opt_run && !(script_fp = fopen (opt_run, "r")))
1265     {
1266       log_error ("cannot open run file '%s': %s\n",
1267                  opt_run, strerror (errno));
1268       exit (1);
1269     }
1270
1271
1272   if (opt.exec)
1273     {
1274       assuan_fd_t no_close[3];
1275
1276       no_close[0] = assuan_fd_from_posix_fd (es_fileno (es_stderr));
1277       no_close[1] = assuan_fd_from_posix_fd (log_get_fd ());
1278       no_close[2] = ASSUAN_INVALID_FD;
1279
1280       rc = assuan_new (&ctx);
1281       if (rc)
1282         {
1283           log_error ("assuan_new failed: %s\n", gpg_strerror (rc));
1284           exit (1);
1285         }
1286
1287       rc = assuan_pipe_connect
1288         (ctx, *argv, (const char **)argv, no_close, NULL, NULL,
1289          (opt.connect_flags & 1) ? ASSUAN_PIPE_CONNECT_FDPASSING : 0);
1290       if (rc)
1291         {
1292           log_error ("assuan_pipe_connect_ext failed: %s\n",
1293                      gpg_strerror (rc));
1294           exit (1);
1295         }
1296
1297       if (opt.verbose)
1298         log_info ("server '%s' started\n", *argv);
1299
1300     }
1301   else if (opt.raw_socket)
1302     {
1303       rc = assuan_new (&ctx);
1304       if (rc)
1305         {
1306           log_error ("assuan_new failed: %s\n", gpg_strerror (rc));
1307           exit (1);
1308         }
1309
1310       rc = assuan_socket_connect
1311         (ctx, opt.raw_socket, 0,
1312          (opt.connect_flags & 1) ? ASSUAN_SOCKET_CONNECT_FDPASSING : 0);
1313       if (rc)
1314         {
1315           log_error ("can't connect to socket '%s': %s\n",
1316                      opt.raw_socket, gpg_strerror (rc));
1317           exit (1);
1318         }
1319
1320       if (opt.verbose)
1321         log_info ("connection to socket '%s' established\n", opt.raw_socket);
1322     }
1323   else if (opt.tcp_socket)
1324     {
1325       char *url;
1326
1327       url = xstrconcat ("assuan://", opt.tcp_socket, NULL);
1328
1329       rc = assuan_new (&ctx);
1330       if (rc)
1331         {
1332           log_error ("assuan_new failed: %s\n", gpg_strerror (rc));
1333           exit (1);
1334         }
1335
1336       rc = assuan_socket_connect (ctx, opt.tcp_socket, 0, 0);
1337       if (rc)
1338         {
1339           log_error ("can't connect to server '%s': %s\n",
1340                      opt.tcp_socket, gpg_strerror (rc));
1341           exit (1);
1342         }
1343
1344       if (opt.verbose)
1345         log_info ("connection to socket '%s' established\n", url);
1346
1347       xfree (url);
1348     }
1349   else
1350     ctx = start_agent ();
1351
1352   /* See whether there is a line pending from the server (in case
1353      assuan did not run the initial handshaking).  */
1354   if (assuan_pending_line (ctx))
1355     {
1356       rc = read_and_print_response (ctx, 0, &cmderr);
1357       if (rc)
1358         log_info (_("receiving line failed: %s\n"), gpg_strerror (rc) );
1359     }
1360
1361
1362   for (loopidx=0; loopidx < DIM (loopstack); loopidx++)
1363     loopstack[loopidx].collecting = 0;
1364   loopidx = -1;
1365   line = NULL;
1366   linesize = 0;
1367   keep_line = 1;
1368   for (;;)
1369     {
1370       int n;
1371       size_t maxlength = 2048;
1372
1373       assert (loopidx < (int)DIM (loopstack));
1374       if (loopidx >= 0 && loopstack[loopidx].current)
1375         {
1376           keep_line = 0;
1377           xfree (line);
1378           line = xstrdup (loopstack[loopidx].current->line);
1379           n = strlen (line);
1380           /* Never go beyond of the final /end.  */
1381           if (loopstack[loopidx].current->next)
1382             loopstack[loopidx].current = loopstack[loopidx].current->next;
1383           else if (!strncmp (line, "/end", 4) && (!line[4]||spacep(line+4)))
1384             ;
1385           else
1386             log_fatal ("/end command vanished\n");
1387         }
1388       else if (cmdline_commands && *cmdline_commands && !script_fp)
1389         {
1390           keep_line = 0;
1391           xfree (line);
1392           line = xstrdup (*cmdline_commands);
1393           cmdline_commands++;
1394           n = strlen (line);
1395           if (n >= maxlength)
1396             maxlength = 0;
1397         }
1398       else if (use_tty && !script_fp)
1399         {
1400           keep_line = 0;
1401           xfree (line);
1402           line = tty_get ("> ");
1403           n = strlen (line);
1404           if (n==1 && *line == CONTROL_D)
1405             n = 0;
1406           if (n >= maxlength)
1407             maxlength = 0;
1408         }
1409       else
1410         {
1411           if (!keep_line)
1412             {
1413               xfree (line);
1414               line = NULL;
1415               linesize = 0;
1416               keep_line = 1;
1417             }
1418           n = read_line (script_fp? script_fp:stdin,
1419                          &line, &linesize, &maxlength);
1420         }
1421       if (n < 0)
1422         {
1423           log_error (_("error reading input: %s\n"), strerror (errno));
1424           if (script_fp)
1425             {
1426               fclose (script_fp);
1427               script_fp = NULL;
1428               log_error ("stopping script execution\n");
1429               continue;
1430             }
1431           exit (1);
1432         }
1433       if (!n)
1434         {
1435           /* EOF */
1436           if (script_fp)
1437             {
1438               fclose (script_fp);
1439               script_fp = NULL;
1440               if (opt.verbose)
1441                 log_info ("end of script\n");
1442               continue;
1443             }
1444           break;
1445         }
1446       if (!maxlength)
1447         {
1448           log_error (_("line too long - skipped\n"));
1449           continue;
1450         }
1451       if (memchr (line, 0, n))
1452         log_info (_("line shortened due to embedded Nul character\n"));
1453       if (line[n-1] == '\n')
1454         line[n-1] = 0;
1455
1456       if (opt.trim_leading_spaces)
1457         {
1458           const char *s = line;
1459
1460           while (spacep (s))
1461             s++;
1462           if (s != line)
1463             {
1464               for (p=line; *s;)
1465                 *p++ = *s++;
1466               *p = 0;
1467               n = p - line;
1468             }
1469         }
1470
1471       if (loopidx+1 >= 0 && loopstack[loopidx+1].collecting)
1472         {
1473           loopline_t ll;
1474
1475           ll = xmalloc (sizeof *ll + strlen (line));
1476           ll->next = NULL;
1477           strcpy (ll->line, line);
1478           *loopstack[loopidx+1].tail = ll;
1479           loopstack[loopidx+1].tail = &ll->next;
1480
1481           if (!strncmp (line, "/end", 4) && (!line[4]||spacep(line+4)))
1482             loopstack[loopidx+1].nestlevel--;
1483           else if (!strncmp (line, "/while", 6) && (!line[6]||spacep(line+6)))
1484             loopstack[loopidx+1].nestlevel++;
1485
1486           if (loopstack[loopidx+1].nestlevel)
1487             continue;
1488           /* We reached the corresponding /end.  */
1489           loopstack[loopidx+1].collecting = 0;
1490           loopidx++;
1491         }
1492
1493       if (*line == '/')
1494         {
1495           /* Handle control commands. */
1496           char *cmd = line+1;
1497
1498           for (p=cmd; *p && !spacep (p); p++)
1499             ;
1500           if (*p)
1501             *p++ = 0;
1502           while (spacep (p))
1503             p++;
1504           if (!strcmp (cmd, "let"))
1505             {
1506               assign_variable (p, 0);
1507             }
1508           else if (!strcmp (cmd, "slet"))
1509             {
1510               /* Deprecated - never used in a released version.  */
1511               assign_variable (p, 1);
1512             }
1513           else if (!strcmp (cmd, "showvar"))
1514             {
1515               show_variables ();
1516             }
1517           else if (!strcmp (cmd, "definq"))
1518             {
1519               tmpline = opt.enable_varsubst? substitute_line (p) : NULL;
1520               if (tmpline)
1521                 {
1522                   add_definq (tmpline, 1, 0);
1523                   xfree (tmpline);
1524                 }
1525               else
1526                 add_definq (p, 1, 0);
1527             }
1528           else if (!strcmp (cmd, "definqfile"))
1529             {
1530               tmpline = opt.enable_varsubst? substitute_line (p) : NULL;
1531               if (tmpline)
1532                 {
1533                   add_definq (tmpline, 0, 0);
1534                   xfree (tmpline);
1535                 }
1536               else
1537                 add_definq (p, 0, 0);
1538             }
1539           else if (!strcmp (cmd, "definqprog"))
1540             {
1541               tmpline = opt.enable_varsubst? substitute_line (p) : NULL;
1542               if (tmpline)
1543                 {
1544                   add_definq (tmpline, 0, 1);
1545                   xfree (tmpline);
1546                 }
1547               else
1548                 add_definq (p, 0, 1);
1549             }
1550           else if (!strcmp (cmd, "datafile"))
1551             {
1552               const char *fname;
1553
1554               if (current_datasink)
1555                 {
1556                   if (current_datasink != stdout)
1557                     fclose (current_datasink);
1558                   current_datasink = NULL;
1559                 }
1560               tmpline = opt.enable_varsubst? substitute_line (p) : NULL;
1561               fname = tmpline? tmpline : p;
1562               if (fname && !strcmp (fname, "-"))
1563                 current_datasink = stdout;
1564               else if (fname && *fname)
1565                 {
1566                   current_datasink = fopen (fname, "wb");
1567                   if (!current_datasink)
1568                     log_error ("can't open '%s': %s\n",
1569                                fname, strerror (errno));
1570                 }
1571               xfree (tmpline);
1572             }
1573           else if (!strcmp (cmd, "showdef"))
1574             {
1575               show_definq ();
1576             }
1577           else if (!strcmp (cmd, "cleardef"))
1578             {
1579               clear_definq ();
1580             }
1581           else if (!strcmp (cmd, "echo"))
1582             {
1583               tmpline = opt.enable_varsubst? substitute_line (p) : NULL;
1584               if (tmpline)
1585                 {
1586                   puts (tmpline);
1587                   xfree (tmpline);
1588                 }
1589               else
1590                 puts (p);
1591             }
1592           else if (!strcmp (cmd, "sendfd"))
1593             {
1594               tmpline = opt.enable_varsubst? substitute_line (p) : NULL;
1595               if (tmpline)
1596                 {
1597                   do_sendfd (ctx, tmpline);
1598                   xfree (tmpline);
1599                 }
1600               else
1601                 do_sendfd (ctx, p);
1602               continue;
1603             }
1604           else if (!strcmp (cmd, "recvfd"))
1605             {
1606               tmpline = opt.enable_varsubst? substitute_line (p) : NULL;
1607               if (tmpline)
1608                 {
1609                   do_recvfd (ctx, tmpline);
1610                   xfree (tmpline);
1611                 }
1612               else
1613                 do_recvfd (ctx, p);
1614               continue;
1615             }
1616           else if (!strcmp (cmd, "open"))
1617             {
1618               tmpline = opt.enable_varsubst? substitute_line (p) : NULL;
1619               if (tmpline)
1620                 {
1621                   do_open (tmpline);
1622                   xfree (tmpline);
1623                 }
1624               else
1625                 do_open (p);
1626             }
1627           else if (!strcmp (cmd, "close"))
1628             {
1629               tmpline = opt.enable_varsubst? substitute_line (p) : NULL;
1630               if (tmpline)
1631                 {
1632                   do_close (tmpline);
1633                   xfree (tmpline);
1634                 }
1635               else
1636                 do_close (p);
1637             }
1638           else if (!strcmp (cmd, "showopen"))
1639             {
1640               do_showopen ();
1641             }
1642           else if (!strcmp (cmd, "serverpid"))
1643             {
1644               do_serverpid (ctx);
1645             }
1646           else if (!strcmp (cmd, "hex"))
1647             opt.hex = 1;
1648           else if (!strcmp (cmd, "nohex"))
1649             opt.hex = 0;
1650           else if (!strcmp (cmd, "decode"))
1651             opt.decode = 1;
1652           else if (!strcmp (cmd, "nodecode"))
1653             opt.decode = 0;
1654           else if (!strcmp (cmd, "subst"))
1655             {
1656               opt.enable_varsubst = 1;
1657               opt.trim_leading_spaces = 1;
1658             }
1659           else if (!strcmp (cmd, "nosubst"))
1660             opt.enable_varsubst = 0;
1661           else if (!strcmp (cmd, "run"))
1662             {
1663               char *p2;
1664
1665               for (p2=p; *p2 && !spacep (p2); p2++)
1666                 ;
1667               if (*p2)
1668                 *p2++ = 0;
1669               while (spacep (p2))
1670                 p++;
1671               if (*p2)
1672                 {
1673                   log_error ("syntax error in run command\n");
1674                   if (script_fp)
1675                     {
1676                       fclose (script_fp);
1677                       script_fp = NULL;
1678                     }
1679                 }
1680               else if (script_fp)
1681                 {
1682                   log_error ("cannot nest run commands - stop\n");
1683                   fclose (script_fp);
1684                   script_fp = NULL;
1685                 }
1686               else if (!(script_fp = fopen (p, "r")))
1687                 {
1688                   log_error ("cannot open run file '%s': %s\n",
1689                              p, strerror (errno));
1690                 }
1691               else if (opt.verbose)
1692                 log_info ("running commands from '%s'\n", p);
1693             }
1694           else if (!strcmp (cmd, "while"))
1695             {
1696               if (loopidx+2 >= (int)DIM(loopstack))
1697                 {
1698                   log_error ("blocks are nested too deep\n");
1699                   /* We should better die or break all loop in this
1700                      case as recovering from this error won't be
1701                      easy.  */
1702                 }
1703               else
1704                 {
1705                   loopstack[loopidx+1].head = NULL;
1706                   loopstack[loopidx+1].tail = &loopstack[loopidx+1].head;
1707                   loopstack[loopidx+1].current = NULL;
1708                   loopstack[loopidx+1].nestlevel = 1;
1709                   loopstack[loopidx+1].oneshot = 0;
1710                   loopstack[loopidx+1].condition = xstrdup (p);
1711                   loopstack[loopidx+1].collecting = 1;
1712                 }
1713             }
1714           else if (!strcmp (cmd, "if"))
1715             {
1716               if (loopidx+2 >= (int)DIM(loopstack))
1717                 {
1718                   log_error ("blocks are nested too deep\n");
1719                 }
1720               else
1721                 {
1722                   /* Note that we need to evaluate the condition right
1723                      away and not just at the end of the block as we
1724                      do with a WHILE. */
1725                   loopstack[loopidx+1].head = NULL;
1726                   loopstack[loopidx+1].tail = &loopstack[loopidx+1].head;
1727                   loopstack[loopidx+1].current = NULL;
1728                   loopstack[loopidx+1].nestlevel = 1;
1729                   loopstack[loopidx+1].oneshot = 1;
1730                   loopstack[loopidx+1].condition = substitute_line_copy (p);
1731                   loopstack[loopidx+1].collecting = 1;
1732                 }
1733             }
1734           else if (!strcmp (cmd, "end"))
1735             {
1736               if (loopidx < 0)
1737                 log_error ("stray /end command encountered - ignored\n");
1738               else
1739                 {
1740                   char *tmpcond;
1741                   const char *value;
1742                   long condition;
1743
1744                   /* Evaluate the condition.  */
1745                   tmpcond = xstrdup (loopstack[loopidx].condition);
1746                   if (loopstack[loopidx].oneshot)
1747                     {
1748                       xfree (loopstack[loopidx].condition);
1749                       loopstack[loopidx].condition = xstrdup ("0");
1750                     }
1751                   tmpline = substitute_line (tmpcond);
1752                   value = tmpline? tmpline : tmpcond;
1753                   /* "true" or "yes" are commonly used to mean TRUE;
1754                      all other strings will evaluate to FALSE due to
1755                      the strtoul.  */
1756                   if (!ascii_strcasecmp (value, "true")
1757                       || !ascii_strcasecmp (value, "yes"))
1758                     condition = 1;
1759                   else
1760                     condition = strtol (value, NULL, 0);
1761                   xfree (tmpline);
1762                   xfree (tmpcond);
1763
1764                   if (condition)
1765                     {
1766                       /* Run loop.  */
1767                       loopstack[loopidx].current = loopstack[loopidx].head;
1768                     }
1769                   else
1770                     {
1771                       /* Cleanup.  */
1772                       while (loopstack[loopidx].head)
1773                         {
1774                           loopline_t tmp = loopstack[loopidx].head->next;
1775                           xfree (loopstack[loopidx].head);
1776                           loopstack[loopidx].head = tmp;
1777                         }
1778                       loopstack[loopidx].tail = NULL;
1779                       loopstack[loopidx].current = NULL;
1780                       loopstack[loopidx].nestlevel = 0;
1781                       loopstack[loopidx].collecting = 0;
1782                       loopstack[loopidx].oneshot = 0;
1783                       xfree (loopstack[loopidx].condition);
1784                       loopstack[loopidx].condition = NULL;
1785                       loopidx--;
1786                     }
1787                 }
1788             }
1789           else if (!strcmp (cmd, "bye"))
1790             {
1791               break;
1792             }
1793           else if (!strcmp (cmd, "sleep"))
1794             {
1795               gnupg_sleep (1);
1796             }
1797           else if (!strcmp (cmd, "help"))
1798             {
1799               puts (
1800 "Available commands:\n"
1801 "/echo ARGS             Echo ARGS.\n"
1802 "/let  NAME VALUE       Set variable NAME to VALUE.\n"
1803 "/showvar               Show all variables.\n"
1804 "/definq NAME VAR       Use content of VAR for inquiries with NAME.\n"
1805 "/definqfile NAME FILE  Use content of FILE for inquiries with NAME.\n"
1806 "/definqprog NAME PGM   Run PGM for inquiries with NAME.\n"
1807 "/datafile [NAME]       Write all D line content to file NAME.\n"
1808 "/showdef               Print all definitions.\n"
1809 "/cleardef              Delete all definitions.\n"
1810 "/sendfd FILE MODE      Open FILE and pass descriptor to server.\n"
1811 "/recvfd                Receive FD from server and print.\n"
1812 "/open VAR FILE MODE    Open FILE and assign the file descriptor to VAR.\n"
1813 "/close FD              Close file with descriptor FD.\n"
1814 "/showopen              Show descriptors of all open files.\n"
1815 "/serverpid             Retrieve the pid of the server.\n"
1816 "/[no]hex               Enable hex dumping of received data lines.\n"
1817 "/[no]decode            Enable decoding of received data lines.\n"
1818 "/[no]subst             Enable variable substitution.\n"
1819 "/run FILE              Run commands from FILE.\n"
1820 "/if VAR                Begin conditional block controlled by VAR.\n"
1821 "/while VAR             Begin loop controlled by VAR.\n"
1822 "/end                   End loop or condition\n"
1823 "/bye                   Terminate gpg-connect-agent.\n"
1824 "/help                  Print this help.");
1825             }
1826           else
1827             log_error (_("unknown command '%s'\n"), cmd );
1828
1829           continue;
1830         }
1831
1832       if (opt.verbose && script_fp)
1833         puts (line);
1834
1835       tmpline = opt.enable_varsubst? substitute_line (line) : NULL;
1836       if (tmpline)
1837         {
1838           rc = assuan_write_line (ctx, tmpline);
1839           xfree (tmpline);
1840         }
1841       else
1842         rc = assuan_write_line (ctx, line);
1843       if (rc)
1844         {
1845           log_info (_("sending line failed: %s\n"), gpg_strerror (rc) );
1846           break;
1847         }
1848       if (*line == '#' || !*line)
1849         continue; /* Don't expect a response for a comment line. */
1850
1851       rc = read_and_print_response (ctx, help_cmd_p (line), &cmderr);
1852       if (rc)
1853         log_info (_("receiving line failed: %s\n"), gpg_strerror (rc) );
1854       if ((rc || cmderr) && script_fp)
1855         {
1856           log_error ("stopping script execution\n");
1857           fclose (script_fp);
1858           script_fp = NULL;
1859         }
1860
1861
1862       /* FIXME: If the last command was BYE or the server died for
1863          some other reason, we won't notice until we get the next
1864          input command.  Probing the connection with a non-blocking
1865          read could help to notice termination or other problems
1866          early.  */
1867     }
1868
1869   if (opt.verbose)
1870     log_info ("closing connection to agent\n");
1871
1872   return 0;
1873 }
1874
1875
1876 /* Handle an Inquire from the server.  Return False if it could not be
1877    handled; in this case the caller shll complete the operation.  LINE
1878    is the complete line as received from the server.  This function
1879    may change the content of LINE. */
1880 static int
1881 handle_inquire (assuan_context_t ctx, char *line)
1882 {
1883   const char *name;
1884   definq_t d;
1885   FILE *fp = NULL;
1886   char buffer[1024];
1887   int rc, n;
1888
1889   /* Skip the command and trailing spaces. */
1890   for (; *line && !spacep (line); line++)
1891     ;
1892   while (spacep (line))
1893     line++;
1894   /* Get the name. */
1895   name = line;
1896   for (; *line && !spacep (line); line++)
1897     ;
1898   if (*line)
1899     *line++ = 0;
1900
1901   /* Now match it against our list.  The second loop is there to
1902      detect the match-all entry. */
1903   for (d=definq_list; d; d = d->next)
1904     if (d->name && !strcmp (d->name, name))
1905         break;
1906   if (!d)
1907     for (d=definq_list; d; d = d->next)
1908       if (!d->name)
1909         break;
1910   if (!d)
1911     {
1912       if (opt.verbose)
1913         log_info ("no handler for inquiry '%s' found\n", name);
1914       return 0;
1915     }
1916
1917   if (d->is_var)
1918     {
1919       char *tmpvalue = get_var_ext (d->file);
1920       if (tmpvalue)
1921         rc = assuan_send_data (ctx, tmpvalue, strlen (tmpvalue));
1922       else
1923         rc = assuan_send_data (ctx, "", 0);
1924       xfree (tmpvalue);
1925       if (rc)
1926         log_error ("sending data back failed: %s\n", gpg_strerror (rc) );
1927     }
1928   else
1929     {
1930       if (d->is_prog)
1931         {
1932 #ifdef HAVE_W32CE_SYSTEM
1933           fp = NULL;
1934 #else
1935           fp = popen (d->file, "r");
1936 #endif
1937           if (!fp)
1938             log_error ("error executing '%s': %s\n",
1939                        d->file, strerror (errno));
1940           else if (opt.verbose)
1941             log_error ("handling inquiry '%s' by running '%s'\n",
1942                        name, d->file);
1943         }
1944       else
1945         {
1946           fp = fopen (d->file, "rb");
1947           if (!fp)
1948             log_error ("error opening '%s': %s\n", d->file, strerror (errno));
1949           else if (opt.verbose)
1950             log_error ("handling inquiry '%s' by returning content of '%s'\n",
1951                        name, d->file);
1952         }
1953       if (!fp)
1954         return 0;
1955
1956       while ( (n = fread (buffer, 1, sizeof buffer, fp)) )
1957         {
1958           rc = assuan_send_data (ctx, buffer, n);
1959           if (rc)
1960             {
1961               log_error ("sending data back failed: %s\n", gpg_strerror (rc) );
1962               break;
1963             }
1964         }
1965       if (ferror (fp))
1966         log_error ("error reading from '%s': %s\n", d->file, strerror (errno));
1967     }
1968
1969   rc = assuan_send_data (ctx, NULL, 0);
1970   if (rc)
1971     log_error ("sending data back failed: %s\n", gpg_strerror (rc) );
1972
1973   if (d->is_var)
1974     ;
1975   else if (d->is_prog)
1976     {
1977 #ifndef HAVE_W32CE_SYSTEM
1978       if (pclose (fp))
1979         log_error ("error running '%s': %s\n", d->file, strerror (errno));
1980 #endif
1981     }
1982   else
1983     fclose (fp);
1984   return 1;
1985 }
1986
1987
1988 /* Read all response lines from server and print them.  Returns 0 on
1989    success or an assuan error code.  If WITHHASH istrue, comment lines
1990    are printed.  Sets R_GOTERR to true if the command did not returned
1991    OK.  */
1992 static int
1993 read_and_print_response (assuan_context_t ctx, int withhash, int *r_goterr)
1994 {
1995   char *line;
1996   size_t linelen;
1997   gpg_error_t rc;
1998   int i, j;
1999   int need_lf = 0;
2000
2001   *r_goterr = 0;
2002   for (;;)
2003     {
2004       do
2005         {
2006           rc = assuan_read_line (ctx, &line, &linelen);
2007           if (rc)
2008             return rc;
2009
2010           if ((withhash || opt.verbose > 1) && *line == '#')
2011             {
2012               fwrite (line, linelen, 1, stdout);
2013               putchar ('\n');
2014             }
2015         }
2016       while (*line == '#' || !linelen);
2017
2018       if (linelen >= 1
2019           && line[0] == 'D' && line[1] == ' ')
2020         {
2021           if (current_datasink)
2022             {
2023               const unsigned char *s;
2024               int c = 0;
2025
2026               for (j=2, s=(unsigned char*)line+2; j < linelen; j++, s++ )
2027                 {
2028                   if (*s == '%' && j+2 < linelen)
2029                     {
2030                       s++; j++;
2031                       c = xtoi_2 ( s );
2032                       s++; j++;
2033                     }
2034                   else
2035                     c = *s;
2036                   putc (c, current_datasink);
2037                 }
2038             }
2039           else if (opt.hex)
2040             {
2041               for (i=2; i < linelen; )
2042                 {
2043                   int save_i = i;
2044
2045                   printf ("D[%04X] ", i-2);
2046                   for (j=0; j < 16 ; j++, i++)
2047                     {
2048                       if (j == 8)
2049                         putchar (' ');
2050                       if (i < linelen)
2051                         printf (" %02X", ((unsigned char*)line)[i]);
2052                       else
2053                         fputs ("   ", stdout);
2054                     }
2055                   fputs ("   ", stdout);
2056                   i= save_i;
2057                   for (j=0; j < 16; j++, i++)
2058                     {
2059                       unsigned int c = ((unsigned char*)line)[i];
2060                       if ( i >= linelen )
2061                         putchar (' ');
2062                       else if (isascii (c) && isprint (c) && !iscntrl (c))
2063                         putchar (c);
2064                       else
2065                         putchar ('.');
2066                     }
2067                   putchar ('\n');
2068                 }
2069             }
2070           else if (opt.decode)
2071             {
2072               const unsigned char *s;
2073               int need_d = 1;
2074               int c = 0;
2075
2076               for (j=2, s=(unsigned char*)line+2; j < linelen; j++, s++ )
2077                 {
2078                   if (need_d)
2079                     {
2080                       fputs ("D ", stdout);
2081                       need_d = 0;
2082                     }
2083                   if (*s == '%' && j+2 < linelen)
2084                     {
2085                       s++; j++;
2086                       c = xtoi_2 ( s );
2087                       s++; j++;
2088                     }
2089                   else
2090                     c = *s;
2091                   if (c == '\n')
2092                     need_d = 1;
2093                   putchar (c);
2094                 }
2095               need_lf = (c != '\n');
2096             }
2097           else
2098             {
2099               fwrite (line, linelen, 1, stdout);
2100               putchar ('\n');
2101             }
2102         }
2103       else
2104         {
2105           if (need_lf)
2106             {
2107               if (!current_datasink || current_datasink != stdout)
2108                 putchar ('\n');
2109               need_lf = 0;
2110             }
2111
2112           if (linelen >= 1
2113               && line[0] == 'S'
2114               && (line[1] == '\0' || line[1] == ' '))
2115             {
2116               if (!current_datasink || current_datasink != stdout)
2117                 {
2118                   fwrite (line, linelen, 1, stdout);
2119                   putchar ('\n');
2120                 }
2121             }
2122           else if (linelen >= 2
2123                    && line[0] == 'O' && line[1] == 'K'
2124                    && (line[2] == '\0' || line[2] == ' '))
2125             {
2126               if (!current_datasink || current_datasink != stdout)
2127                 {
2128                   fwrite (line, linelen, 1, stdout);
2129                   putchar ('\n');
2130                 }
2131               set_int_var ("?", 0);
2132               return 0;
2133             }
2134           else if (linelen >= 3
2135                    && line[0] == 'E' && line[1] == 'R' && line[2] == 'R'
2136                    && (line[3] == '\0' || line[3] == ' '))
2137             {
2138               int errval;
2139
2140               errval = strtol (line+3, NULL, 10);
2141               if (!errval)
2142                 errval = -1;
2143               set_int_var ("?", errval);
2144               if (!current_datasink || current_datasink != stdout)
2145                 {
2146                   fwrite (line, linelen, 1, stdout);
2147                   putchar ('\n');
2148                 }
2149               *r_goterr = 1;
2150               return 0;
2151             }
2152           else if (linelen >= 7
2153                    && line[0] == 'I' && line[1] == 'N' && line[2] == 'Q'
2154                    && line[3] == 'U' && line[4] == 'I' && line[5] == 'R'
2155                    && line[6] == 'E'
2156                    && (line[7] == '\0' || line[7] == ' '))
2157             {
2158               if (!current_datasink || current_datasink != stdout)
2159                 {
2160                   fwrite (line, linelen, 1, stdout);
2161                   putchar ('\n');
2162                 }
2163               if (!handle_inquire (ctx, line))
2164                 assuan_write_line (ctx, "CANCEL");
2165             }
2166           else if (linelen >= 3
2167                    && line[0] == 'E' && line[1] == 'N' && line[2] == 'D'
2168                    && (line[3] == '\0' || line[3] == ' '))
2169             {
2170               if (!current_datasink || current_datasink != stdout)
2171                 {
2172                   fwrite (line, linelen, 1, stdout);
2173                   putchar ('\n');
2174                 }
2175               /* Received from server, thus more responses are expected.  */
2176             }
2177           else
2178             return gpg_error (GPG_ERR_ASS_INV_RESPONSE);
2179         }
2180     }
2181 }
2182
2183
2184
2185
2186 /* Connect to the agent and send the standard options.  */
2187 static assuan_context_t
2188 start_agent (void)
2189 {
2190   gpg_error_t err;
2191   assuan_context_t ctx;
2192   session_env_t session_env;
2193
2194   session_env = session_env_new ();
2195   if (!session_env)
2196     log_fatal ("error allocating session environment block: %s\n",
2197                strerror (errno));
2198   if (opt.use_dirmngr)
2199     err = start_new_dirmngr (&ctx,
2200                              GPG_ERR_SOURCE_DEFAULT,
2201                              opt.homedir,
2202                              opt.dirmngr_program,
2203                              opt.autostart,
2204                              !opt.quiet, 0,
2205                              NULL, NULL);
2206   else
2207     err = start_new_gpg_agent (&ctx,
2208                                GPG_ERR_SOURCE_DEFAULT,
2209                                opt.homedir,
2210                                opt.agent_program,
2211                                NULL, NULL,
2212                                session_env,
2213                                opt.autostart,
2214                                !opt.quiet, 0,
2215                                NULL, NULL);
2216
2217   session_env_release (session_env);
2218   if (err)
2219     {
2220       if (!opt.autostart
2221           && (gpg_err_code (err)
2222               == opt.use_dirmngr? GPG_ERR_NO_DIRMNGR : GPG_ERR_NO_AGENT))
2223         {
2224           /* In the no-autostart case we don't make gpg-connect-agent
2225              fail on a missing server.  */
2226           log_info (opt.use_dirmngr?
2227                     _("no dirmngr running in this session\n"):
2228                     _("no gpg-agent running in this session\n"));
2229           exit (0);
2230         }
2231       else
2232         {
2233           log_error (_("error sending standard options: %s\n"),
2234                      gpg_strerror (err));
2235           exit (1);
2236         }
2237     }
2238
2239   return ctx;
2240 }