OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [libiberty/] [pex-win32.c] - Blame information for rev 450

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 274 jeremybenn
/* Utilities to execute a program in a subprocess (possibly linked by pipes
2
   with other subprocesses), and wait for it.  Generic Win32 specialization.
3
   Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006
4
   Free Software Foundation, Inc.
5
 
6
This file is part of the libiberty library.
7
Libiberty is free software; you can redistribute it and/or
8
modify it under the terms of the GNU Library General Public
9
License as published by the Free Software Foundation; either
10
version 2 of the License, or (at your option) any later version.
11
 
12
Libiberty 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 GNU
15
Library General Public License for more details.
16
 
17
You should have received a copy of the GNU Library General Public
18
License along with libiberty; see the file COPYING.LIB.  If not,
19
write to the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
20
Boston, MA 02110-1301, USA.  */
21
 
22
#include "pex-common.h"
23
 
24
#include <windows.h>
25
 
26
#ifdef HAVE_STDLIB_H
27
#include <stdlib.h>
28
#endif
29
#ifdef HAVE_STRING_H
30
#include <string.h>
31
#endif
32
#ifdef HAVE_UNISTD_H
33
#include <unistd.h>
34
#endif
35
#ifdef HAVE_SYS_WAIT_H
36
#include <sys/wait.h>
37
#endif
38
 
39
#include <assert.h>
40
#include <process.h>
41
#include <io.h>
42
#include <fcntl.h>
43
#include <signal.h>
44
#include <sys/stat.h>
45
#include <errno.h>
46
#include <ctype.h>
47
 
48
/* mingw32 headers may not define the following.  */
49
 
50
#ifndef _P_WAIT
51
#  define _P_WAIT       0
52
#  define _P_NOWAIT     1
53
#  define _P_OVERLAY    2
54
#  define _P_NOWAITO    3
55
#  define _P_DETACH     4
56
 
57
#  define WAIT_CHILD            0
58
#  define WAIT_GRANDCHILD       1
59
#endif
60
 
61
#define MINGW_NAME "Minimalist GNU for Windows"
62
#define MINGW_NAME_LEN (sizeof(MINGW_NAME) - 1)
63
 
64
extern char *stpcpy (char *dst, const char *src);
65
 
66
/* Ensure that the executable pathname uses Win32 backslashes. This
67
   is not necessary on NT, but on W9x, forward slashes causes
68
   failure of spawn* and exec* functions (and probably any function
69
   that calls CreateProcess) *iff* the executable pathname (argv[0])
70
   is a quoted string.  And quoting is necessary in case a pathname
71
   contains embedded white space.  You can't win.  */
72
static void
73
backslashify (char *s)
74
{
75
  while ((s = strchr (s, '/')) != NULL)
76
    *s = '\\';
77
  return;
78
}
79
 
80
static int pex_win32_open_read (struct pex_obj *, const char *, int);
81
static int pex_win32_open_write (struct pex_obj *, const char *, int);
82
static pid_t pex_win32_exec_child (struct pex_obj *, int, const char *,
83
                                  char * const *, char * const *,
84
                                  int, int, int, int,
85
                                  const char **, int *);
86
static int pex_win32_close (struct pex_obj *, int);
87
static pid_t pex_win32_wait (struct pex_obj *, pid_t, int *,
88
                           struct pex_time *, int, const char **, int *);
89
static int pex_win32_pipe (struct pex_obj *, int *, int);
90
static FILE *pex_win32_fdopenr (struct pex_obj *, int, int);
91
static FILE *pex_win32_fdopenw (struct pex_obj *, int, int);
92
 
93
/* The list of functions we pass to the common routines.  */
94
 
95
const struct pex_funcs funcs =
96
{
97
  pex_win32_open_read,
98
  pex_win32_open_write,
99
  pex_win32_exec_child,
100
  pex_win32_close,
101
  pex_win32_wait,
102
  pex_win32_pipe,
103
  pex_win32_fdopenr,
104
  pex_win32_fdopenw,
105
  NULL /* cleanup */
106
};
107
 
108
/* Return a newly initialized pex_obj structure.  */
109
 
110
struct pex_obj *
111
pex_init (int flags, const char *pname, const char *tempbase)
112
{
113
  return pex_init_common (flags, pname, tempbase, &funcs);
114
}
115
 
