8a4ab544118839b6eeef1f31d011219eb8c45f38
[gpgme.git] / src / gpgme-w32spawn.c
1 /* gpgme-w32spawn.c - Wrapper to spawn a process under Windows.
2    Copyright (C) 2008 g10 Code GmbH
3
4    This file is part of GPGME.
5
6    GPGME is free software; you can redistribute it and/or modify it
7    under the terms of the GNU Lesser General Public License as
8    published by the Free Software Foundation; either version 2.1 of
9    the License, or (at your option) any later version.
10
11    GPGME is distributed in the hope that it will be useful, but
12    WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14    Lesser General Public License for more details.
15
16    You should have received a copy of the GNU Lesser General Public
17    License along with this program; if not, see <http://www.gnu.org/licenses/>.
18  */
19
20
21 #ifdef HAVE_CONFIG_H
22 # include <config.h>
23 #endif
24
25 #include <errno.h>
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <fcntl.h>
29 #include <ctype.h>
30 #include <string.h>
31 #ifdef HAVE_SYS_TYPES_H
32 # include <sys/types.h>
33 #endif
34 #ifdef HAVE_SYS_STAT_H
35 # include <sys/stat.h>
36 #endif
37 #include <stdint.h>
38 #include <process.h>
39 #include <windows.h>
40
41 /* Flag values as used by gpgme.  */
42 #define IOSPAWN_FLAG_ALLOW_SET_FG 1
43
44
45 /* Name of this program.  */
46 #define PGM "gpgme-w32spawn"
47
48
49 \f
50 struct spawn_fd_item_s
51 {
52   int handle;
53   int dup_to;
54   int peer_name;
55   int arg_loc;
56 };
57
58
59 static char *
60 build_commandline (char **argv)
61 {
62   int i;
63   int n = 0;
64   char *buf;
65   char *p;
66
67   /* We have to quote some things because under Windows the program
68      parses the commandline and does some unquoting.  We enclose the
69      whole argument in double-quotes, and escape literal double-quotes
70      as well as backslashes with a backslash.  We end up with a
71      trailing space at the end of the line, but that is harmless.  */
72   for (i = 0; argv[i]; i++)
73     {
74       p = argv[i];
75       /* The leading double-quote.  */
76       n++;
77       while (*p)
78         {
79           /* An extra one for each literal that must be escaped.  */
80           if (*p == '\\' || *p == '"')
81             n++;
82           n++;
83           p++;
84         }
85       /* The trailing double-quote and the delimiter.  */
86       n += 2;
87     }
88   /* And a trailing zero.  */
89   n++;
90
91   buf = p = malloc (n);
92   if (!buf)
93     return NULL;
94   for (i = 0; argv[i]; i++)
95     {
96       char *argvp = argv[i];
97
98       *(p++) = '"';
99       while (*argvp)
100         {
101           if (*argvp == '\\' || *argvp == '"')
102             *(p++) = '\\';
103           *(p++) = *(argvp++);
104         }
105       *(p++) = '"';
106       *(p++) = ' ';
107     }
108   *(p++) = 0;
109
110   return buf;
111 }
112
113
114 int
115 my_spawn (char **argv, struct spawn_fd_item_s *fd_list, unsigned int flags)
116 {
117   SECURITY_ATTRIBUTES sec_attr;
118   PROCESS_INFORMATION pi =
119     {
120       NULL,      /* returns process handle */
121       0,         /* returns primary thread handle */
122       0,         /* returns pid */
123       0          /* returns tid */
124     };
125   STARTUPINFO si;
126   char *envblock = NULL;
127   int cr_flags = CREATE_DEFAULT_ERROR_MODE
128     | GetPriorityClass (GetCurrentProcess ());
129   int i;
130   char *arg_string;
131   int duped_stdin = 0;
132   int duped_stdout = 0;
133   int duped_stderr = 0;
134   HANDLE hnul = INVALID_HANDLE_VALUE;
135   /* FIXME.  */
136   int debug_me = 0;
137
138   i = 0;
139   while (argv[i])
140     {
141       fprintf (stderr, PGM": argv[%2i] = %s\n", i, argv[i]);
142       i++;
143     }
144
145   memset (&sec_attr, 0, sizeof sec_attr);
146   sec_attr.nLength = sizeof sec_attr;
147   sec_attr.bInheritHandle = FALSE;
148
149   arg_string = build_commandline (argv);
150   if (!arg_string)
151     return -1;
152
153   memset (&si, 0, sizeof si);
154   si.cb = sizeof (si);
155   si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
156   si.wShowWindow = debug_me ? SW_SHOW : SW_HIDE;
157   si.hStdInput = GetStdHandle (STD_INPUT_HANDLE);
158   si.hStdOutput = GetStdHandle (STD_OUTPUT_HANDLE);
159   si.hStdError = GetStdHandle (STD_ERROR_HANDLE);
160
161   fprintf (stderr, PGM": spawning: %s\n", arg_string);
162
163   for (i = 0; fd_list[i].handle != -1; i++)
164     {
165       /* The handle already is inheritable.  */
166       if (fd_list[i].dup_to == 0)
167         {
168           si.hStdInput = (HANDLE) fd_list[i].peer_name;
169           duped_stdin = 1;
170           fprintf (stderr, PGM": dup 0x%x to stdin\n", fd_list[i].peer_name);
171         }
172       else if (fd_list[i].dup_to == 1)
173         {
174           si.hStdOutput = (HANDLE) fd_list[i].peer_name;
175           duped_stdout = 1;
176           fprintf (stderr, PGM": dup 0x%x to stdout\n", fd_list[i].peer_name);
177         }
178       else if (fd_list[i].dup_to == 2)
179         {
180           si.hStdError = (HANDLE) fd_list[i].peer_name;
181           duped_stderr = 1;
182           fprintf (stderr, PGM":dup 0x%x to stderr\n", fd_list[i].peer_name);
183         }
184     }
185
186   if (!duped_stdin || !duped_stdout || !duped_stderr)
187     {
188       SECURITY_ATTRIBUTES sa;
189
190       memset (&sa, 0, sizeof sa);
191       sa.nLength = sizeof sa;
192       sa.bInheritHandle = TRUE;
193       hnul = CreateFile ("nul",
194                          GENERIC_READ|GENERIC_WRITE,
195                          FILE_SHARE_READ|FILE_SHARE_WRITE,
196                          &sa,
197                          OPEN_EXISTING,
198                          FILE_ATTRIBUTE_NORMAL,
199                          NULL);
200       if (hnul == INVALID_HANDLE_VALUE)
201         {
202           free (arg_string);
203           /* FIXME: Should translate the error code.  */
204           errno = EIO;
205           return -1;
206         }
207       /* Make sure that the process has a connected stdin.  */
208       if (!duped_stdin)
209         si.hStdInput = hnul;
210       /* Make sure that the process has a connected stdout.  */
211       if (!duped_stdout)
212         si.hStdOutput = hnul;
213       /* We normally don't want all the normal output.  */
214       if (!duped_stderr)
215         si.hStdError = hnul;
216     }
217
218   cr_flags |= CREATE_SUSPENDED;
219   cr_flags |= DETACHED_PROCESS;
220   if (!CreateProcessA (argv[0],
221                        arg_string,
222                        &sec_attr,     /* process security attributes */
223                        &sec_attr,     /* thread security attributes */
224                        TRUE,          /* inherit handles */
225                        cr_flags,      /* creation flags */
226                        envblock,      /* environment */
227                        NULL,          /* use current drive/directory */
228                        &si,           /* startup information */
229                        &pi))          /* returns process information */
230     {
231       free (arg_string);
232       /* FIXME: Should translate the error code.  */
233       errno = EIO;
234       return -1;
235     }
236
237   free (arg_string);
238
239   /* Close the /dev/nul handle if used.  */
240   if (hnul != INVALID_HANDLE_VALUE)
241     CloseHandle (hnul);
242
243   for (i = 0; fd_list[i].handle != -1; i++)
244     CloseHandle ((HANDLE) fd_list[i].handle);
245
246   if (flags & IOSPAWN_FLAG_ALLOW_SET_FG)
247     {
248       static int initialized;
249       static BOOL (WINAPI * func)(DWORD);
250       void *handle;
251
252       if (!initialized)
253         {
254           /* Available since W2000; thus we dynload it.  */
255           initialized = 1;
256           handle = LoadLibrary ("user32.dll");
257           if (handle)
258             {
259               func = GetProcAddress (handle, "AllowSetForegroundWindow");
260               if (!func)
261                 FreeLibrary (handle);
262             }
263         }
264
265       if (func)
266         {
267           int rc = func (pi.dwProcessId);
268           fprintf (stderr, PGM": AllowSetForegroundWindow(%d): rc=%d\n",
269                    (int)pi.dwProcessId, rc);
270         }
271     }
272
273   ResumeThread (pi.hThread);
274   CloseHandle (pi.hThread);
275   CloseHandle (pi.hProcess);
276
277   return 0;
278 }
279
280 \f
281 #define MAX_TRANS 10
282
283 int
284 translate_get_from_file (const char *trans_file,
285                          struct spawn_fd_item_s *fd_list,
286                          unsigned int *r_flags)
287 {
288   /* Hold roughly MAX_TRANS triplets of 64 bit numbers in hex
289      notation: "0xFEDCBA9876543210".  10*19*4 - 1 = 759.  This plans
290      ahead for a time when a HANDLE is 64 bit.  */
291 #define BUFFER_MAX 810
292
293   char line[BUFFER_MAX + 1];
294   char *linep;
295   int idx;
296   int res;
297   int fd;
298
299   *r_flags = 0;
300
301   fd = open (trans_file, O_RDONLY);
302   if (fd < 0)
303     return -1;
304
305   /* We always read one line from stdin.  */
306   res = read (fd, line, BUFFER_MAX);
307   close (fd);
308   if (res < 0)
309     return -1;
310
311   line[BUFFER_MAX] = '\0';
312   linep = strchr (line, '\n');
313   if (linep)
314     {
315       if (linep > line && linep[-1] == '\r')
316         linep--;
317       *linep = '\0';
318     }
319   linep = line;
320
321   /* Now start to read mapping pairs.  */
322   for (idx = 0; idx < MAX_TRANS; idx++)
323     {
324       unsigned long from;
325       long dup_to;
326       unsigned long to;
327       unsigned long loc;
328       char *tail;
329
330       /* FIXME: Maybe could use scanf.  */
331       while (isspace (*((unsigned char *)linep)))
332         linep++;
333       if (*linep == '\0')
334         break;
335       if (!idx && *linep == '~')
336         {
337           /* Spawn flags have been passed.  */
338           linep++;
339           *r_flags = strtoul (linep, &tail, 0);
340           if (tail == NULL || ! (*tail == '\0' || isspace (*tail)))
341             break;
342           linep = tail;
343
344           while (isspace (*((unsigned char *)linep)))
345             linep++;
346           if (*linep == '\0')
347             break;
348         }
349
350       from = strtoul (linep, &tail, 0);
351       if (tail == NULL || ! (*tail == '\0' || isspace (*tail)))
352         break;
353       linep = tail;
354
355       while (isspace (*linep))
356         linep++;
357       if (*linep == '\0')
358         break;
359       dup_to = strtol (linep, &tail, 0);
360       if (tail == NULL || ! (*tail == '\0' || isspace (*tail)))
361         break;
362       linep = tail;
363
364       while (isspace (*linep))
365         linep++;
366       if (*linep == '\0')
367         break;
368       to = strtoul (linep, &tail, 0);
369       if (tail == NULL || ! (*tail == '\0' || isspace (*tail)))
370         break;
371       linep = tail;
372
373       while (isspace (*linep))
374         linep++;
375       if (*linep == '\0')
376         break;
377       loc = strtoul (linep, &tail, 0);
378       if (tail == NULL || ! (*tail == '\0' || isspace (*tail)))
379         break;
380       linep = tail;
381
382       fd_list[idx].handle = from;
383       fd_list[idx].dup_to = dup_to;
384       fd_list[idx].peer_name = to;
385       fd_list[idx].arg_loc = loc;
386     }
387   fd_list[idx].handle = -1;
388   fd_list[idx].dup_to = -1;
389   fd_list[idx].peer_name = -1;
390   fd_list[idx].arg_loc = 0;
391   return 0;
392 }
393
394
395 /* Read the translated handles from TRANS_FILE and do a substitution
396    in ARGV.  Returns the new argv and the list of substitutions in
397    FD_LIST (which must be MAX_TRANS+1 large).  */
398 char **
399 translate_handles (const char *trans_file, const char * const *argv,
400                    struct spawn_fd_item_s *fd_list, unsigned int *r_flags)
401 {
402   int res;
403   int idx;
404   int n_args;
405   char **args;
406
407   res = translate_get_from_file (trans_file, fd_list, r_flags);
408   if (res < 0)
409     return NULL;
410
411   for (idx = 0; argv[idx]; idx++)
412     ;
413   args = malloc (sizeof (*args) * (idx + 1));
414   for (idx = 0; argv[idx]; idx++)
415     {
416       args[idx] = strdup (argv[idx]);
417       if (!args[idx])
418         return NULL;
419     }
420   args[idx] = NULL;
421   n_args = idx;
422
423   for (idx = 0; fd_list[idx].handle != -1; idx++)
424     {
425       char buf[25];
426       int aidx;
427
428       aidx = fd_list[idx].arg_loc;
429       if (aidx == 0)
430         continue;
431
432       if (aidx >= n_args)
433         {
434           fprintf (stderr, PGM": translation file does not match args\n");
435           return NULL;
436         }
437
438       args[aidx] = malloc (sizeof (buf));
439       /* We currently disable translation for stdin/stdout/stderr.  We
440          assume that the spawned program handles 0/1/2 specially
441          already.  FIXME: Check if this is true.  */
442       if (!args[idx] || fd_list[idx].dup_to != -1)
443         return NULL;
444
445       /* NOTE: Here is the part where application specific knowledge
446          comes in.  GPGME/GnuPG uses two forms of descriptor
447          specification, a plain number and a "-&" form.  */
448       if (argv[aidx][0] == '-' && argv[aidx][1] == '&')
449         snprintf (args[aidx], sizeof (buf), "-&%d", fd_list[idx].peer_name);
450       else
451         snprintf (args[aidx], sizeof (buf), "%d", fd_list[idx].peer_name);
452     }
453   return args;
454 }
455
456
457 int
458 main (int argc, const char * const *argv)
459 {
460   int rc = 0;
461   char **argv_spawn;
462   struct spawn_fd_item_s fd_list[MAX_TRANS + 1];
463   unsigned int flags;
464
465   if (argc < 3)
466     {
467       rc = 2;
468       goto leave;
469     }
470
471   argv_spawn = translate_handles (argv[1], &argv[2], fd_list, &flags);
472   if (!argv_spawn)
473     {
474       rc = 2;
475       goto leave;
476     }
477
478   /* Using execv does not replace the existing program image, but
479      spawns a new one and daemonizes it, confusing the command line
480      interpreter.  So we have to use spawnv.  */
481   rc = my_spawn (argv_spawn, fd_list, flags);
482   if (rc < 0)
483     {
484       fprintf (stderr, PGM": executing `%s' failed: %s\n",
485                argv[0], strerror (errno));
486       rc = 2;
487       goto leave;
488     }
489
490  leave:
491   if (rc)
492     fprintf (stderr, PGM": internal error\n");
493   /* Always try to delete the temporary file.  */
494   if (argc >= 2)
495     {
496       if (DeleteFile (argv[1]) == 0)
497         fprintf (stderr, PGM": failed to delete %s: ec=%ld\n",
498                  argv[1], GetLastError ());
499     }
500   return rc;
501 }