116
/* Open a file for reading.  */
117
 
118
static int
119
pex_win32_open_read (struct pex_obj *obj ATTRIBUTE_UNUSED, const char *name,
120
                     int binary)
121
{
122
  return _open (name, _O_RDONLY | (binary ? _O_BINARY : _O_TEXT));
123
}
124
 
125
/* Open a file for writing.  */
126
 
127
static int
128
pex_win32_open_write (struct pex_obj *obj ATTRIBUTE_UNUSED, const char *name,
129
                      int binary)
130
{
131
  /* Note that we can't use O_EXCL here because gcc may have already
132
     created the temporary file via make_temp_file.  */
133
  return _open (name,
134
                (_O_WRONLY | _O_CREAT | _O_TRUNC
135
                 | (binary ? _O_BINARY : _O_TEXT)),
136
                _S_IREAD | _S_IWRITE);
137
}
138
 
139
/* Close a file.  */
140
 
141
static int
142
pex_win32_close (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd)
143
{
144
  return _close (fd);
145
}
146
 
147
#ifdef USE_MINGW_MSYS
148
static const char *mingw_keys[] = {"SOFTWARE", "Microsoft", "Windows", "CurrentVersion", "Uninstall", NULL};
149
 
150
/* Tack the executable on the end of a (possibly slash terminated) buffer
151
   and convert everything to \. */
152
static const char *
153
tack_on_executable (char *buf, const char *executable)
154
{
155
  char *p = strchr (buf, '\0');
156
  if (p > buf && (p[-1] == '\\' || p[-1] == '/'))
157
    p[-1] = '\0';
158
  backslashify (strcat (buf, executable));
159
  return buf;
160
}
161
 
162
/* Walk down a registry hierarchy until the end.  Return the key. */
163
static HKEY
164
openkey (HKEY hStart, const char *keys[])
165
{
166
  HKEY hKey, hTmp;
167
  for (hKey = hStart; *keys; keys++)
168
    {
169
      LONG res;
170
      hTmp = hKey;
171
      res = RegOpenKey (hTmp, *keys, &hKey);
172
 
173
      if (hTmp != HKEY_LOCAL_MACHINE)
174
        RegCloseKey (hTmp);
175
 
176
      if (res != ERROR_SUCCESS)
177
        return NULL;
178
    }
179
  return hKey;
180
}
181
 
182
/* Return the "mingw root" as derived from the mingw uninstall information. */
183
static const char *
184
mingw_rootify (const char *executable)
185
{
186
  HKEY hKey, hTmp;
187
  DWORD maxlen;
188
  char *namebuf, *foundbuf;
189
  DWORD i;
190
  LONG res;
191
 
192
  /* Open the uninstall "directory". */
193
  hKey = openkey (HKEY_LOCAL_MACHINE, mingw_keys);
194
 
195
  /* Not found. */
196
  if (!hKey)
197
    return executable;
198
 
199
  /* Need to enumerate all of the keys here looking for one the most recent
200
     one for MinGW. */
201
  if (RegQueryInfoKey (hKey, NULL, NULL, NULL, NULL, &maxlen, NULL, NULL,
202
                       NULL, NULL, NULL, NULL) != ERROR_SUCCESS)
203
    {
204
      RegCloseKey (hKey);
205
      return executable;
206
    }
207
  namebuf = XNEWVEC (char, ++maxlen);
208
  foundbuf = XNEWVEC (char, maxlen);
209
  foundbuf[0] = '\0';
210
  if (!namebuf || !foundbuf)
211
    {
212
      RegCloseKey (hKey);
213
      if (namebuf)
214
        free (namebuf);
215
      if (foundbuf)
216
        free (foundbuf);
217
      return executable;
218
    }
219
 
220
  /* Look through all of the keys for one that begins with Minimal GNU...
221
     Try to get the latest version by doing a string compare although that
222
     string never really works with version number sorting. */
223
  for (i = 0; RegEnumKey (hKey, i, namebuf, maxlen) == ERROR_SUCCESS; i++)
224
    {
225
      int match = strcasecmp (namebuf, MINGW_NAME);
226
      if (match < 0)
227
        continue;
228
      if (match > 0 && strncasecmp (namebuf, MINGW_NAME, MINGW_NAME_LEN) > 0)
229
        continue;
230
      if (strcasecmp (namebuf, foundbuf) > 0)
231
        strcpy (foundbuf, namebuf);
232
    }
233
  free (namebuf);
234
 
235
  /* If foundbuf is empty, we didn't find anything.  Punt. */
236
  if (!foundbuf[0])
237
    {
238
      free (foundbuf);
239
      RegCloseKey (hKey);
240
      return executable;
241
    }
242
 
243
  /* Open the key that we wanted */
244
  res = RegOpenKey (hKey, foundbuf, &hTmp);
245
  RegCloseKey (hKey);
246
  free (foundbuf);
247
 
248
  /* Don't know why this would fail, but you gotta check */
249
  if (res != ERROR_SUCCESS)
250
    return executable;
251
 
252
  maxlen = 0;
253
  /* Get the length of the value pointed to by InstallLocation */
254
  if (RegQueryValueEx (hTmp, "InstallLocation", 0, NULL, NULL,
255
                       &maxlen) != ERROR_SUCCESS || maxlen == 0)
256
    {
257
      RegCloseKey (hTmp);
258
      return executable;
259
    }
260
 
261
  /* Allocate space for the install location */
262
  foundbuf = XNEWVEC (char, maxlen + strlen (executable));
263
  if (!foundbuf)
264
    {
265
      free (foundbuf);
266
      RegCloseKey (hTmp);
267
    }
268
 
269
  /* Read the install location into the buffer */
270
  res = RegQueryValueEx (hTmp, "InstallLocation", 0, NULL, (LPBYTE) foundbuf,
271
                         &maxlen);
272
  RegCloseKey (hTmp);
273
  if (res != ERROR_SUCCESS)
274
    {
275
      free (foundbuf);
276
      return executable;
277
    }
278
 
279
  /* Concatenate the install location and the executable, turn all slashes
280
     to backslashes, and return that. */
281
  return tack_on_executable (foundbuf, executable);
282
}
283
 
284
/* Read the install location of msys from it's installation file and
285
   rootify the executable based on that. */
286
static const char *
287
msys_rootify (const char *executable)
288
{
289
  size_t bufsize = 64;
290
  size_t execlen = strlen (executable) + 1;
291
  char *buf;
292
  DWORD res = 0;
293
  for (;;)
294
    {
295
      buf = XNEWVEC (char, bufsize + execlen);
296
      if (!buf)
297
        break;
298
      res = GetPrivateProfileString ("InstallSettings", "InstallPath", NULL,
299
                                     buf, bufsize, "msys.ini");
300
      if (!res)
301
        break;
302
      if (strlen (buf) < bufsize)
303
        break;
304
      res = 0;
305
      free (buf);
306
      bufsize *= 2;
307
      if (bufsize > 65536)
308
        {
309
          buf = NULL;
310
          break;
311
        }
312
    }
313
 
314
  if (res)
315
    return tack_on_executable (buf, executable);
316
 
317
  /* failed */
318
  if (buf)
319
    free (buf);
320
  return executable;
321
}
322
#endif
323
 
324
/* Return the number of arguments in an argv array, not including the null
325
   terminating argument. */
326
 
327
static int
328
argv_to_argc (char *const *argv)
329
{
330
  char *const *i = argv;
331
  while (*i)
332
    i++;
333
  return i - argv;
334
}
335
 
336
/* Return a Windows command-line from ARGV.  It is the caller's
337
   responsibility to free the string returned.  */
338
 
339
static char *
340
argv_to_cmdline (char *const *argv)
341
{
342
  char *cmdline;
343
  char *p;
344
  size_t cmdline_len;
345
  int i, j, k;
346
 
347
  cmdline_len = 0;
348
  for (i = 0; argv[i]; i++)
349
    {
350
      /* We quote every last argument.  This simplifies the problem;
351
         we need only escape embedded double-quotes and immediately
352
         preceeding backslash characters.  A sequence of backslach characters
353
         that is not follwed by a double quote character will not be
354
         escaped.  */
355
      for (j = 0; argv[i][j]; j++)
356
        {
357
          if (argv[i][j] == '"')
358
            {
359
              /* Escape preceeding backslashes.  */
360
              for (k = j - 1; k >= 0 && argv[i][k] == '\\'; k--)
361
                cmdline_len++;
362
              /* Escape the qote character.  */
363
              cmdline_len++;
364
            }
365
        }
366
      /* Trailing backslashes also need to be escaped because they will be
367
         followed by the terminating quote.  */
368
      for (k = j - 1; k >= 0 && argv[i][k] == '\\'; k--)
369
        cmdline_len++;
370
      cmdline_len += j;
371
      cmdline_len += 3;  /* for leading and trailing quotes and space */
372
    }
373
  cmdline = XNEWVEC (char, cmdline_len);
374
  p = cmdline;
375
  for (i = 0; argv[i]; i++)
376
    {
377
      *p++ = '"';
378
      for (j = 0; argv[i][j]; j++)
379
        {
380
          if (argv[i][j] == '"')
381
            {
382
              for (k = j - 1; k >= 0 && argv[i][k] == '\\'; k--)
383
                *p++ = '\\';
384
              *p++ = '\\';
385
            }
386
          *p++ = argv[i][j];
387
        }
388
      for (k = j - 1; k >= 0 && argv[i][k] == '\\'; k--)
389
        *p++ = '\\';
390
      *p++ = '"';
391
      *p++ = ' ';
392
    }
393
  p[-1] = '\0';
394
  return cmdline;
395
}
396
 
397
/* We'll try the passed filename with all the known standard
398
   extensions, and then without extension.  We try no extension
399
   last so that we don't try to run some random extension-less
400
   file that might be hanging around.  We try both extension
401
   and no extension so that we don't need any fancy logic
402
   to determine if a file has extension.  */
403
static const char *const
404
std_suffixes[] = {
405
  ".com",
406
  ".exe",
407
  ".bat",
408
  ".cmd",
409
  "",
410
 
411
};
412
 
413
/* Returns the full path to PROGRAM.  If SEARCH is true, look for
414
   PROGRAM in each directory in PATH.  */
415
 
416
static char *
417
find_executable (const char *program, BOOL search)
418
{
419
  char *full_executable;
420
  char *e;
421
  size_t fe_len;
422
  const char *path = 0;
423
  const char *const *ext;
424
  const char *p, *q;
425
  size_t proglen = strlen (program);
426
  int has_slash = (strchr (program, '/') || strchr (program, '\\'));
427
  HANDLE h;
428
 
429
  if (has_slash)
430
    search = FALSE;
431
 
432
  if (search)
433
    path = getenv ("PATH");
434
  if (!path)
435
    path = "";
436
 
437
  fe_len = 0;
438
  for (p = path; *p; p = q)
439
    {
440
      q = p;
441
      while (*q != ';' && *q != '\0')
442
        q++;
443
      if ((size_t)(q - p) > fe_len)
444
        fe_len = q - p;
445
      if (*q == ';')
446
        q++;
447
    }
448
  fe_len = fe_len + 1 + proglen + 5 /* space for extension */;
449
  full_executable = XNEWVEC (char, fe_len);
450
 
451
  p = path;
452
  do
453
    {
454
      q = p;
455
      while (*q != ';' && *q != '\0')
456
        q++;
457
 
458
      e = full_executable;
459
      memcpy (e, p, q - p);
460
      e += (q - p);
461
      if (q - p)
462
        *e++ = '\\';
463
      strcpy (e, program);
464
 
465
      if (*q == ';')
466
        q++;
467
 
468
      for (e = full_executable; *e; e++)
469
        if (*e == '/')
470
          *e = '\\';
471
 
472
      /* At this point, e points to the terminating NUL character for
473
         full_executable.  */
474
      for (ext = std_suffixes; *ext; ext++)
475
        {
476
          /* Remove any current extension.  */
477
          *e = '\0';
478
          /* Add the new one.  */
479
          strcat (full_executable, *ext);
480
 
481
          /* Attempt to open this file.  */
482
          h = CreateFile (full_executable, GENERIC_READ,
483
                          FILE_SHARE_READ | FILE_SHARE_WRITE,
484
                          0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
485
          if (h != INVALID_HANDLE_VALUE)
486
            goto found;
487
        }
488
      p = q;
489
    }
490
  while (*p);
491
  free (full_executable);
492
  return 0;
493
 
494
 found:
495
  CloseHandle (h);
496
  return full_executable;
497
}
498
 
499
/* Low-level process creation function and helper.  */
500
 
501
static int
502
env_compare (const void *a_ptr, const void *b_ptr)
503
{
504
  const char *a;
505
  const char *b;
506
  unsigned char c1;
507
  unsigned char c2;
508
 
509
  a = *(const char **) a_ptr;
510
  b = *(const char **) b_ptr;
511
 
512
  /* a and b will be of the form: VAR=VALUE
513
     We compare only the variable name part here using a case-insensitive
514
     comparison algorithm.  It might appear that in fact strcasecmp () can
515
     take the place of this whole function, and indeed it could, save for
516
     the fact that it would fail in cases such as comparing A1=foo and
517
     A=bar (because 1 is less than = in the ASCII character set).
518
     (Environment variables containing no numbers would work in such a
519
     scenario.)  */
520
 
521
  do
522
    {
523
      c1 = (unsigned char) tolower (*a++);
524
      c2 = (unsigned char) tolower (*b++);
525
 
526
      if (c1 == '=')
527
        c1 = '\0';
528
 
529
      if (c2 == '=')
530
        c2 = '\0';
531
    }
532
  while (c1 == c2 && c1 != '\0');
533
 
534
  return c1 - c2;
535
}
536
 
537
/* Execute a Windows executable as a child process.  This will fail if the
538
 * target is not actually an executable, such as if it is a shell script. */
539
 
540
static pid_t
541
win32_spawn (const char *executable,
542
             BOOL search,
543
             char *const *argv,
544
             char *const *env, /* array of strings of the form: VAR=VALUE */
545
             DWORD dwCreationFlags,
546
             LPSTARTUPINFO si,
547
             LPPROCESS_INFORMATION pi)
548
{
549
  char *full_executable;
550
  char *cmdline;
551
  char **env_copy;
552
  char *env_block = NULL;
553
 
554
  full_executable = NULL;
555
  cmdline = NULL;
556
 
557
  if (env)
558
    {
559
      int env_size;
560
 
561
      /* Count the number of environment bindings supplied.  */
562
      for (env_size = 0; env[env_size]; env_size++)
563
        continue;
564
 
565
      /* Assemble an environment block, if required.  This consists of
566
         VAR=VALUE strings juxtaposed (with one null character between each
567
         pair) and an additional null at the end.  */
568
      if (env_size > 0)
569
        {
570
          int var;
571
          int total_size = 1; /* 1 is for the final null.  */
572
          char *bufptr;
573
 
574
          /* Windows needs the members of the block to be sorted by variable
575
             name.  */
576
          env_copy = (char **) alloca (sizeof (char *) * env_size);
577
          memcpy (env_copy, env, sizeof (char *) * env_size);
578
          qsort (env_copy, env_size, sizeof (char *), env_compare);
579
 
580
          for (var = 0; var < env_size; var++)
581
            total_size += strlen (env[var]) + 1;
582
 
583
          env_block = XNEWVEC (char, total_size);
584
          bufptr = env_block;
585
          for (var = 0; var < env_size; var++)
586
            bufptr = stpcpy (bufptr, env_copy[var]) + 1;
587
 
588
          *bufptr = '\0';
589
        }
590
    }
591
 
592
  full_executable = find_executable (executable, search);
593
  if (!full_executable)
594
    goto error;
595
  cmdline = argv_to_cmdline (argv);
596
  if (!cmdline)
597
    goto error;
598
 
599
  /* Create the child process.  */
600
  if (!CreateProcess (full_executable, cmdline,
601
                      /*lpProcessAttributes=*/NULL,
602
                      /*lpThreadAttributes=*/NULL,
603
                      /*bInheritHandles=*/TRUE,
604
                      dwCreationFlags,
605
                      (LPVOID) env_block,
606
                      /*lpCurrentDirectory=*/NULL,
607
                      si,
608
                      pi))
609
    {
610
      if (env_block)
611
        free (env_block);
612
 
613
      free (full_executable);
614
 
615
      return (pid_t) -1;
616
    }
617
 
618
  /* Clean up.  */
619
  CloseHandle (pi->hThread);
620
  free (full_executable);
621
  if (env_block)
622
    free (env_block);
623
 
624
  return (pid_t) pi->hProcess;
625
 
626
 error:
627
  if (env_block)
628
    free (env_block);
629
  if (cmdline)
630
    free (cmdline);
631
  if (full_executable)
632
    free (full_executable);
633
 
634
  return (pid_t) -1;
635
}
636
 
637
/* Spawn a script.  This simulates the Unix script execution mechanism.
638
   This function is called as a fallback if win32_spawn fails. */
639
 
640
static pid_t
641
spawn_script (const char *executable, char *const *argv,
642
              char* const *env,
643
              DWORD dwCreationFlags,
644
              LPSTARTUPINFO si,
645
              LPPROCESS_INFORMATION pi)
646
{
647
  pid_t pid = (pid_t) -1;
648
  int save_errno = errno;
649
  int fd = _open (executable, _O_RDONLY);
650
 
651
  /* Try to open script, check header format, extract interpreter path,
652
     and spawn script using that interpretter. */
653
  if (fd >= 0)
654
    {
655
      char buf[MAX_PATH + 5];
656
      int len = _read (fd, buf, sizeof (buf) - 1);
657
      _close (fd);
658
      if (len > 3)
659
        {
660
          char *eol;
661
          buf[len] = '\0';
662
          eol = strchr (buf, '\n');
663
          if (eol && strncmp (buf, "#!", 2) == 0)
664
            {
665
 
666
              /* Header format is OK. */
667
              char *executable1;
668
              int new_argc;
669
              const char **avhere;
670
 
671
              /* Extract interpreter path. */
672
              do
673
                *eol = '\0';
674
              while (*--eol == '\r' || *eol == ' ' || *eol == '\t');
675
              for (executable1 = buf + 2; *executable1 == ' ' || *executable1 == '\t'; executable1++)
676
                continue;
677
              backslashify (executable1);
678
 
679
              /* Duplicate argv, prepending the interpreter path. */
680
              new_argc = argv_to_argc (argv) + 1;
681
              avhere = XNEWVEC (const char *, new_argc + 1);
682
              *avhere = executable1;
683
              memcpy (avhere + 1, argv, new_argc * sizeof(*argv));
684
              argv = (char *const *)avhere;
685
 
686
              /* Spawn the child. */
687
#ifndef USE_MINGW_MSYS
688
              executable = strrchr (executable1, '\\') + 1;
689
              if (!executable)
690
                executable = executable1;
691
              pid = win32_spawn (executable, TRUE, argv, env,
692
                                 dwCreationFlags, si, pi);
693
#else
694
              if (strchr (executable1, '\\') == NULL)
695
                pid = win32_spawn (executable1, TRUE, argv, env,
696
                                   dwCreationFlags, si, pi);
697
              else if (executable1[0] != '\\')
698
                pid = win32_spawn (executable1, FALSE, argv, env,
699
                                   dwCreationFlags, si, pi);
700
              else
701
                {
702
                  const char *newex = mingw_rootify (executable1);
703
                  *avhere = newex;
704
                  pid = win32_spawn (newex, FALSE, argv, env,
705
                                     dwCreationFlags, si, pi);
706
                  if (executable1 != newex)
707
                    free ((char *) newex);
708
                  if (pid == (pid_t) -1)
709
                    {
710
                      newex = msys_rootify (executable1);
711
                      if (newex != executable1)
712
                        {
713
                          *avhere = newex;
714
                          pid = win32_spawn (newex, FALSE, argv, env,
715
                                             dwCreationFlags, si, pi);
716
                          free ((char *) newex);
717
                        }
718
                    }
719
                }
720
#endif
721
              free (avhere);
722
            }
723
        }
724
    }
725
  if (pid == (pid_t) -1)
726
    errno = save_errno;
727
  return pid;
728
}
729
 
730
/* Execute a child.  */
731
 
732
static pid_t
733
pex_win32_exec_child (struct pex_obj *obj ATTRIBUTE_UNUSED, int flags,
734
                      const char *executable, char * const * argv,
735
                      char* const* env,
736
                      int in, int out, int errdes,
737
                      int toclose ATTRIBUTE_UNUSED,
738
                      const char **errmsg,
739
                      int *err)
740
{
741
  pid_t pid;
742
  HANDLE stdin_handle;
743
  HANDLE stdout_handle;
744
  HANDLE stderr_handle;
745
  DWORD dwCreationFlags;
746
  OSVERSIONINFO version_info;
747
  STARTUPINFO si;
748
  PROCESS_INFORMATION pi;
749
  int orig_out, orig_in, orig_err;
750
  BOOL separate_stderr = !(flags & PEX_STDERR_TO_STDOUT);
751
 
752
  /* Ensure we have inheritable descriptors to pass to the child, and close the
753
     original descriptors.  */
754
  orig_in = in;
755
  in = _dup (orig_in);
756
  if (orig_in != STDIN_FILENO)
757
    _close (orig_in);
758
 
759
  orig_out = out;
760
  out = _dup (orig_out);
761
  if (orig_out != STDOUT_FILENO)
762
    _close (orig_out);
763
 
764
  if (separate_stderr)
765
    {
766
      orig_err = errdes;
767
      errdes = _dup (orig_err);
768
      if (orig_err != STDERR_FILENO)
769
        _close (orig_err);
770
    }
771
 
772
  stdin_handle = INVALID_HANDLE_VALUE;
773
  stdout_handle = INVALID_HANDLE_VALUE;
774
  stderr_handle = INVALID_HANDLE_VALUE;
775
 
776
  stdin_handle = (HANDLE) _get_osfhandle (in);
777
  stdout_handle = (HANDLE) _get_osfhandle (out);
778
  if (separate_stderr)
779
    stderr_handle = (HANDLE) _get_osfhandle (errdes);
780
  else
781
    stderr_handle = stdout_handle;
782
 
783
  /* Determine the version of Windows we are running on.  */
784
  version_info.dwOSVersionInfoSize = sizeof (version_info);
785
  GetVersionEx (&version_info);
786
  if (version_info.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS)
787
    /* On Windows 95/98/ME the CREATE_NO_WINDOW flag is not
788
       supported, so we cannot avoid creating a console window.  */
789
    dwCreationFlags = 0;
790
  else
791
    {
792
      HANDLE conout_handle;
793
 
794
      /* Determine whether or not we have an associated console.  */
795
      conout_handle = CreateFile("CONOUT$",
796
                                 GENERIC_WRITE,
797
                                 FILE_SHARE_WRITE,
798
                                 /*lpSecurityAttributes=*/NULL,
799
                                 OPEN_EXISTING,
800
                                 FILE_ATTRIBUTE_NORMAL,
801
                                 /*hTemplateFile=*/NULL);
802
      if (conout_handle == INVALID_HANDLE_VALUE)
803
        /* There is no console associated with this process.  Since
804
           the child is a console process, the OS would normally
805
           create a new console Window for the child.  Since we'll be
806
           redirecting the child's standard streams, we do not need
807
           the console window.  */
808
        dwCreationFlags = CREATE_NO_WINDOW;
809
      else
810
        {
811
          /* There is a console associated with the process, so the OS
812
             will not create a new console.  And, if we use
813
             CREATE_NO_WINDOW in this situation, the child will have
814
             no associated console.  Therefore, if the child's
815
             standard streams are connected to the console, the output
816
             will be discarded.  */
817
          CloseHandle(conout_handle);
818
          dwCreationFlags = 0;
819
        }
820
    }
821
 
822
  /* Since the child will be a console process, it will, by default,
823
     connect standard input/output to its console.  However, we want
824
     the child to use the handles specifically designated above.  In
825
     addition, if there is no console (such as when we are running in
826
     a Cygwin X window), then we must redirect the child's
827
     input/output, as there is no console for the child to use.  */
828
  memset (&si, 0, sizeof (si));
829
  si.cb = sizeof (si);
830
  si.dwFlags = STARTF_USESTDHANDLES;
831
  si.hStdInput = stdin_handle;
832
  si.hStdOutput = stdout_handle;
833
  si.hStdError = stderr_handle;
834
 
835
  /* Create the child process.  */
836
  pid = win32_spawn (executable, (flags & PEX_SEARCH) != 0,
837
                     argv, env, dwCreationFlags, &si, &pi);
838
  if (pid == (pid_t) -1)
839
    pid = spawn_script (executable, argv, env, dwCreationFlags,
840
                        &si, &pi);
841
  if (pid == (pid_t) -1)
842
    {
843
      *err = ENOENT;
844
      *errmsg = "CreateProcess";
845
    }
846
 
847
  /* Close the standard input, standard output and standard error handles
848
     in the parent.  */
849
 
850
  _close (in);
851
  _close (out);
852
  if (separate_stderr)
853
    _close (errdes);
854
 
855
  return pid;
856
}
857
 
858
/* Wait for a child process to complete.  MS CRTDLL doesn't return
859
   enough information in status to decide if the child exited due to a
860
   signal or not, rather it simply returns an integer with the exit
861
   code of the child; eg., if the child exited with an abort() call
862
   and didn't have a handler for SIGABRT, it simply returns with
863
   status == 3.  We fix the status code to conform to the usual WIF*
864
   macros.  Note that WIFSIGNALED will never be true under CRTDLL. */
865
 
866
static pid_t
867
pex_win32_wait (struct pex_obj *obj ATTRIBUTE_UNUSED, pid_t pid,
868
                int *status, struct pex_time *time, int done ATTRIBUTE_UNUSED,
869
                const char **errmsg, int *err)
870
{
871
  DWORD termstat;
872
  HANDLE h;
873
 
874
  if (time != NULL)
875
    memset (time, 0, sizeof *time);
876
 
877
  h = (HANDLE) pid;
878
 
879
  /* FIXME: If done is non-zero, we should probably try to kill the
880
     process.  */
881
  if (WaitForSingleObject (h, INFINITE) != WAIT_OBJECT_0)
882
    {
883
      CloseHandle (h);
884
      *err = ECHILD;
885
      *errmsg = "WaitForSingleObject";
886
      return -1;
887
    }
888
 
889
  GetExitCodeProcess (h, &termstat);
890
  CloseHandle (h);
891
 
892
  /* A value of 3 indicates that the child caught a signal, but not
893
     which one.  Since only SIGABRT, SIGFPE and SIGINT do anything, we
894
     report SIGABRT.  */
895
  if (termstat == 3)
896
    *status = SIGABRT;
897
  else
898
    *status = (termstat & 0xff) << 8;
899
 
900
  return 0;
901
}
902
 
903
/* Create a pipe.  */
904
 
905
static int
906
pex_win32_pipe (struct pex_obj *obj ATTRIBUTE_UNUSED, int *p,
907
                int binary)
908
{
909
  return _pipe (p, 256, (binary ? _O_BINARY : _O_TEXT) | _O_NOINHERIT);
910
}
911
 
912
/* Get a FILE pointer to read from a file descriptor.  */
913
 
914
static FILE *
915
pex_win32_fdopenr (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd,
916
                   int binary)
917
{
918
  HANDLE h = (HANDLE) _get_osfhandle (fd);
919
  if (h == INVALID_HANDLE_VALUE)
920
    return NULL;
921
  if (! SetHandleInformation (h, HANDLE_FLAG_INHERIT, 0))
922
    return NULL;
923
  return fdopen (fd, binary ? "rb" : "r");
924
}
925
 
926
static FILE *
927
pex_win32_fdopenw (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd,
928
                   int binary)
929
{
930
  HANDLE h = (HANDLE) _get_osfhandle (fd);
931
  if (h == INVALID_HANDLE_VALUE)
932
    return NULL;
933
  if (! SetHandleInformation (h, HANDLE_FLAG_INHERIT, 0))
934
    return NULL;
935
  return fdopen (fd, binary ? "wb" : "w");
936
}
937
 
938
#ifdef MAIN
939
#include <stdio.h>
940
 
941
int
942
main (int argc ATTRIBUTE_UNUSED, char **argv)
943
{
944
  char const *errmsg;
945
  int err;
946
  argv++;
947
  printf ("%ld\n", (long) pex_win32_exec_child (NULL, PEX_SEARCH, argv[0], argv, NULL, 0, 0, 1, 2, &errmsg, &err));
948
  exit (0);
949
}
950
#endif

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.