Changeset 3138 for vendor/gnumake/current/w32

Timestamp:

Mar 12, 2018, 8:32:29 PM (7 years ago)

Author:

bird

Message:

Imported make 4.2.1 (2e55f5e4abdc0e38c1d64be703b446695e70b3b6) from ​https://git.savannah.gnu.org/git/make.git.

Location:

vendor/gnumake/current/w32

Files:

• .cvsignore (deleted)
• Makefile.am (modified) (2 diffs)
• compat/dirent.c (modified) (7 diffs)
• compat/posixfcn.c (added)
• include/dirent.h (modified) (2 diffs)
• include/dlfcn.h (added)
• include/pathstuff.h (modified) (1 diff)
• include/sub_proc.h (modified) (4 diffs)
• include/w32err.h (modified) (2 diffs)
• pathstuff.c (modified) (5 diffs)
• subproc/NMakefile (modified) (1 diff)
• subproc/build.bat (deleted)
• subproc/misc.c (modified) (2 diffs)
• subproc/proc.h (modified) (2 diffs)
• subproc/sub_proc.c (modified) (34 diffs)
• subproc/w32err.c (modified) (3 diffs)
• w32os.c (added)

vendor/gnumake/current/w32/Makefile.am

@@ -1 +1 @@
 # Makefile.am to create libw32.a for mingw32 host.
-# Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
-# 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+# Copyright (C) 1997-2016 Free Software Foundation, Inc.
 # This file is part of GNU Make.
 #
@@ -17 +16 @@
 # this program.  If not, see <http://www.gnu.org/licenses/>.
 
+AUTOMAKE_OPTIONS = subdir-objects
+
 noinst_LIBRARIES = libw32.a
 
 libw32_a_SOURCES =  subproc/misc.c subproc/sub_proc.c subproc/w32err.c \
-                    pathstuff.c
+                    compat/posixfcn.c pathstuff.c w32os.c
 
-libw32_a_CPPFLAGS = -I$(srcdir)/include -I$(srcdir)/subproc -I$(top_srcdir)
+libw32_a_CPPFLAGS = -I$(srcdir)/include -I$(srcdir)/subproc -I$(top_srcdir) \
+                    -I$(top_srcdir)/glob

vendor/gnumake/current/w32/compat/dirent.c

@@ -1 +1 @@
 /* Directory entry code for Window platforms.
-Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
-2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+Copyright (C) 1996-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 
@@ -29 +28 @@
 opendir(const char* pDirName)
 {
-        struct stat sb;
-        DIR*    pDir;
-        char*   pEndDirName;
-        int     nBufferLen;
-
-        /* sanity checks */
-        if (!pDirName) {
-                errno = EINVAL;
-                return NULL;
-        }
-        if (stat(pDirName, &sb) != 0) {
-                errno = ENOENT;
-                return NULL;
-        }
-        if ((sb.st_mode & S_IFMT) != S_IFDIR) {
-                errno = ENOTDIR;
-                return NULL;
-        }
-
-        /* allocate a DIR structure to return */
-        pDir = (DIR *) malloc(sizeof (DIR));
-
-        if (!pDir)
-                return NULL;
-
-        /* input directory name length */
-        nBufferLen = strlen(pDirName);
-
-        /* copy input directory name to DIR buffer */
-        strcpy(pDir->dir_pDirectoryName, pDirName);
-
-        /* point to end of the copied directory name */
-        pEndDirName = &pDir->dir_pDirectoryName[nBufferLen - 1];
-
-        /* if directory name did not end in '/' or '\', add '/' */
-        if ((*pEndDirName != '/') && (*pEndDirName != '\\')) {
-                pEndDirName++;
-                *pEndDirName = '/';
-        }
-
-        /* now append the wildcard character to the buffer */
-        pEndDirName++;
-        *pEndDirName = '*';
-        pEndDirName++;
-        *pEndDirName = '\0';
-
-        /* other values defaulted */
-        pDir->dir_nNumFiles = 0;
-        pDir->dir_hDirHandle = INVALID_HANDLE_VALUE;
-        pDir->dir_ulCookie = __DIRENT_COOKIE;
-
-        return pDir;
+        struct stat sb;
+        DIR*    pDir;
+        char*   pEndDirName;
+        int     nBufferLen;
+
+        /* sanity checks */
+        if (!pDirName) {
+                errno = EINVAL;
+                return NULL;
+        }
+        if (stat(pDirName, &sb) != 0) {
+                errno = ENOENT;
+                return NULL;
+        }
+        if ((sb.st_mode & S_IFMT) != S_IFDIR) {
+                errno = ENOTDIR;
+                return NULL;
+        }
+
+        /* allocate a DIR structure to return */
+        pDir = (DIR *) malloc(sizeof (DIR));
+
+        if (!pDir)
+                return NULL;
+
+        /* input directory name length */
+        nBufferLen = strlen(pDirName);
+
+        /* copy input directory name to DIR buffer */
+        strcpy(pDir->dir_pDirectoryName, pDirName);
+
+        /* point to end of the copied directory name */
+        pEndDirName = &pDir->dir_pDirectoryName[nBufferLen - 1];
+
+        /* if directory name did not end in '/' or '\', add '/' */
+        if ((*pEndDirName != '/') && (*pEndDirName != '\\')) {
+                pEndDirName++;
+                *pEndDirName = '/';
+        }
+
+        /* now append the wildcard character to the buffer */
+        pEndDirName++;
+        *pEndDirName = '*';
+        pEndDirName++;
+        *pEndDirName = '\0';
+
+        /* other values defaulted */
+        pDir->dir_nNumFiles = 0;
+        pDir->dir_hDirHandle = INVALID_HANDLE_VALUE;
+        pDir->dir_ulCookie = __DIRENT_COOKIE;
+
+        return pDir;
 }
 
@@ -86 +85 @@
 closedir(DIR *pDir)
 {
-        /* got a valid pointer? */
-        if (!pDir) {
-                errno = EINVAL;
-                return;
-        }
-
-        /* sanity check that this is a DIR pointer */
-        if (pDir->dir_ulCookie != __DIRENT_COOKIE) {
-                errno = EINVAL;
-                return;
-        }
-
-        /* close the WINDOWS32 directory handle */
-        if (pDir->dir_hDirHandle != INVALID_HANDLE_VALUE)
-                FindClose(pDir->dir_hDirHandle);
-
-        free(pDir);
-
-        return;
+        /* got a valid pointer? */
+        if (!pDir) {
+                errno = EINVAL;
+                return;
+        }
+
+        /* sanity check that this is a DIR pointer */
+        if (pDir->dir_ulCookie != __DIRENT_COOKIE) {
+                errno = EINVAL;
+                return;
+        }
+
+        /* close the WINDOWS32 directory handle */
+        if (pDir->dir_hDirHandle != INVALID_HANDLE_VALUE)
+                FindClose(pDir->dir_hDirHandle);
+
+        free(pDir);
+
+        return;
 }
 
@@ -110 +109 @@
 readdir(DIR* pDir)
 {
-        WIN32_FIND_DATA wfdFindData;
-
-        if (!pDir) {
-                errno = EINVAL;
-                return NULL;
-        }
-
-        /* sanity check that this is a DIR pointer */
-        if (pDir->dir_ulCookie != __DIRENT_COOKIE) {
-                errno = EINVAL;
-                return NULL;
-        }
-
-        if (pDir->dir_nNumFiles == 0) {
-                pDir->dir_hDirHandle = FindFirstFile(pDir->dir_pDirectoryName, &wfdFindData);
-                if (pDir->dir_hDirHandle == INVALID_HANDLE_VALUE)
-                        return NULL;
-        } else if (!FindNextFile(pDir->dir_hDirHandle, &wfdFindData))
-                        return NULL;
-
-        /* bump count for next call to readdir() or telldir() */
-        pDir->dir_nNumFiles++;
-
-        /* fill in struct dirent values */
-        pDir->dir_sdReturn.d_ino = (ino_t)-1;
-        strcpy(pDir->dir_sdReturn.d_name, wfdFindData.cFileName);
-
-        return &pDir->dir_sdReturn;
+        WIN32_FIND_DATA wfdFindData;
+
+        if (!pDir) {
+                errno = EINVAL;
+                return NULL;
+        }
+
+        /* sanity check that this is a DIR pointer */
+        if (pDir->dir_ulCookie != __DIRENT_COOKIE) {
+                errno = EINVAL;
+                return NULL;
+        }
+
+        if (pDir->dir_nNumFiles == 0) {
+                pDir->dir_hDirHandle = FindFirstFile(pDir->dir_pDirectoryName, &wfdFindData);
+                if (pDir->dir_hDirHandle == INVALID_HANDLE_VALUE)
+                        return NULL;
+        } else if (!FindNextFile(pDir->dir_hDirHandle, &wfdFindData))
+                        return NULL;
+
+        /* bump count for next call to readdir() or telldir() */
+        pDir->dir_nNumFiles++;
+
+        /* fill in struct dirent values */
+        pDir->dir_sdReturn.d_ino = (ino_t)-1;
+        strcpy(pDir->dir_sdReturn.d_name, wfdFindData.cFileName);
+
+        return &pDir->dir_sdReturn;
 }
 
@@ -143 +142 @@
 rewinddir(DIR* pDir)
 {
-        if (!pDir) {
-                errno = EINVAL;
-                return;
-        }
-
-        /* sanity check that this is a DIR pointer */
-        if (pDir->dir_ulCookie != __DIRENT_COOKIE) {
-                errno = EINVAL;
-                return;
-        }
-
-        /* close the WINDOWS32 directory handle */
-        if (pDir->dir_hDirHandle != INVALID_HANDLE_VALUE)
-                if (!FindClose(pDir->dir_hDirHandle))
-                        errno = EBADF;
-
-        /* reset members which control readdir() */
-        pDir->dir_hDirHandle = INVALID_HANDLE_VALUE;
-        pDir->dir_nNumFiles = 0;
-
-        return;
+        if (!pDir) {
+                errno = EINVAL;
+                return;
+        }
+
+        /* sanity check that this is a DIR pointer */
+        if (pDir->dir_ulCookie != __DIRENT_COOKIE) {
+                errno = EINVAL;
+                return;
+        }
+
+        /* close the WINDOWS32 directory handle */
+        if (pDir->dir_hDirHandle != INVALID_HANDLE_VALUE)
+                if (!FindClose(pDir->dir_hDirHandle))
+                        errno = EBADF;
+
+        /* reset members which control readdir() */
+        pDir->dir_hDirHandle = INVALID_HANDLE_VALUE;
+        pDir->dir_nNumFiles = 0;
+
+        return;
 }
 
@@ -169 +168 @@
 telldir(DIR* pDir)
 {
-        if (!pDir) {
-                errno = EINVAL;
-                return -1;
-        }
-
-        /* sanity check that this is a DIR pointer */
-        if (pDir->dir_ulCookie != __DIRENT_COOKIE) {
-                errno = EINVAL;
-                return -1;
-        }
-
-        /* return number of times readdir() called */
-        return pDir->dir_nNumFiles;
+        if (!pDir) {
+                errno = EINVAL;
+                return -1;
+        }
+
+        /* sanity check that this is a DIR pointer */
+        if (pDir->dir_ulCookie != __DIRENT_COOKIE) {
+                errno = EINVAL;
+                return -1;
+        }
+
+        /* return number of times readdir() called */
+        return pDir->dir_nNumFiles;
 }
 
@@ -187 +186 @@
 seekdir(DIR* pDir, long nPosition)
 {
-        if (!pDir)
-                return;
-
-        /* sanity check that this is a DIR pointer */
-        if (pDir->dir_ulCookie != __DIRENT_COOKIE)
-                return;
-
-        /* go back to beginning of directory */
-        rewinddir(pDir);
-
-        /* loop until we have found position we care about */
-        for (--nPosition; nPosition && readdir(pDir); nPosition--);
-
-        /* flag invalid nPosition value */
-        if (nPosition)
-                errno = EINVAL;
-
-        return;
-}
+        if (!pDir)
+                return;
+
+        /* sanity check that this is a DIR pointer */
+        if (pDir->dir_ulCookie != __DIRENT_COOKIE)
+                return;
+
+        /* go back to beginning of directory */
+        rewinddir(pDir);
+
+        /* loop until we have found position we care about */
+        for (--nPosition; nPosition && readdir(pDir); nPosition--);
+
+        /* flag invalid nPosition value */
+        if (nPosition)
+                errno = EINVAL;
+
+        return;
+}

vendor/gnumake/current/w32/include/dirent.h

@@ -1 +1 @@
 /* Windows version of dirent.h
-Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
-2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+Copyright (C) 1996-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 
@@ -38 +37 @@
 struct dirent
 {
-  ino_t d_ino;                  /* unused - no equivalent on WINDOWS32 */
+  ino_t d_ino;                  /* unused - no equivalent on WINDOWS32 */
   char d_name[NAME_MAX+1];
 };
 
 typedef struct dir_struct {
-        ULONG   dir_ulCookie;
-        HANDLE  dir_hDirHandle;
-        DWORD   dir_nNumFiles;
-        char    dir_pDirectoryName[NAME_MAX+1];
-        struct dirent dir_sdReturn;
+        ULONG   dir_ulCookie;
+        HANDLE  dir_hDirHandle;
+        DWORD   dir_nNumFiles;
+        char    dir_pDirectoryName[NAME_MAX+1];
+        struct dirent dir_sdReturn;
 } DIR;
 

vendor/gnumake/current/w32/include/pathstuff.h

@@ -1 +1 @@
 /* Definitions for Windows path manipulation.
-Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
-2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+Copyright (C) 1996-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 

vendor/gnumake/current/w32/include/sub_proc.h

@@ -1 +1 @@
 /* Definitions for Windows process invocation.
-Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
-2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+Copyright (C) 1996-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 
@@ -22 +21 @@
  * Component Name:
  *
- * $Date: 2010/07/13 01:20:43 $
+ * $Date$
  *
- * $Source: /sources/make/make/w32/include/sub_proc.h,v $
+ * $Source$
  *
- * $Id: sub_proc.h,v 1.12 2010/07/13 01:20:43 psmith Exp $
+ * $Id$
  */
 
@@ -34 +33 @@
 EXTERN_DECL(HANDLE process_init, (VOID_DECL));
 EXTERN_DECL(HANDLE process_init_fd, (HANDLE stdinh, HANDLE stdouth,
-        HANDLE stderrh));
+                                     HANDLE stderrh));
 EXTERN_DECL(long process_begin, (HANDLE proc, char **argv, char **envp,
-        char *exec_path, char *as_user));
+                                 char *exec_path, char *as_user));
 EXTERN_DECL(long process_pipe_io, (HANDLE proc, char *stdin_data,
-        int stdin_data_len));
+                                   int stdin_data_len));
 EXTERN_DECL(long process_file_io, (HANDLE proc));
 EXTERN_DECL(void process_cleanup, (HANDLE proc));
-EXTERN_DECL(HANDLE process_wait_for_any, (VOID_DECL));
+EXTERN_DECL(HANDLE process_wait_for_any, (int block, DWORD* pdwWaitStatus));
 EXTERN_DECL(void process_register, (HANDLE proc));
-EXTERN_DECL(HANDLE process_easy, (char** argv, char** env));
+EXTERN_DECL(HANDLE process_easy, (char** argv, char** env,
+                                  int outfd, int errfd));
 EXTERN_DECL(BOOL process_kill, (HANDLE proc, int signal));
 EXTERN_DECL(int process_used_slots, (VOID_DECL));
+EXTERN_DECL(DWORD process_set_handles, (HANDLE *handles));
 
 /* support routines */
@@ -57 +58 @@
 EXTERN_DECL(int process_errcnt, (HANDLE proc));
 EXTERN_DECL(void process_pipes, (HANDLE proc, int pipes[3]));
+EXTERN_DECL(void process_noinherit, (int fildes));
 
 #endif

vendor/gnumake/current/w32/include/w32err.h

@@ -1 +1 @@
 /* Definitions for Windows error handling.
-Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
-2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+Copyright (C) 1996-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 
@@ -23 +22 @@
 #endif
 
-EXTERN_DECL(char * map_windows32_error_to_string, (DWORD error));
+EXTERN_DECL(const char * map_windows32_error_to_string, (DWORD error));
 
 #endif /* !_W32ERR_H */

vendor/gnumake/current/w32/pathstuff.c

@@ -1 +1 @@
 /* Path conversion for Windows pathnames.
-Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
-2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+Copyright (C) 1996-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 
@@ -16 +15 @@
 this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
-#include "make.h"
+#include "makeint.h"
 #include <string.h>
 #include <stdlib.h>
@@ -29 +28 @@
     char *etok;            /* token separator for old Path */
 
-        /*
-         * Convert all spaces to delimiters. Note that pathnames which
-         * contain blanks get trounced here. Use 8.3 format as a workaround.
-         */
-        for (etok = Path; etok && *etok; etok++)
-                if (isblank ((unsigned char) *etok))
-                        *etok = to_delim;
-
-        return (convert_Path_to_windows32(Path, to_delim));
+        /*
+         * Convert all spaces to delimiters. Note that pathnames which
+         * contain blanks get trounced here. Use 8.3 format as a workaround.
+         */
+        for (etok = Path; etok && *etok; etok++)
+                if (ISBLANK ((unsigned char) *etok))
+                        *etok = to_delim;
+
+        return (convert_Path_to_windows32(Path, to_delim));
 }
 
@@ -81 +80 @@
                 *etok = to_delim;
                 p = ++etok;
-            } else
+            } else
                 p += strlen(p);
         } else {
@@ -116 +115 @@
 getcwd_fs(char* buf, int len)
 {
-        char *p = getcwd(buf, len);
-
-        if (p) {
-                char *q = w32ify(buf, 0);
-                strncpy(buf, q, len);
-        }
-
-        return p;
+        char *p = getcwd(buf, len);
+
+        if (p) {
+                char *q = w32ify(buf, 0);
+                strncpy(buf, q, len);
+        }
+
+        return p;
 }
 

vendor/gnumake/current/w32/subproc/NMakefile

@@ -1 @@
-# NOTE: If you have no `make' program at all to process this makefile, run
-# `build.bat' instead.
+# NOTE: If you have no 'make' program at all to process this makefile, run
+# 'build.bat' instead.
 #
-# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
-# 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+# Copyright (C) 1996-2016 Free Software Foundation, Inc.
 # This file is part of GNU Make.
 #

vendor/gnumake/current/w32/subproc/misc.c

@@ -1 +1 @@
 /* Process handling for Windows
-Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
-2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+Copyright (C) 1996-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 
@@ -26 +25 @@
 /*
  * Description:  Convert a NULL string terminated UNIX environment block to
- *              an environment block suitable for a windows32 system call
+ *              an environment block suitable for a windows32 system call
  *
  * Returns:  TRUE= success, FALSE=fail
  *
  * Notes/Dependencies:  the environment block is sorted in case-insensitive
- *      order, is double-null terminated, and is a char *, not a char **
+ *      order, is double-null terminated, and is a char *, not a char **
  */
 int _cdecl compare(const void *a1, const void *a2)
 {
-        return _stricoll(*((char**)a1),*((char**)a2));
+        return _stricoll(*((char**)a1),*((char**)a2));
 }
 bool_t
-arr2envblk(char **arr, char **envblk_out)
+arr2envblk(char **arr, char **envblk_out, int *envsize_needed)
 {
-        char **tmp;
-        int size_needed;
-        int arrcnt;
-        char *ptr;
+        char **tmp;
+        int size_needed;
+        int arrcnt;
+        char *ptr;
 
-        arrcnt = 0;
-        while (arr[arrcnt]) {
-                arrcnt++;
-        }
+        arrcnt = 0;
+        while (arr[arrcnt]) {
+                arrcnt++;
+        }
 
-        tmp = (char**) calloc(arrcnt + 1, sizeof(char *));
-        if (!tmp) {
-                return FALSE;
-        }
+        tmp = (char**) calloc(arrcnt + 1, sizeof(char *));
+        if (!tmp) {
+                return FALSE;
+        }
 
-        arrcnt = 0;
-        size_needed = 0;
-        while (arr[arrcnt]) {
-                tmp[arrcnt] = arr[arrcnt];
-                size_needed += strlen(arr[arrcnt]) + 1;
-                arrcnt++;
-        }
-        size_needed++;
+        arrcnt = 0;
+        size_needed = *envsize_needed = 0;
+        while (arr[arrcnt]) {
+                tmp[arrcnt] = arr[arrcnt];
+                size_needed += strlen(arr[arrcnt]) + 1;
+                arrcnt++;
+        }
+        size_needed++;
+        *envsize_needed = size_needed;
 
-        qsort((void *) tmp, (size_t) arrcnt, sizeof (char*), compare);
+        qsort((void *) tmp, (size_t) arrcnt, sizeof (char*), compare);
 
-        ptr = *envblk_out = calloc(size_needed, 1);
-        if (!ptr) {
-                free(tmp);
-                return FALSE;
-        }
+        ptr = *envblk_out = calloc(size_needed, 1);
+        if (!ptr) {
+                free(tmp);
+                return FALSE;
+        }
 
-        arrcnt = 0;
-        while (tmp[arrcnt]) {
-                strcpy(ptr, tmp[arrcnt]);
-                ptr += strlen(tmp[arrcnt]) + 1;
-                arrcnt++;
-        }
+        arrcnt = 0;
+        while (tmp[arrcnt]) {
+                strcpy(ptr, tmp[arrcnt]);
+                ptr += strlen(tmp[arrcnt]) + 1;
+                arrcnt++;
+        }
 
-        free(tmp);
-        return TRUE;
+        free(tmp);
+        return TRUE;
 }

vendor/gnumake/current/w32/subproc/proc.h

@@ -1 +1 @@
 /* Definitions for Windows
-Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
-2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+Copyright (C) 1996-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 
@@ -21 +20 @@
 typedef int bool_t;
 
-#define E_SCALL         101
-#define E_IO            102
-#define E_NO_MEM        103
-#define E_FORK          104
+#define E_SCALL         101
+#define E_IO            102
+#define E_NO_MEM        103
+#define E_FORK          104
 
-extern bool_t arr2envblk(char **arr, char **envblk_out);
+extern bool_t arr2envblk(char **arr, char **envblk_out, int *envsize_needed);
 
 #endif

vendor/gnumake/current/w32/subproc/sub_proc.c

@@ -1 +1 @@
 /* Process handling for Windows.
-Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
-2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+Copyright (C) 1996-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 
@@ -19 +18 @@
 #include <stdlib.h>
 #include <stdio.h>
+#include <io.h>         /* for _get_osfhandle */
 #ifdef _MSC_VER
 # include <stddef.h>    /* for intptr_t */
@@ -24 +24 @@
 # include <stdint.h>
 #endif
+#include <string.h>
 #include <process.h>  /* for msvc _beginthreadex, _endthreadex */
 #include <signal.h>
 #include <windows.h>
 
+#include "makeint.h"
+#include "filedef.h"
+#include "variable.h"
 #include "sub_proc.h"
 #include "proc.h"
@@ -34 +38 @@
 
 static char *make_command_line(char *shell_name, char *exec_path, char **argv);
-extern char *xmalloc (unsigned int);
 
 typedef struct sub_process_t {
-        intptr_t sv_stdin[2];
-        intptr_t sv_stdout[2];
-        intptr_t sv_stderr[2];
-        int using_pipes;
-        char *inp;
-        DWORD incnt;
-        char * volatile outp;
-        volatile DWORD outcnt;
-        char * volatile errp;
-        volatile DWORD errcnt;
-        pid_t pid;
-        int exit_code;
-        int signal;
-        long last_err;
-        long lerrno;
+        intptr_t sv_stdin[2];
+        intptr_t sv_stdout[2];
+        intptr_t sv_stderr[2];
+        int using_pipes;
+        char *inp;
+        DWORD incnt;
+        char * volatile outp;
+        volatile DWORD outcnt;
+        char * volatile errp;
+        volatile DWORD errcnt;
+        pid_t pid;
+        int exit_code;
+        int signal;
+        long last_err;
+        long lerrno;
 } sub_process;
 
@@ -58 +61 @@
 static int proc_index = 0;
 static int fake_exits_pending = 0;
+
+
+/*
+ * Fill a HANDLE list with handles to wait for.
+ */
+DWORD
+process_set_handles(HANDLE *handles)
+{
+    DWORD count = 0;
+    int i;
+
+    /* Build array of handles to wait for */
+    for (i = 0; i < proc_index; i++) {
+        /* Don't wait on child processes that have already finished */
+        if (fake_exits_pending && proc_array[i]->exit_code)
+            continue;
+
+        handles[count++] = (HANDLE) proc_array[i]->pid;
+    }
+
+    return count;
+}
 
 /*
@@ -66 +91 @@
 process_adjust_wait_state(sub_process* pproc)
 {
-        int i;
-
-        if (!proc_index)
-                return;
-
-        for (i = 0; i < proc_index; i++)
-                if (proc_array[i]->pid == pproc->pid)
-                        break;
-
-        if (i < proc_index) {
-                proc_index--;
-                if (i != proc_index)
-                        memmove(&proc_array[i], &proc_array[i+1],
-                                (proc_index-i) * sizeof(sub_process*));
-                proc_array[proc_index] = NULL;
-        }
+        int i;
+
+        if (!proc_index)
+                return;
+
+        for (i = 0; i < proc_index; i++)
+                if (proc_array[i]->pid == pproc->pid)
+                        break;
+
+        if (i < proc_index) {
+                proc_index--;
+                if (i != proc_index)
+                        memmove(&proc_array[i], &proc_array[i+1],
+                                (proc_index-i) * sizeof(sub_process*));
+                proc_array[proc_index] = NULL;
+        }
 }
 
@@ -88 +113 @@
  */
 static sub_process *
-process_wait_for_any_private(void)
-{
-        HANDLE handles[MAXIMUM_WAIT_OBJECTS];
-        DWORD retval, which;
-        int i;
-
-        if (!proc_index)
-                return NULL;
-
-        /* build array of handles to wait for */
-        for (i = 0; i < proc_index; i++) {
-                handles[i] = (HANDLE) proc_array[i]->pid;
-
-                if (fake_exits_pending && proc_array[i]->exit_code)
-                        break;
-        }
-
-        /* wait for someone to exit */
-        if (!fake_exits_pending) {
-                retval = WaitForMultipleObjects(proc_index, handles, FALSE, INFINITE);
-                which = retval - WAIT_OBJECT_0;
-        } else {
-                fake_exits_pending--;
-                retval = !WAIT_FAILED;
-                which = i;
-        }
-
-        /* return pointer to process */
-        if (retval != WAIT_FAILED) {
-                sub_process* pproc = proc_array[which];
-                process_adjust_wait_state(pproc);
-                return pproc;
-        } else
-                return NULL;
+process_wait_for_any_private(int block, DWORD* pdwWaitStatus)
+{
+        HANDLE handles[MAXIMUM_WAIT_OBJECTS];
+        DWORD retval, which;
+        int i;
+
+        if (!proc_index)
+                return NULL;
+
+        /* build array of handles to wait for */
+        for (i = 0; i < proc_index; i++) {
+                handles[i] = (HANDLE) proc_array[i]->pid;
+
+                if (fake_exits_pending && proc_array[i]->exit_code)
+                        break;
+        }
+
+        /* wait for someone to exit */
+        if (!fake_exits_pending) {
+                retval = WaitForMultipleObjects(proc_index, handles, FALSE, (block ? INFINITE : 0));
+                which = retval - WAIT_OBJECT_0;
+        } else {
+                fake_exits_pending--;
+                retval = !WAIT_FAILED;
+                which = i;
+        }
+
+        /* If the pointer is not NULL, set the wait status result variable. */
+        if (pdwWaitStatus)
+            *pdwWaitStatus = retval;
+
+        /* return pointer to process */
+        if ((retval == WAIT_TIMEOUT) || (retval == WAIT_FAILED)) {
+                return NULL;
+        }
+        else {
+                sub_process* pproc = proc_array[which];
+                process_adjust_wait_state(pproc);
+                return pproc;
+        }
 }
 
@@ -130 +161 @@
 process_kill(HANDLE proc, int signal)
 {
-        sub_process* pproc = (sub_process*) proc;
-        pproc->signal = signal;
-        return (TerminateProcess((HANDLE) pproc->pid, signal));
+        sub_process* pproc = (sub_process*) proc;
+        pproc->signal = signal;
+        return (TerminateProcess((HANDLE) pproc->pid, signal));
 }
 
@@ -144 +175 @@
 process_register(HANDLE proc)
 {
-        if (proc_index < MAXIMUM_WAIT_OBJECTS)
-                proc_array[proc_index++] = (sub_process *) proc;
+        if (proc_index < MAXIMUM_WAIT_OBJECTS)
+                proc_array[proc_index++] = (sub_process *) proc;
 }
 
@@ -154 +185 @@
 process_used_slots(void)
 {
-        return proc_index;
+        return proc_index;
 }
 
@@ -162 +193 @@
  * you must do 1 of things:
  *
- *      x = process_easy(...);
+ *      x = process_easy(...);
  *
  * or
  *
- *      x = process_init_fd();
- *      process_register(x);
+ *      x = process_init_fd();
+ *      process_register(x);
  *
  * or
  *
- *      x = process_init();
- *      process_register(x);
+ *      x = process_init();
+ *      process_register(x);
  *
  * You must NOT then call process_pipe_io() because this function is
@@ -180 +211 @@
 
 HANDLE
-process_wait_for_any(void)
-{
-        sub_process* pproc = process_wait_for_any_private();
-
-        if (!pproc)
-                return NULL;
-        else {
-                /*
-                 * Ouch! can't tell caller if this fails directly. Caller
-                 * will have to use process_last_err()
+process_wait_for_any(int block, DWORD* pdwWaitStatus)
+{
+        sub_process* pproc = process_wait_for_any_private(block, pdwWaitStatus);
+
+        if (!pproc)
+                return NULL;
+        else {
+                /*
+                 * Ouch! can't tell caller if this fails directly. Caller
+                 * will have to use process_last_err()
                  */
-                (void) process_file_io(pproc);
-                return ((HANDLE) pproc);
-        }
+                (void) process_file_io(pproc);
+                return ((HANDLE) pproc);
+        }
 }
 
@@ -207 +238 @@
 {
         if (proc == INVALID_HANDLE_VALUE) return ERROR_INVALID_HANDLE;
-        return (((sub_process *)proc)->last_err);
+        return (((sub_process *)proc)->last_err);
 }
 
@@ -214 +245 @@
 {
         if (proc == INVALID_HANDLE_VALUE) return EXIT_FAILURE;
-        return (((sub_process *)proc)->exit_code);
+        return (((sub_process *)proc)->exit_code);
+}
+
+void
+process_noinherit(int fd)
+{
+  HANDLE fh = (HANDLE)_get_osfhandle(fd);
+
+  if (fh && fh != INVALID_HANDLE_VALUE)
+        SetHandleInformation(fh, HANDLE_FLAG_INHERIT, 0);
 }
 
@@ -227 +267 @@
 process_outbuf(HANDLE proc)
 {
-        return (((sub_process *)proc)->outp);
+        return (((sub_process *)proc)->outp);
 }
 
@@ -233 +273 @@
 process_errbuf(HANDLE proc)
 {
-        return (((sub_process *)proc)->errp);
+        return (((sub_process *)proc)->errp);
 }
 
@@ -239 +279 @@
 process_outcnt(HANDLE proc)
 {
-        return (((sub_process *)proc)->outcnt);
+        return (((sub_process *)proc)->outcnt);
 }
 
@@ -245 +285 @@
 process_errcnt(HANDLE proc)
 {
-        return (((sub_process *)proc)->errcnt);
+        return (((sub_process *)proc)->errcnt);
 }
 
@@ -251 +291 @@
 process_pipes(HANDLE proc, int pipes[3])
 {
-        pipes[0] = ((sub_process *)proc)->sv_stdin[0];
-        pipes[1] = ((sub_process *)proc)->sv_stdout[0];
-        pipes[2] = ((sub_process *)proc)->sv_stderr[0];
-        return;
+        pipes[0] = ((sub_process *)proc)->sv_stdin[0];
+        pipes[1] = ((sub_process *)proc)->sv_stdout[0];
+        pipes[2] = ((sub_process *)proc)->sv_stderr[0];
+        return;
 }
 */
 
-        HANDLE
+        HANDLE
 process_init()
 {
-        sub_process *pproc;
-        /*
-         * open file descriptors for attaching stdin/stdout/sterr
-         */
-        HANDLE stdin_pipes[2];
-        HANDLE stdout_pipes[2];
-        HANDLE stderr_pipes[2];
-        SECURITY_ATTRIBUTES inherit;
-        BYTE sd[SECURITY_DESCRIPTOR_MIN_LENGTH];
-
-        pproc = malloc(sizeof(*pproc));
-        memset(pproc, 0, sizeof(*pproc));
-
-        /* We can't use NULL for lpSecurityDescriptor because that
-           uses the default security descriptor of the calling process.
-           Instead we use a security descriptor with no DACL.  This
-           allows nonrestricted access to the associated objects. */
-
-        if (!InitializeSecurityDescriptor((PSECURITY_DESCRIPTOR)(&sd),
-                                          SECURITY_DESCRIPTOR_REVISION)) {
-                pproc->last_err = GetLastError();
-                pproc->lerrno = E_SCALL;
-                return((HANDLE)pproc);
-        }
-
-        inherit.nLength = sizeof(inherit);
-        inherit.lpSecurityDescriptor = (PSECURITY_DESCRIPTOR)(&sd);
-        inherit.bInheritHandle = TRUE;
-
-        // By convention, parent gets pipe[0], and child gets pipe[1]
-        // This means the READ side of stdin pipe goes into pipe[1]
-        // and the WRITE side of the stdout and stderr pipes go into pipe[1]
-        if (CreatePipe( &stdin_pipes[1], &stdin_pipes[0], &inherit, 0) == FALSE ||
-        CreatePipe( &stdout_pipes[0], &stdout_pipes[1], &inherit, 0) == FALSE ||
-        CreatePipe( &stderr_pipes[0], &stderr_pipes[1], &inherit, 0) == FALSE) {
-
-                pproc->last_err = GetLastError();
-                pproc->lerrno = E_SCALL;
-                return((HANDLE)pproc);
-        }
-
-        //
-        // Mark the parent sides of the pipes as non-inheritable
-        //
-        if (SetHandleInformation(stdin_pipes[0],
-                                HANDLE_FLAG_INHERIT, 0) == FALSE ||
-                SetHandleInformation(stdout_pipes[0],
-                                HANDLE_FLAG_INHERIT, 0) == FALSE ||
-                SetHandleInformation(stderr_pipes[0],
-                                HANDLE_FLAG_INHERIT, 0) == FALSE) {
-
-                pproc->last_err = GetLastError();
-                pproc->lerrno = E_SCALL;
-                return((HANDLE)pproc);
-        }
-        pproc->sv_stdin[0]  = (intptr_t) stdin_pipes[0];
-        pproc->sv_stdin[1]  = (intptr_t) stdin_pipes[1];
-        pproc->sv_stdout[0] = (intptr_t) stdout_pipes[0];
-        pproc->sv_stdout[1] = (intptr_t) stdout_pipes[1];
-        pproc->sv_stderr[0] = (intptr_t) stderr_pipes[0];
-        pproc->sv_stderr[1] = (intptr_t) stderr_pipes[1];
-
-        pproc->using_pipes = 1;
-
-        pproc->lerrno = 0;
-
-        return((HANDLE)pproc);
-}
-
-
-        HANDLE
+        sub_process *pproc;
+        /*
+         * open file descriptors for attaching stdin/stdout/sterr
+         */
+        HANDLE stdin_pipes[2];
+        HANDLE stdout_pipes[2];
+        HANDLE stderr_pipes[2];
+        SECURITY_ATTRIBUTES inherit;
+        BYTE sd[SECURITY_DESCRIPTOR_MIN_LENGTH];
+
+        pproc = malloc(sizeof(*pproc));
+        memset(pproc, 0, sizeof(*pproc));
+
+        /* We can't use NULL for lpSecurityDescriptor because that
+           uses the default security descriptor of the calling process.
+           Instead we use a security descriptor with no DACL.  This
+           allows nonrestricted access to the associated objects. */
+
+        if (!InitializeSecurityDescriptor((PSECURITY_DESCRIPTOR)(&sd),
+                                          SECURITY_DESCRIPTOR_REVISION)) {
+                pproc->last_err = GetLastError();
+                pproc->lerrno = E_SCALL;
+                return((HANDLE)pproc);
+        }
+
+        inherit.nLength = sizeof(inherit);
+        inherit.lpSecurityDescriptor = (PSECURITY_DESCRIPTOR)(&sd);
+        inherit.bInheritHandle = TRUE;
+
+        // By convention, parent gets pipe[0], and child gets pipe[1]
+        // This means the READ side of stdin pipe goes into pipe[1]
+        // and the WRITE side of the stdout and stderr pipes go into pipe[1]
+        if (CreatePipe( &stdin_pipes[1], &stdin_pipes[0], &inherit, 0) == FALSE ||
+        CreatePipe( &stdout_pipes[0], &stdout_pipes[1], &inherit, 0) == FALSE ||
+        CreatePipe( &stderr_pipes[0], &stderr_pipes[1], &inherit, 0) == FALSE) {
+
+                pproc->last_err = GetLastError();
+                pproc->lerrno = E_SCALL;
+                return((HANDLE)pproc);
+        }
+
+        //
+        // Mark the parent sides of the pipes as non-inheritable
+        //
+        if (SetHandleInformation(stdin_pipes[0],
+                                HANDLE_FLAG_INHERIT, 0) == FALSE ||
+                SetHandleInformation(stdout_pipes[0],
+                                HANDLE_FLAG_INHERIT, 0) == FALSE ||
+                SetHandleInformation(stderr_pipes[0],
+                                HANDLE_FLAG_INHERIT, 0) == FALSE) {
+
+                pproc->last_err = GetLastError();
+                pproc->lerrno = E_SCALL;
+                return((HANDLE)pproc);
+        }
+        pproc->sv_stdin[0]  = (intptr_t) stdin_pipes[0];
+        pproc->sv_stdin[1]  = (intptr_t) stdin_pipes[1];
+        pproc->sv_stdout[0] = (intptr_t) stdout_pipes[0];
+        pproc->sv_stdout[1] = (intptr_t) stdout_pipes[1];
+        pproc->sv_stderr[0] = (intptr_t) stderr_pipes[0];
+        pproc->sv_stderr[1] = (intptr_t) stderr_pipes[1];
+
+        pproc->using_pipes = 1;
+
+        pproc->lerrno = 0;
+
+        return((HANDLE)pproc);
+}
+
+
+        HANDLE
 process_init_fd(HANDLE stdinh, HANDLE stdouth, HANDLE stderrh)
 {
-        sub_process *pproc;
-
-        pproc = malloc(sizeof(*pproc));
-        memset(pproc, 0, sizeof(*pproc));
-
-        /*
-         * Just pass the provided file handles to the 'child side' of the
-         * pipe, bypassing pipes altogether.
-         */
-        pproc->sv_stdin[1]  = (intptr_t) stdinh;
-        pproc->sv_stdout[1] = (intptr_t) stdouth;
-        pproc->sv_stderr[1] = (intptr_t) stderrh;
-
-        pproc->last_err = pproc->lerrno = 0;
-
-        return((HANDLE)pproc);
+        sub_process *pproc;
+
+        pproc = malloc(sizeof(*pproc));
+        if (pproc) {
+                memset(pproc, 0, sizeof(*pproc));
+
+                /*
+                 * Just pass the provided file handles to the 'child
+                 * side' of the pipe, bypassing pipes altogether.
+                 */
+                pproc->sv_stdin[1]  = (intptr_t) stdinh;
+                pproc->sv_stdout[1] = (intptr_t) stdouth;
+                pproc->sv_stderr[1] = (intptr_t) stderrh;
+
+                pproc->last_err = pproc->lerrno = 0;
+        }
+
+        return((HANDLE)pproc);
 }
 
@@ -355 +397 @@
 static HANDLE
 find_file(const char *exec_path, const char *path_var,
-          char *full_fname, DWORD full_len)
-{
-        HANDLE exec_handle;
-        char *fname;
-        char *ext;
-        DWORD req_len;
-        int i;
-        static const char *extensions[] =
-          /* Should .com come before no-extension case?  */
-          { ".exe", ".cmd", ".bat", "", ".com", NULL };
-
-        fname = xmalloc(strlen(exec_path) + 5);
-        strcpy(fname, exec_path);
-        ext = fname + strlen(fname);
-
-        for (i = 0; extensions[i]; i++) {
-                strcpy(ext, extensions[i]);
-                if (((req_len = SearchPath (path_var, fname, NULL, full_len,
-                                            full_fname, NULL)) > 0
-                     /* For compatibility with previous code, which
-                        used OpenFile, and with Windows operation in
-                        general, also look in various default
-                        locations, such as Windows directory and
-                        Windows System directory.  Warning: this also
-                        searches PATH in the Make's environment, which
-                        might not be what the Makefile wants, but it
-                        seems to be OK as a fallback, after the
-                        previous SearchPath failed to find on child's
-                        PATH.  */
-                     || (req_len = SearchPath (NULL, fname, NULL, full_len,
-                                               full_fname, NULL)) > 0)
-                    && req_len <= full_len
-                    && (exec_handle =
-                                CreateFile(full_fname,
-                                           GENERIC_READ,
-                                           FILE_SHARE_READ | FILE_SHARE_WRITE,
-                                           NULL,
-                                           OPEN_EXISTING,
-                                           FILE_ATTRIBUTE_NORMAL,
-                                           NULL)) != INVALID_HANDLE_VALUE) {
-                        free(fname);
-                        return(exec_handle);
-                }
-        }
-
-        free(fname);
-        return INVALID_HANDLE_VALUE;
+          char *full_fname, DWORD full_len)
+{
+        HANDLE exec_handle;
+        char *fname;
+        char *ext;
+        DWORD req_len;
+        int i;
+        static const char *extensions[] =
+          /* Should .com come before no-extension case?  */
+          { ".exe", ".cmd", ".bat", "", ".com", NULL };
+
+        fname = xmalloc(strlen(exec_path) + 5);
+        strcpy(fname, exec_path);
+        ext = fname + strlen(fname);
+
+        for (i = 0; extensions[i]; i++) {
+                strcpy(ext, extensions[i]);
+                if (((req_len = SearchPath (path_var, fname, NULL, full_len,
+                                            full_fname, NULL)) > 0
+                     /* For compatibility with previous code, which
+                        used OpenFile, and with Windows operation in
+                        general, also look in various default
+                        locations, such as Windows directory and
+                        Windows System directory.  Warning: this also
+                        searches PATH in the Make's environment, which
+                        might not be what the Makefile wants, but it
+                        seems to be OK as a fallback, after the
+                        previous SearchPath failed to find on child's
+                        PATH.  */
+                     || (req_len = SearchPath (NULL, fname, NULL, full_len,
+                                               full_fname, NULL)) > 0)
+                    && req_len <= full_len
+                    && (exec_handle =
+                                CreateFile(full_fname,
+                                           GENERIC_READ,
+                                           FILE_SHARE_READ | FILE_SHARE_WRITE,
+                                           NULL,
+                                           OPEN_EXISTING,
+                                           FILE_ATTRIBUTE_NORMAL,
+                                           NULL)) != INVALID_HANDLE_VALUE) {
+                        free(fname);
+                        return(exec_handle);
+                }
+        }
+
+        free(fname);
+        return INVALID_HANDLE_VALUE;
+}
+
+/*
+ * Return non-zero of FNAME specifies a batch file and its name
+ * includes embedded whitespace.
+ */
+
+static int
+batch_file_with_spaces(const char *fname)
+{
+        size_t fnlen = strlen(fname);
+
+        return (fnlen > 4
+                && (_strnicmp(fname + fnlen - 4, ".bat", 4) == 0
+                    || _strnicmp(fname + fnlen - 4, ".cmd", 4) == 0)
+                /* The set of characters in the 2nd arg to strpbrk
+                   should be the same one used by make_command_line
+                   below to decide whether an argv[] element needs
+                   quoting.  */
+                && strpbrk(fname, " \t") != NULL);
 }
 
@@ -414 +476 @@
 long
 process_begin(
-        HANDLE proc,
-        char **argv,
-        char **envp,
-        char *exec_path,
-        char *as_user)
-{
-        sub_process *pproc = (sub_process *)proc;
-        char *shell_name = 0;
-        int file_not_found=0;
-        HANDLE exec_handle;
-        char exec_fname[MAX_PATH];
-        const char *path_var = NULL;
-        char **ep;
-        char buf[256];
-        DWORD bytes_returned;
-        DWORD flags;
-        char *command_line;
-        STARTUPINFO startInfo;
-        PROCESS_INFORMATION procInfo;
-        char *envblk=NULL;
-
-        /*
-         *  Shell script detection...  if the exec_path starts with #! then
-         *  we want to exec shell-script-name exec-path, not just exec-path
-         *  NT doesn't recognize #!/bin/sh or #!/etc/Tivoli/bin/perl.  We do not
-         *  hard-code the path to the shell or perl or whatever:  Instead, we
-         *  assume it's in the path somewhere (generally, the NT tools
-         *  bin directory)
-         */
-
-        /* Use the Makefile's value of PATH to look for the program to
-           execute, because it could be different from Make's PATH
-           (e.g., if the target sets its own value.  */
-        if (envp)
-                for (ep = envp; *ep; ep++) {
-                        if (strncmp (*ep, "PATH=", 5) == 0
-                            || strncmp (*ep, "Path=", 5) == 0) {
-                                path_var = *ep + 5;
-                                break;
-                        }
-                }
-        exec_handle = find_file(exec_path, path_var,
-                                exec_fname, sizeof(exec_fname));
-
-        /*
-         * If we couldn't open the file, just assume that Windows will be
-         * somehow able to find and execute it.
-         */
-        if (exec_handle == INVALID_HANDLE_VALUE) {
-                file_not_found++;
-        }
-        else {
-                /* Attempt to read the first line of the file */
-                if (ReadFile( exec_handle,
-                                buf, sizeof(buf) - 1, /* leave room for trailing NULL */
-                                &bytes_returned, 0) == FALSE || bytes_returned < 2) {
-
-                        pproc->last_err = GetLastError();
-                        pproc->lerrno = E_IO;
-                        CloseHandle(exec_handle);
-                        return(-1);
-                }
-                if (buf[0] == '#' && buf[1] == '!') {
-                        /*
-                         *  This is a shell script...  Change the command line from
-                         *      exec_path args to shell_name exec_path args
-                         */
-                        char *p;
-
-                        /*  Make sure buf is NULL terminated */
-                        buf[bytes_returned] = 0;
-                        /*
-                         * Depending on the file system type, etc. the first line
-                         * of the shell script may end with newline or newline-carriage-return
-                         * Whatever it ends with, cut it off.
-                         */
-                        p= strchr(buf, '\n');
-                        if (p)
-                                *p = 0;
-                        p = strchr(buf, '\r');
-                        if (p)
-                                *p = 0;
-
-                        /*
-                         *  Find base name of shell
-                         */
-                        shell_name = strrchr( buf, '/');
-                        if (shell_name) {
-                                shell_name++;
-                        } else {
-                                shell_name = &buf[2];/* skipping "#!" */
-                        }
-
-                }
-                CloseHandle(exec_handle);
-        }
-
-        flags = 0;
-
-        if (file_not_found)
-                command_line = make_command_line( shell_name, exec_path, argv);
-        else
-                command_line = make_command_line( shell_name, exec_fname, argv);
-
-        if ( command_line == NULL ) {
-                pproc->last_err = 0;
-                pproc->lerrno = E_NO_MEM;
-                return(-1);
-        }
-
-        if (envp) {
-                if (arr2envblk(envp, &envblk) ==FALSE) {
-                        pproc->last_err = 0;
-                        pproc->lerrno = E_NO_MEM;
-                        free( command_line );
-                        return(-1);
-                }
-        }
-
-        if ((shell_name) || (file_not_found)) {
-                exec_path = 0;  /* Search for the program in %Path% */
-        } else {
-                exec_path = exec_fname;
-        }
-
-        /*
-         *  Set up inherited stdin, stdout, stderr for child
-         */
-        GetStartupInfo(&startInfo);
-        startInfo.dwFlags = STARTF_USESTDHANDLES;
-        startInfo.lpReserved = 0;
-        startInfo.cbReserved2 = 0;
-        startInfo.lpReserved2 = 0;
-        startInfo.lpTitle = shell_name ? shell_name : exec_path;
-        startInfo.hStdInput = (HANDLE)pproc->sv_stdin[1];
-        startInfo.hStdOutput = (HANDLE)pproc->sv_stdout[1];
-        startInfo.hStdError = (HANDLE)pproc->sv_stderr[1];
-
-        if (as_user) {
-                if (envblk) free(envblk);
-                return -1;
-        } else {
-                DB (DB_JOBS, ("CreateProcess(%s,%s,...)\n",
-                        exec_path ? exec_path : "NULL",
-                        command_line ? command_line : "NULL"));
-                if (CreateProcess(
-                        exec_path,
-                        command_line,
-                        NULL,
-                        0, /* default security attributes for thread */
-                        TRUE, /* inherit handles (e.g. helper pipes, oserv socket) */
-                        flags,
-                        envblk,
-                        0, /* default starting directory */
-                        &startInfo,
-                        &procInfo) == FALSE) {
-
-                        pproc->last_err = GetLastError();
-                        pproc->lerrno = E_FORK;
-                        fprintf(stderr, "process_begin: CreateProcess(%s, %s, ...) failed.\n",
+        HANDLE proc,
+        char **argv,
+        char **envp,
+        char *exec_path,
+        char *as_user)
+{
+        sub_process *pproc = (sub_process *)proc;
+        char *shell_name = 0;
+        int file_not_found=0;
+        HANDLE exec_handle;
+        char exec_fname[MAX_PATH];
+        const char *path_var = NULL;
+        char **ep;
+        char buf[MAX_PATH];
+        DWORD bytes_returned;
+        DWORD flags;
+        char *command_line;
+        STARTUPINFO startInfo;
+        PROCESS_INFORMATION procInfo;
+        char *envblk=NULL;
+        int envsize_needed = 0;
+        int pass_null_exec_path = 0;
+
+        /*
+         *  Shell script detection...  if the exec_path starts with #! then
+         *  we want to exec shell-script-name exec-path, not just exec-path
+         *  NT doesn't recognize #!/bin/sh or #!/etc/Tivoli/bin/perl.  We do not
+         *  hard-code the path to the shell or perl or whatever:  Instead, we
+         *  assume it's in the path somewhere (generally, the NT tools
+         *  bin directory)
+         */
+
+        /* Use the Makefile's value of PATH to look for the program to
+           execute, because it could be different from Make's PATH
+           (e.g., if the target sets its own value.  */
+        if (envp)
+                for (ep = envp; *ep; ep++) {
+                        if (strncmp (*ep, "PATH=", 5) == 0
+                            || strncmp (*ep, "Path=", 5) == 0) {
+                                path_var = *ep + 5;
+                                break;
+                        }
+                }
+        exec_handle = find_file(exec_path, path_var,
+                                exec_fname, sizeof(exec_fname));
+
+        /*
+         * If we couldn't open the file, just assume that Windows will be
+         * somehow able to find and execute it.  If the first character
+         * of the command is '/', assume they set SHELL to a Unixy shell
+         * that have some magic mounts known only to it, and run the whole
+         * command via $SHELL -c "COMMAND" instead.
+         */
+        if (exec_handle == INVALID_HANDLE_VALUE) {
+                if (exec_path[0] == '/') {
+                        char *new_argv0;
+                        char **argvi = argv;
+                        int arglen = 0;
+
+                        strcpy(buf, variable_expand ("$(SHELL)"));
+                        shell_name = &buf[0];
+                        strcpy(exec_fname, "-c");
+                        /* Construct a single command string in argv[0].  */
+                        while (*argvi) {
+                                arglen += strlen(*argvi) + 1;
+                                argvi++;
+                        }
+                        new_argv0 = xmalloc(arglen + 1);
+                        new_argv0[0] = '\0';
+                        for (argvi = argv; *argvi; argvi++) {
+                                strcat(new_argv0, *argvi);
+                                strcat(new_argv0, " ");
+                        }
+                        /* Remove the extra blank at the end.  */
+                        new_argv0[arglen-1] = '\0';
+                        free(argv[0]);
+                        argv[0] = new_argv0;
+                        argv[1] = NULL;
+                }
+                else
+                        file_not_found++;
+        }
+        else {
+                /* Attempt to read the first line of the file */
+                if (ReadFile( exec_handle,
+                                buf, sizeof(buf) - 1, /* leave room for trailing NULL */
+                                &bytes_returned, 0) == FALSE || bytes_returned < 2) {
+
+                        pproc->last_err = GetLastError();
+                        pproc->lerrno = E_IO;
+                        CloseHandle(exec_handle);
+                        return(-1);
+                }
+                if (buf[0] == '#' && buf[1] == '!') {
+                        /*
+                         *  This is a shell script...  Change the command line from
+                         *      exec_path args to shell_name exec_path args
+                         */
+                        char *p;
+
+                        /*  Make sure buf is NULL terminated */
+                        buf[bytes_returned] = 0;
+                        /*
+                         * Depending on the file system type, etc. the first line
+                         * of the shell script may end with newline or newline-carriage-return
+                         * Whatever it ends with, cut it off.
+                         */
+                        p= strchr(buf, '\n');
+                        if (p)
+                                *p = 0;
+                        p = strchr(buf, '\r');
+                        if (p)
+                                *p = 0;
+
+                        /*
+                         *  Find base name of shell
+                         */
+                        shell_name = strrchr( buf, '/');
+                        if (shell_name) {
+                                shell_name++;
+                        } else {
+                                shell_name = &buf[2];/* skipping "#!" */
+                        }
+
+                }
+                CloseHandle(exec_handle);
+        }
+
+        flags = 0;
+
+        if (file_not_found)
+                command_line = make_command_line( shell_name, exec_path, argv);
+        else {
+                /* If exec_fname includes whitespace, CreateProcess
+                   behaves erratically and unreliably, and often fails
+                   if argv[0] also includes whitespace (and thus will
+                   be quoted by make_command_line below).  So in that
+                   case, we don't pass exec_fname as the 1st arg to
+                   CreateProcess, but instead replace argv[0] with
+                   exec_fname (to keep its leading directories and
+                   extension as found by find_file), and pass NULL to
+                   CreateProcess as its 1st arg.  This works around
+                   the bugs in CreateProcess, which are probably
+                   caused by its passing the command to cmd.exe with
+                   some incorrect quoting.  */
+                if (!shell_name
+                    && batch_file_with_spaces(exec_fname)
+                    && _stricmp(exec_path, argv[0]) == 0) {
+                        char *new_argv, *p;
+                        char **argvi;
+                        int arglen, i;
+                        pass_null_exec_path = 1;
+                        /* Rewrite argv[] replacing argv[0] with exec_fname.  */
+                        for (argvi = argv + 1, arglen = strlen(exec_fname) + 1;
+                             *argvi;
+                             argvi++) {
+                                arglen += strlen(*argvi) + 1;
+                        }
+                        new_argv = xmalloc(arglen);
+                        p = strcpy(new_argv, exec_fname) + strlen(exec_fname) + 1;
+                        for (argvi = argv + 1, i = 1; *argvi; argvi++, i++) {
+                                strcpy(p, *argvi);
+                                argv[i] = p;
+                                p += strlen(*argvi) + 1;
+                        }
+                        argv[i] = NULL;
+                        free (argv[0]);
+                        argv[0] = new_argv;
+                }
+                command_line = make_command_line( shell_name, exec_fname, argv);
+        }
+
+        if ( command_line == NULL ) {
+                pproc->last_err = 0;
+                pproc->lerrno = E_NO_MEM;
+                return(-1);
+        }
+
+        if (envp) {
+                if (arr2envblk(envp, &envblk, &envsize_needed) == FALSE) {
+                        pproc->lerrno = E_NO_MEM;
+                        free( command_line );
+                        if ((pproc->last_err == ERROR_INVALID_PARAMETER
+                             || pproc->last_err == ERROR_MORE_DATA)
+                            && envsize_needed > 32*1024) {
+                                fprintf (stderr, "CreateProcess failed, probably because environment is too large (%d bytes).\n",
+                                         envsize_needed);
+                        }
+                        pproc->last_err = 0;
+                        return(-1);
+                }
+        }
+
+        if (shell_name || file_not_found || pass_null_exec_path) {
+                exec_path = 0;  /* Search for the program in %Path% */
+        } else {
+                exec_path = exec_fname;
+        }
+
+        /*
+         *  Set up inherited stdin, stdout, stderr for child
+         */
+        memset(&startInfo, '\0', sizeof(startInfo));
+        GetStartupInfo(&startInfo);
+        startInfo.dwFlags = STARTF_USESTDHANDLES;
+        startInfo.lpReserved = 0;
+        startInfo.cbReserved2 = 0;
+        startInfo.lpReserved2 = 0;
+        startInfo.hStdInput = (HANDLE)pproc->sv_stdin[1];
+        startInfo.hStdOutput = (HANDLE)pproc->sv_stdout[1];
+        startInfo.hStdError = (HANDLE)pproc->sv_stderr[1];
+
+        if (as_user) {
+                free(envblk);
+                return -1;
+        } else {
+                DB (DB_JOBS, ("CreateProcess(%s,%s,...)\n",
+                        exec_path ? exec_path : "NULL",
+                        command_line ? command_line : "NULL"));
+                if (CreateProcess(
+                        exec_path,
+                        command_line,
+                        NULL,
+                        0, /* default security attributes for thread */
+                        TRUE, /* inherit handles (e.g. helper pipes, oserv socket) */
+                        flags,
+                        envblk,
+                        0, /* default starting directory */
+                        &startInfo,
+                        &procInfo) == FALSE) {
+
+                        pproc->last_err = GetLastError();
+                        pproc->lerrno = E_FORK;
+                        fprintf(stderr, "process_begin: CreateProcess(%s, %s, ...) failed.\n",
                                 exec_path ? exec_path : "NULL", command_line);
-                        if (envblk) free(envblk);
-                        free( command_line );
-                        return(-1);
-                }
-        }
-
-        pproc->pid = (pid_t)procInfo.hProcess;
-        /* Close the thread handle -- we'll just watch the process */
-        CloseHandle(procInfo.hThread);
-
-        /* Close the halves of the pipes we don't need */
-        CloseHandle((HANDLE)pproc->sv_stdin[1]);
-        CloseHandle((HANDLE)pproc->sv_stdout[1]);
-        CloseHandle((HANDLE)pproc->sv_stderr[1]);
+                        free(envblk);
+                        free( command_line );
+                        return(-1);
+                }
+        }
+
+        pproc->pid = (pid_t)procInfo.hProcess;
+        /* Close the thread handle -- we'll just watch the process */
+        CloseHandle(procInfo.hThread);
+
+        /* Close the halves of the pipes we don't need */
+        if ((HANDLE)pproc->sv_stdin[1] != INVALID_HANDLE_VALUE)
+          CloseHandle((HANDLE)pproc->sv_stdin[1]);
+        if ((HANDLE)pproc->sv_stdout[1] != INVALID_HANDLE_VALUE)
+          CloseHandle((HANDLE)pproc->sv_stdout[1]);
+        if ((HANDLE)pproc->sv_stderr[1] != INVALID_HANDLE_VALUE)
+          CloseHandle((HANDLE)pproc->sv_stderr[1]);
         pproc->sv_stdin[1] = 0;
         pproc->sv_stdout[1] = 0;
         pproc->sv_stderr[1] = 0;
 
-        free( command_line );
-        if (envblk) free(envblk);
-        pproc->lerrno=0;
-        return 0;
-}
-
-
-
+        free( command_line );
+        free(envblk);
+        pproc->lerrno=0;
+        return 0;
+}
+
+
+
+#if 0   /* unused */
 static DWORD
 proc_stdin_thread(sub_process *pproc)
 {
-        DWORD in_done;
-        for (;;) {
-                if (WriteFile( (HANDLE) pproc->sv_stdin[0], pproc->inp, pproc->incnt,
-                                         &in_done, NULL) == FALSE)
-                        _endthreadex(0);
-                // This if should never be true for anonymous pipes, but gives
-                // us a chance to change I/O mechanisms later
-                if (in_done < pproc->incnt) {
-                        pproc->incnt -= in_done;
-                        pproc->inp += in_done;
-                } else {
-                        _endthreadex(0);
-                }
-        }
-        return 0; // for compiler warnings only.. not reached
+        DWORD in_done;
+        for (;;) {
+                if (WriteFile( (HANDLE) pproc->sv_stdin[0], pproc->inp, pproc->incnt,
+                                         &in_done, NULL) == FALSE)
+                        _endthreadex(0);
+                // This if should never be true for anonymous pipes, but gives
+                // us a chance to change I/O mechanisms later
+                if (in_done < pproc->incnt) {
+                        pproc->incnt -= in_done;
+                        pproc->inp += in_done;
+                } else {
+                        _endthreadex(0);
+                }
+        }
+        return 0; // for compiler warnings only.. not reached
 }
 
@@ -624 +764 @@
 proc_stdout_thread(sub_process *pproc)
 {
-        DWORD bufsize = 1024;
-        char c;
-        DWORD nread;
-        pproc->outp = malloc(bufsize);
-        if (pproc->outp == NULL)
-                _endthreadex(0);
-        pproc->outcnt = 0;
-
-        for (;;) {
-                if (ReadFile( (HANDLE)pproc->sv_stdout[0], &c, 1, &nread, NULL)
-                                        == FALSE) {
-/*                      map_windows32_error_to_string(GetLastError());*/
-                        _endthreadex(0);
-                }
-                if (nread == 0)
-                        _endthreadex(0);
-                if (pproc->outcnt + nread > bufsize) {
-                        bufsize += nread + 512;
-                        pproc->outp = realloc(pproc->outp, bufsize);
-                        if (pproc->outp == NULL) {
-                                pproc->outcnt = 0;
-                                _endthreadex(0);
-                        }
-                }
-                pproc->outp[pproc->outcnt++] = c;
-        }
-        return 0;
+        DWORD bufsize = 1024;
+        char c;
+        DWORD nread;
+        pproc->outp = malloc(bufsize);
+        if (pproc->outp == NULL)
+                _endthreadex(0);
+        pproc->outcnt = 0;
+
+        for (;;) {
+                if (ReadFile( (HANDLE)pproc->sv_stdout[0], &c, 1, &nread, NULL)
+                                        == FALSE) {
+/*                      map_windows32_error_to_string(GetLastError());*/
+                        _endthreadex(0);
+                }
+                if (nread == 0)
+                        _endthreadex(0);
+                if (pproc->outcnt + nread > bufsize) {
+                        bufsize += nread + 512;
+                        pproc->outp = realloc(pproc->outp, bufsize);
+                        if (pproc->outp == NULL) {
+                                pproc->outcnt = 0;
+                                _endthreadex(0);
+                        }
+                }
+                pproc->outp[pproc->outcnt++] = c;
+        }
+        return 0;
 }
 
@@ -656 +796 @@
 proc_stderr_thread(sub_process *pproc)
 {
-        DWORD bufsize = 1024;
-        char c;
-        DWORD nread;
-        pproc->errp = malloc(bufsize);
-        if (pproc->errp == NULL)
-                _endthreadex(0);
-        pproc->errcnt = 0;
-
-        for (;;) {
-                if (ReadFile( (HANDLE)pproc->sv_stderr[0], &c, 1, &nread, NULL) == FALSE) {
-                        map_windows32_error_to_string(GetLastError());
-                        _endthreadex(0);
-                }
-                if (nread == 0)
-                        _endthreadex(0);
-                if (pproc->errcnt + nread > bufsize) {
-                        bufsize += nread + 512;
-                        pproc->errp = realloc(pproc->errp, bufsize);
-                        if (pproc->errp == NULL) {
-                                pproc->errcnt = 0;
-                                _endthreadex(0);
-                        }
-                }
-                pproc->errp[pproc->errcnt++] = c;
-        }
-        return 0;
+        DWORD bufsize = 1024;
+        char c;
+        DWORD nread;
+        pproc->errp = malloc(bufsize);
+        if (pproc->errp == NULL)
+                _endthreadex(0);
+        pproc->errcnt = 0;
+
+        for (;;) {
+                if (ReadFile( (HANDLE)pproc->sv_stderr[0], &c, 1, &nread, NULL) == FALSE) {
+                        map_windows32_error_to_string(GetLastError());
+                        _endthreadex(0);
+                }
+                if (nread == 0)
+                        _endthreadex(0);
+                if (pproc->errcnt + nread > bufsize) {
+                        bufsize += nread + 512;
+                        pproc->errp = realloc(pproc->errp, bufsize);
+                        if (pproc->errp == NULL) {
+                                pproc->errcnt = 0;
+                                _endthreadex(0);
+                        }
+                }
+                pproc->errp[pproc->errcnt++] = c;
+        }
+        return 0;
 }
 
@@ -694 +834 @@
  * Notes/Dependencies:
  */
-        long
+        long
 process_pipe_io(
-        HANDLE proc,
-        char *stdin_data,
-        int stdin_data_len)
-{
-        sub_process *pproc = (sub_process *)proc;
-        bool_t stdin_eof = FALSE, stdout_eof = FALSE, stderr_eof = FALSE;
-        HANDLE childhand = (HANDLE) pproc->pid;
-        HANDLE tStdin = NULL, tStdout = NULL, tStderr = NULL;
-        unsigned int dwStdin, dwStdout, dwStderr;
-        HANDLE wait_list[4];
-        DWORD wait_count;
-        DWORD wait_return;
-        HANDLE ready_hand;
-        bool_t child_dead = FALSE;
-        BOOL GetExitCodeResult;
-
-        /*
-         *  Create stdin thread, if needed
-         */
-        pproc->inp = stdin_data;
-        pproc->incnt = stdin_data_len;
-        if (!pproc->inp) {
-                stdin_eof = TRUE;
-                CloseHandle((HANDLE)pproc->sv_stdin[0]);
-                pproc->sv_stdin[0] = 0;
-        } else {
-                tStdin = (HANDLE) _beginthreadex( 0, 1024,
-                        (unsigned (__stdcall *) (void *))proc_stdin_thread,
-                                                  pproc, 0, &dwStdin);
-                if (tStdin == 0) {
-                        pproc->last_err = GetLastError();
-                        pproc->lerrno = E_SCALL;
-                        goto done;
-                }
-        }
-
-        /*
-         *   Assume child will produce stdout and stderr
-         */
-        tStdout = (HANDLE) _beginthreadex( 0, 1024,
-                (unsigned (__stdcall *) (void *))proc_stdout_thread, pproc, 0,
-                &dwStdout);
-        tStderr = (HANDLE) _beginthreadex( 0, 1024,
-                (unsigned (__stdcall *) (void *))proc_stderr_thread, pproc, 0,
-                &dwStderr);
-
-        if (tStdout == 0 || tStderr == 0) {
-
-                pproc->last_err = GetLastError();
-                pproc->lerrno = E_SCALL;
-                goto done;
-        }
-
-
-        /*
-         *  Wait for all I/O to finish and for the child process to exit
-         */
-
-        while (!stdin_eof || !stdout_eof || !stderr_eof || !child_dead) {
-                wait_count = 0;
-                if (!stdin_eof) {
-                        wait_list[wait_count++] = tStdin;
-                }
-                if (!stdout_eof) {
-                        wait_list[wait_count++] = tStdout;
-                }
-                if (!stderr_eof) {
-                        wait_list[wait_count++] = tStderr;
-                }
-                if (!child_dead) {
-                        wait_list[wait_count++] = childhand;
-                }
-
-                wait_return = WaitForMultipleObjects(wait_count, wait_list,
-                         FALSE, /* don't wait for all: one ready will do */
-                         child_dead? 1000 :INFINITE); /* after the child dies, subthreads have
-                                one second to collect all remaining output */
-
-                if (wait_return == WAIT_FAILED) {
-/*                      map_windows32_error_to_string(GetLastError());*/
-                        pproc->last_err = GetLastError();
-                        pproc->lerrno = E_SCALL;
-                        goto done;
-                }
-
-                ready_hand = wait_list[wait_return - WAIT_OBJECT_0];
-
-                if (ready_hand == tStdin) {
-                        CloseHandle((HANDLE)pproc->sv_stdin[0]);
-                        pproc->sv_stdin[0] = 0;
-                        CloseHandle(tStdin);
-                        tStdin = 0;
-                        stdin_eof = TRUE;
-
-                } else if (ready_hand == tStdout) {
-
-                        CloseHandle((HANDLE)pproc->sv_stdout[0]);
-                        pproc->sv_stdout[0] = 0;
-                        CloseHandle(tStdout);
-                        tStdout = 0;
-                        stdout_eof = TRUE;
-
-                } else if (ready_hand == tStderr) {
-
-                        CloseHandle((HANDLE)pproc->sv_stderr[0]);
-                        pproc->sv_stderr[0] = 0;
-                        CloseHandle(tStderr);
-                        tStderr = 0;
-                        stderr_eof = TRUE;
-
-                } else if (ready_hand == childhand) {
-
-                        DWORD ierr;
-                        GetExitCodeResult = GetExitCodeProcess(childhand, &ierr);
-                        if (ierr == CONTROL_C_EXIT) {
-                                pproc->signal = SIGINT;
-                        } else {
-                                pproc->exit_code = ierr;
-                        }
-                        if (GetExitCodeResult == FALSE) {
-                                pproc->last_err = GetLastError();
-                                pproc->lerrno = E_SCALL;
-                                goto done;
-                        }
-                        child_dead = TRUE;
-
-                } else {
-
-                        /* ?? Got back a handle we didn't query ?? */
-                        pproc->last_err = 0;
-                        pproc->lerrno = E_FAIL;
-                        goto done;
-                }
-        }
+        HANDLE proc,
+        char *stdin_data,
+        int stdin_data_len)
+{
+        sub_process *pproc = (sub_process *)proc;
+        bool_t stdin_eof = FALSE, stdout_eof = FALSE, stderr_eof = FALSE;
+        HANDLE childhand = (HANDLE) pproc->pid;
+        HANDLE tStdin = NULL, tStdout = NULL, tStderr = NULL;
+        unsigned int dwStdin, dwStdout, dwStderr;
+        HANDLE wait_list[4];
+        DWORD wait_count;
+        DWORD wait_return;
+        HANDLE ready_hand;
+        bool_t child_dead = FALSE;
+        BOOL GetExitCodeResult;
+
+        /*
+         *  Create stdin thread, if needed
+         */
+        pproc->inp = stdin_data;
+        pproc->incnt = stdin_data_len;
+        if (!pproc->inp) {
+                stdin_eof = TRUE;
+                CloseHandle((HANDLE)pproc->sv_stdin[0]);
+                pproc->sv_stdin[0] = 0;
+        } else {
+                tStdin = (HANDLE) _beginthreadex( 0, 1024,
+                        (unsigned (__stdcall *) (void *))proc_stdin_thread,
+                                                  pproc, 0, &dwStdin);
+                if (tStdin == 0) {
+                        pproc->last_err = GetLastError();
+                        pproc->lerrno = E_SCALL;
+                        goto done;
+                }
+        }
+
+        /*
+         *   Assume child will produce stdout and stderr
+         */
+        tStdout = (HANDLE) _beginthreadex( 0, 1024,
+                (unsigned (__stdcall *) (void *))proc_stdout_thread, pproc, 0,
+                &dwStdout);
+        tStderr = (HANDLE) _beginthreadex( 0, 1024,
+                (unsigned (__stdcall *) (void *))proc_stderr_thread, pproc, 0,
+                &dwStderr);
+
+        if (tStdout == 0 || tStderr == 0) {
+
+                pproc->last_err = GetLastError();
+                pproc->lerrno = E_SCALL;
+                goto done;
+        }
+
+
+        /*
+         *  Wait for all I/O to finish and for the child process to exit
+         */
+
+        while (!stdin_eof || !stdout_eof || !stderr_eof || !child_dead) {
+                wait_count = 0;
+                if (!stdin_eof) {
+                        wait_list[wait_count++] = tStdin;
+                }
+                if (!stdout_eof) {
+                        wait_list[wait_count++] = tStdout;
+                }
+                if (!stderr_eof) {
+                        wait_list[wait_count++] = tStderr;
+                }
+                if (!child_dead) {
+                        wait_list[wait_count++] = childhand;
+                }
+
+                wait_return = WaitForMultipleObjects(wait_count, wait_list,
+                         FALSE, /* don't wait for all: one ready will do */
+                         child_dead? 1000 :INFINITE); /* after the child dies, subthreads have
+                                one second to collect all remaining output */
+
+                if (wait_return == WAIT_FAILED) {
+/*                      map_windows32_error_to_string(GetLastError());*/
+                        pproc->last_err = GetLastError();
+                        pproc->lerrno = E_SCALL;
+                        goto done;
+                }
+
+                ready_hand = wait_list[wait_return - WAIT_OBJECT_0];
+
+                if (ready_hand == tStdin) {
+                        CloseHandle((HANDLE)pproc->sv_stdin[0]);
+                        pproc->sv_stdin[0] = 0;
+                        CloseHandle(tStdin);
+                        tStdin = 0;
+                        stdin_eof = TRUE;
+
+                } else if (ready_hand == tStdout) {
+
+                        CloseHandle((HANDLE)pproc->sv_stdout[0]);
+                        pproc->sv_stdout[0] = 0;
+                        CloseHandle(tStdout);
+                        tStdout = 0;
+                        stdout_eof = TRUE;
+
+                } else if (ready_hand == tStderr) {
+
+                        CloseHandle((HANDLE)pproc->sv_stderr[0]);
+                        pproc->sv_stderr[0] = 0;
+                        CloseHandle(tStderr);
+                        tStderr = 0;
+                        stderr_eof = TRUE;
+
+                } else if (ready_hand == childhand) {
+
+                        DWORD ierr;
+                        GetExitCodeResult = GetExitCodeProcess(childhand, &ierr);
+                        if (ierr == CONTROL_C_EXIT) {
+                                pproc->signal = SIGINT;
+                        } else {
+                                pproc->exit_code = ierr;
+                        }
+                        if (GetExitCodeResult == FALSE) {
+                                pproc->last_err = GetLastError();
+                                pproc->lerrno = E_SCALL;
+                                goto done;
+                        }
+                        child_dead = TRUE;
+
+                } else {
+
+                        /* ?? Got back a handle we didn't query ?? */
+                        pproc->last_err = 0;
+                        pproc->lerrno = E_FAIL;
+                        goto done;
+                }
+        }
 
  done:
-        if (tStdin != 0)
-                CloseHandle(tStdin);
-        if (tStdout != 0)
-                CloseHandle(tStdout);
-        if (tStderr != 0)
-                CloseHandle(tStderr);
-
-        if (pproc->lerrno)
-                return(-1);
-        else
-                return(0);
-
-}
+        if (tStdin != 0)
+                CloseHandle(tStdin);
+        if (tStdout != 0)
+                CloseHandle(tStdout);
+        if (tStderr != 0)
+                CloseHandle(tStderr);
+
+        if (pproc->lerrno)
+                return(-1);
+        else
+                return(0);
+
+}
+#endif  /* unused */
 
 /*
@@ -855 +996 @@
  * Notes/Dependencies:
  */
-        long
+        long
 process_file_io(
-        HANDLE proc)
-{
-        sub_process *pproc;
-        HANDLE childhand;
-        DWORD wait_return;
-        BOOL GetExitCodeResult;
+        HANDLE proc)
+{
+        sub_process *pproc;
+        HANDLE childhand;
+        DWORD wait_return;
+        BOOL GetExitCodeResult;
         DWORD ierr;
 
-        if (proc == NULL)
-                pproc = process_wait_for_any_private();
-        else
-                pproc = (sub_process *)proc;
-
-        /* some sort of internal error */
-        if (!pproc)
-                return -1;
-
-        childhand = (HANDLE) pproc->pid;
-
-        /*
-         * This function is poorly named, and could also be used just to wait
-         * for child death if you're doing your own pipe I/O.  If that is
-         * the case, close the pipe handles here.
-         */
-        if (pproc->sv_stdin[0]) {
-                CloseHandle((HANDLE)pproc->sv_stdin[0]);
-                pproc->sv_stdin[0] = 0;
-        }
-        if (pproc->sv_stdout[0]) {
-                CloseHandle((HANDLE)pproc->sv_stdout[0]);
-                pproc->sv_stdout[0] = 0;
-        }
-        if (pproc->sv_stderr[0]) {
-                CloseHandle((HANDLE)pproc->sv_stderr[0]);
-                pproc->sv_stderr[0] = 0;
-        }
-
-        /*
-         *  Wait for the child process to exit
-         */
-
-        wait_return = WaitForSingleObject(childhand, INFINITE);
-
-        if (wait_return != WAIT_OBJECT_0) {
-/*              map_windows32_error_to_string(GetLastError());*/
-                pproc->last_err = GetLastError();
-                pproc->lerrno = E_SCALL;
-                goto done2;
-        }
-
-        GetExitCodeResult = GetExitCodeProcess(childhand, &ierr);
-        if (ierr == CONTROL_C_EXIT) {
-                pproc->signal = SIGINT;
-        } else {
-                pproc->exit_code = ierr;
-        }
-        if (GetExitCodeResult == FALSE) {
-                pproc->last_err = GetLastError();
-                pproc->lerrno = E_SCALL;
-        }
+        if (proc == NULL)
+                pproc = process_wait_for_any_private(1, 0);
+        else
+                pproc = (sub_process *)proc;
+
+        /* some sort of internal error */
+        if (!pproc)
+                return -1;
+
+        childhand = (HANDLE) pproc->pid;
+
+        /*
+         * This function is poorly named, and could also be used just to wait
+         * for child death if you're doing your own pipe I/O.  If that is
+         * the case, close the pipe handles here.
+         */
+        if (pproc->sv_stdin[0]) {
+                CloseHandle((HANDLE)pproc->sv_stdin[0]);
+                pproc->sv_stdin[0] = 0;
+        }
+        if (pproc->sv_stdout[0]) {
+                CloseHandle((HANDLE)pproc->sv_stdout[0]);
+                pproc->sv_stdout[0] = 0;
+        }
+        if (pproc->sv_stderr[0]) {
+                CloseHandle((HANDLE)pproc->sv_stderr[0]);
+                pproc->sv_stderr[0] = 0;
+        }
+
+        /*
+         *  Wait for the child process to exit
+         */
+
+        wait_return = WaitForSingleObject(childhand, INFINITE);
+
+        if (wait_return != WAIT_OBJECT_0) {
+/*              map_windows32_error_to_string(GetLastError());*/
+                pproc->last_err = GetLastError();
+                pproc->lerrno = E_SCALL;
+                goto done2;
+        }
+
+        GetExitCodeResult = GetExitCodeProcess(childhand, &ierr);
+        if (ierr == CONTROL_C_EXIT) {
+                pproc->signal = SIGINT;
+        } else {
+                pproc->exit_code = ierr;
+        }
+        if (GetExitCodeResult == FALSE) {
+                pproc->last_err = GetLastError();
+                pproc->lerrno = E_SCALL;
+        }
 
 done2:
-        if (pproc->lerrno)
-                return(-1);
-        else
-                return(0);
+        if (pproc->lerrno)
+                return(-1);
+        else
+                return(0);
 
 }
@@ -928 +1069 @@
 /*
  * Description:  Clean up any leftover handles, etc.  It is up to the
- * caller to manage and free the input, ouput, and stderr buffers.
+ * caller to manage and free the input, output, and stderr buffers.
  */
-        void
+        void
 process_cleanup(
-        HANDLE proc)
-{
-        sub_process *pproc = (sub_process *)proc;
-        int i;
-
-        if (pproc->using_pipes) {
-                for (i= 0; i <= 1; i++) {
-                        if ((HANDLE)pproc->sv_stdin[i])
-                                CloseHandle((HANDLE)pproc->sv_stdin[i]);
-                        if ((HANDLE)pproc->sv_stdout[i])
-                                CloseHandle((HANDLE)pproc->sv_stdout[i]);
-                        if ((HANDLE)pproc->sv_stderr[i])
-                                CloseHandle((HANDLE)pproc->sv_stderr[i]);
-                }
-        }
-        if ((HANDLE)pproc->pid)
-                CloseHandle((HANDLE)pproc->pid);
-
-        free(pproc);
+        HANDLE proc)
+{
+        sub_process *pproc = (sub_process *)proc;
+        int i;
+
+        if (pproc->using_pipes) {
+                for (i= 0; i <= 1; i++) {
+                        if ((HANDLE)pproc->sv_stdin[i]
+                            && (HANDLE)pproc->sv_stdin[i] != INVALID_HANDLE_VALUE)
+                                CloseHandle((HANDLE)pproc->sv_stdin[i]);
+                        if ((HANDLE)pproc->sv_stdout[i]
+                            && (HANDLE)pproc->sv_stdout[i] != INVALID_HANDLE_VALUE)
+                                CloseHandle((HANDLE)pproc->sv_stdout[i]);
+                        if ((HANDLE)pproc->sv_stderr[i]
+                            && (HANDLE)pproc->sv_stderr[i] != INVALID_HANDLE_VALUE)
+                                CloseHandle((HANDLE)pproc->sv_stderr[i]);
+                }
+        }
+        if ((HANDLE)pproc->pid)
+                CloseHandle((HANDLE)pproc->pid);
+
+        free(pproc);
 }
 
@@ -956 +1100 @@
 /*
  * Description:
- *       Create a command line buffer to pass to CreateProcess
+ *       Create a command line buffer to pass to CreateProcess
  *
  * Returns:  the buffer or NULL for failure
- *      Shell case:  sh_name a:/full/path/to/script argv[1] argv[2] ...
+ *      Shell case:  sh_name a:/full/path/to/script argv[1] argv[2] ...
  *  Otherwise:   argv[0] argv[1] argv[2] ...
  *
@@ -970 +1114 @@
 make_command_line( char *shell_name, char *full_exec_path, char **argv)
 {
-        int             argc = 0;
-        char**          argvi;
-        int*            enclose_in_quotes = NULL;
-        int*            enclose_in_quotes_i;
-        unsigned int    bytes_required = 0;
-        char*           command_line;
-        char*           command_line_i;
-        int  cygwin_mode = 0; /* HAVE_CYGWIN_SHELL */
-        int have_sh = 0; /* HAVE_CYGWIN_SHELL */
+        int             argc = 0;
+        char**          argvi;
+        int*            enclose_in_quotes = NULL;
+        int*            enclose_in_quotes_i;
+        unsigned int    bytes_required = 0;
+        char*           command_line;
+        char*           command_line_i;
+        int  cygwin_mode = 0; /* HAVE_CYGWIN_SHELL */
+        int have_sh = 0; /* HAVE_CYGWIN_SHELL */
 
 #ifdef HAVE_CYGWIN_SHELL
-        have_sh = (shell_name != NULL || strstr(full_exec_path, "sh.exe"));
-        cygwin_mode = 1;
+        have_sh = (shell_name != NULL || strstr(full_exec_path, "sh.exe"));
+        cygwin_mode = 1;
 #endif
 
-        if (shell_name && full_exec_path) {
-                bytes_required
-                  = strlen(shell_name) + 1 + strlen(full_exec_path);
-                /*
-                 * Skip argv[0] if any, when shell_name is given.
-                 */
-                if (*argv) argv++;
-                /*
-                 * Add one for the intervening space.
-                 */
-                if (*argv) bytes_required++;
-        }
-
-        argvi = argv;
-        while (*(argvi++)) argc++;
-
-        if (argc) {
-                enclose_in_quotes = (int*) calloc(1, argc * sizeof(int));
-
-                if (!enclose_in_quotes) {
-                        return NULL;
-                }
-        }
-
-        /* We have to make one pass through each argv[i] to see if we need
-         * to enclose it in ", so we might as well figure out how much
-         * memory we'll need on the same pass.
-         */
-
-        argvi = argv;
-        enclose_in_quotes_i = enclose_in_quotes;
-        while(*argvi) {
-                char* p = *argvi;
-                unsigned int backslash_count = 0;
-
-                /*
-                 * We have to enclose empty arguments in ".
-                 */
-                if (!(*p)) *enclose_in_quotes_i = 1;
-
-                while(*p) {
-                        switch (*p) {
-                        case '\"':
-                                /*
-                                 * We have to insert a backslash for each "
-                                 * and each \ that precedes the ".
-                                 */
-                                bytes_required += (backslash_count + 1);
-                                backslash_count = 0;
-                                break;
+        if (shell_name && full_exec_path) {
+                bytes_required
+                  = strlen(shell_name) + 1 + strlen(full_exec_path);
+                /*
+                 * Skip argv[0] if any, when shell_name is given.
+                 * The special case of "-c" in full_exec_path means
+                 * argv[0] is not the shell name, but the command string
+                 * to pass to the shell.
+                 */
+                if (*argv && strcmp(full_exec_path, "-c")) argv++;
+                /*
+                 * Add one for the intervening space.
+                 */
+                if (*argv) bytes_required++;
+        }
+
+        argvi = argv;
+        while (*(argvi++)) argc++;
+
+        if (argc) {
+                enclose_in_quotes = (int*) calloc(1, argc * sizeof(int));
+
+                if (!enclose_in_quotes) {
+                        return NULL;
+                }
+        }
+
+        /* We have to make one pass through each argv[i] to see if we need
+         * to enclose it in ", so we might as well figure out how much
+         * memory we'll need on the same pass.
+         */
+
+        argvi = argv;
+        enclose_in_quotes_i = enclose_in_quotes;
+        while(*argvi) {
+                char* p = *argvi;
+                unsigned int backslash_count = 0;
+
+                /*
+                 * We have to enclose empty arguments in ".
+                 */
+                if (!(*p)) *enclose_in_quotes_i = 1;
+
+                while(*p) {
+                        switch (*p) {
+                        case '\"':
+                                /*
+                                 * We have to insert a backslash for each "
+                                 * and each \ that precedes the ".
+                                 */
+                                bytes_required += (backslash_count + 1);
+                                backslash_count = 0;
+                                break;
 
 #if !defined(HAVE_MKS_SHELL) && !defined(HAVE_CYGWIN_SHELL)
-                        case '\\':
-                                backslash_count++;
-                                break;
+                        case '\\':
+                                backslash_count++;
+                                break;
 #endif
-        /*
-         * At one time we set *enclose_in_quotes_i for '*' or '?' to suppress
-         * wildcard expansion in programs linked with MSVC's SETARGV.OBJ so
-         * that argv in always equals argv out. This was removed.  Say you have
-         * such a program named glob.exe.  You enter
-         * glob '*'
-         * at the sh command prompt.  Obviously the intent is to make glob do the
-         * wildcarding instead of sh.  If we set *enclose_in_quotes_i for '*' or '?',
-         * then the command line that glob would see would be
-         * glob "*"
-         * and the _setargv in SETARGV.OBJ would _not_ expand the *.
-         */
-                        case ' ':
-                        case '\t':
-                                *enclose_in_quotes_i = 1;
-                                /* fall through */
-
-                        default:
-                                backslash_count = 0;
-                                break;
-                        }
-
-                        /*
-                         * Add one for each character in argv[i].
-                         */
-                        bytes_required++;
-
-                        p++;
-                }
-
-                if (*enclose_in_quotes_i) {
-                        /*
-                         * Add one for each enclosing ",
-                         * and one for each \ that precedes the
-                         * closing ".
-                         */
-                        bytes_required += (backslash_count + 2);
-                }
-
-                /*
-                 * Add one for the intervening space.
-                 */
-                if (*(++argvi)) bytes_required++;
-                enclose_in_quotes_i++;
-        }
-
-        /*
-         * Add one for the terminating NULL.
-         */
-        bytes_required++;
-
-        command_line = (char*) malloc(bytes_required);
-
-        if (!command_line) {
-                if (enclose_in_quotes) free(enclose_in_quotes);
-                return NULL;
-        }
-
-        command_line_i = command_line;
-
-        if (shell_name && full_exec_path) {
-                while(*shell_name) {
-                        *(command_line_i++) = *(shell_name++);
-                }
-
-                *(command_line_i++) = ' ';
-
-                while(*full_exec_path) {
-                        *(command_line_i++) = *(full_exec_path++);
-                }
-
-                if (*argv) {
-                        *(command_line_i++) = ' ';
-                }
-        }
-
-        argvi = argv;
-        enclose_in_quotes_i = enclose_in_quotes;
-
-        while(*argvi) {
-                char* p = *argvi;
-                unsigned int backslash_count = 0;
-
-                if (*enclose_in_quotes_i) {
-                        *(command_line_i++) = '\"';
-                }
-
-                while(*p) {
-                        if (*p == '\"') {
-                                if (cygwin_mode && have_sh) { /* HAVE_CYGWIN_SHELL */
-                                        /* instead of a \", cygwin likes "" */
-                                        *(command_line_i++) = '\"';
-                                } else {
-
-                                /*
-                                 * We have to insert a backslash for the "
-                                 * and each \ that precedes the ".
-                                 */
-                                backslash_count++;
-
-                                while(backslash_count) {
-                                        *(command_line_i++) = '\\';
-                                        backslash_count--;
-                                };
-                                }
+        /*
+         * At one time we set *enclose_in_quotes_i for '*' or '?' to suppress
+         * wildcard expansion in programs linked with MSVC's SETARGV.OBJ so
+         * that argv in always equals argv out. This was removed.  Say you have
+         * such a program named glob.exe.  You enter
+         * glob '*'
+         * at the sh command prompt.  Obviously the intent is to make glob do the
+         * wildcarding instead of sh.  If we set *enclose_in_quotes_i for '*' or '?',
+         * then the command line that glob would see would be
+         * glob "*"
+         * and the _setargv in SETARGV.OBJ would _not_ expand the *.
+         */
+                        case ' ':
+                        case '\t':
+                                *enclose_in_quotes_i = 1;
+                                /* fall through */
+
+                        default:
+                                backslash_count = 0;
+                                break;
+                        }
+
+                        /*
+                         * Add one for each character in argv[i].
+                         */
+                        bytes_required++;
+
+                        p++;
+                }
+
+                if (*enclose_in_quotes_i) {
+                        /*
+                         * Add one for each enclosing ",
+                         * and one for each \ that precedes the
+                         * closing ".
+                         */
+                        bytes_required += (backslash_count + 2);
+                }
+
+                /*
+                 * Add one for the intervening space.
+                 */
+                if (*(++argvi)) bytes_required++;
+                enclose_in_quotes_i++;
+        }
+
+        /*
+         * Add one for the terminating NULL.
+         */
+        bytes_required++;
+
+        command_line = (char*) malloc(bytes_required);
+
+        if (!command_line) {
+                free(enclose_in_quotes);
+                return NULL;
+        }
+
+        command_line_i = command_line;
+
+        if (shell_name && full_exec_path) {
+                while(*shell_name) {
+                        *(command_line_i++) = *(shell_name++);
+                }
+
+                *(command_line_i++) = ' ';
+
+                while(*full_exec_path) {
+                        *(command_line_i++) = *(full_exec_path++);
+                }
+
+                if (*argv) {
+                        *(command_line_i++) = ' ';
+                }
+        }
+
+        argvi = argv;
+        enclose_in_quotes_i = enclose_in_quotes;
+
+        while(*argvi) {
+                char* p = *argvi;
+                unsigned int backslash_count = 0;
+
+                if (*enclose_in_quotes_i) {
+                        *(command_line_i++) = '\"';
+                }
+
+                while(*p) {
+                        if (*p == '\"') {
+                                if (cygwin_mode && have_sh) { /* HAVE_CYGWIN_SHELL */
+                                        /* instead of a \", cygwin likes "" */
+                                        *(command_line_i++) = '\"';
+                                } else {
+
+                                /*
+                                 * We have to insert a backslash for the "
+                                 * and each \ that precedes the ".
+                                 */
+                                backslash_count++;
+
+                                while(backslash_count) {
+                                        *(command_line_i++) = '\\';
+                                        backslash_count--;
+                                };
+                                }
 #if !defined(HAVE_MKS_SHELL) && !defined(HAVE_CYGWIN_SHELL)
-                        } else if (*p == '\\') {
-                                backslash_count++;
-                        } else {
-                                backslash_count = 0;
+                        } else if (*p == '\\') {
+                                backslash_count++;
+                        } else {
+                                backslash_count = 0;
 #endif
-                        }
-
-                        /*
-                         * Copy the character.
-                         */
-                        *(command_line_i++) = *(p++);
-                }
-
-                if (*enclose_in_quotes_i) {
+                        }
+
+                        /*
+                         * Copy the character.
+                         */
+                        *(command_line_i++) = *(p++);
+                }
+
+                if (*enclose_in_quotes_i) {
 #if !defined(HAVE_MKS_SHELL) && !defined(HAVE_CYGWIN_SHELL)
-                        /*
-                         * Add one \ for each \ that precedes the
-                         * closing ".
-                         */
-                        while(backslash_count--) {
-                                *(command_line_i++) = '\\';
-                        };
+                        /*
+                         * Add one \ for each \ that precedes the
+                         * closing ".
+                         */
+                        while(backslash_count--) {
+                                *(command_line_i++) = '\\';
+                        };
 #endif
-                        *(command_line_i++) = '\"';
-                }
-
-                /*
-                 * Append an intervening space.
-                 */
-                if (*(++argvi)) {
-                        *(command_line_i++) = ' ';
-                }
-
-                enclose_in_quotes_i++;
-        }
-
-        /*
-         * Append the terminating NULL.
-         */
-        *command_line_i = '\0';
-
-        if (enclose_in_quotes) free(enclose_in_quotes);
-        return command_line;
+                        *(command_line_i++) = '\"';
+                }
+
+                /*
+                 * Append an intervening space.
+                 */
+                if (*(++argvi)) {
+                        *(command_line_i++) = ' ';
+                }
+
+                enclose_in_quotes_i++;
+        }
+
+        /*
+         * Append the terminating NULL.
+         */
+        *command_line_i = '\0';
+
+        free(enclose_in_quotes);
+        return command_line;
 }
 
@@ -1196 +1343 @@
  *              using the default stdin, stdout, and stderr handles.
  *              Also, register process so that process_wait_for_any_private()
- *              can be used via process_file_io(NULL) or
- *              process_wait_for_any().
+ *              can be used via process_file_io(NULL) or
+ *              process_wait_for_any().
  *
  * Returns:
@@ -1205 +1352 @@
 HANDLE
 process_easy(
-        char **argv,
-        char **envp)
-{
-  HANDLE hIn;
-  HANDLE hOut;
-  HANDLE hErr;
-  HANDLE hProcess;
+        char **argv,
+        char **envp,
+        int outfd,
+        int errfd)
+{
+  HANDLE hIn = INVALID_HANDLE_VALUE;
+  HANDLE hOut = INVALID_HANDLE_VALUE;
+  HANDLE hErr = INVALID_HANDLE_VALUE;
+  HANDLE hProcess, tmpIn, tmpOut, tmpErr;
+  DWORD e;
 
   if (proc_index >= MAXIMUM_WAIT_OBJECTS) {
-        DB (DB_JOBS, ("process_easy: All process slots used up\n"));
-        return INVALID_HANDLE_VALUE;
+        DB (DB_JOBS, ("process_easy: All process slots used up\n"));
+        return INVALID_HANDLE_VALUE;
   }
+  /* Standard handles returned by GetStdHandle can be NULL or
+     INVALID_HANDLE_VALUE if the parent process closed them.  If that
+     happens, we open the null device and pass its handle to
+     CreateProcess as the corresponding handle to inherit.  */
+  tmpIn = GetStdHandle(STD_INPUT_HANDLE);
   if (DuplicateHandle(GetCurrentProcess(),
-                      GetStdHandle(STD_INPUT_HANDLE),
+                      tmpIn,
                       GetCurrentProcess(),
                       &hIn,
@@ -1224 +1379 @@
                       TRUE,
                       DUPLICATE_SAME_ACCESS) == FALSE) {
-    fprintf(stderr,
-            "process_easy: DuplicateHandle(In) failed (e=%ld)\n",
-            GetLastError());
-    return INVALID_HANDLE_VALUE;
+    if ((e = GetLastError()) == ERROR_INVALID_HANDLE) {
+      tmpIn = CreateFile("NUL", GENERIC_READ,
+                         FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
+                         OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+      if (tmpIn != INVALID_HANDLE_VALUE
+          && DuplicateHandle(GetCurrentProcess(),
+                             tmpIn,
+                             GetCurrentProcess(),
+                             &hIn,
+                             0,
+                             TRUE,
+                             DUPLICATE_SAME_ACCESS) == FALSE)
+        CloseHandle(tmpIn);
+    }
+    if (hIn == INVALID_HANDLE_VALUE) {
+      fprintf(stderr, "process_easy: DuplicateHandle(In) failed (e=%ld)\n", e);
+      return INVALID_HANDLE_VALUE;
+    }
   }
+  if (outfd >= 0)
+    tmpOut = (HANDLE)_get_osfhandle (outfd);
+  else
+    tmpOut = GetStdHandle (STD_OUTPUT_HANDLE);
   if (DuplicateHandle(GetCurrentProcess(),
-                      GetStdHandle(STD_OUTPUT_HANDLE),
+                      tmpOut,
                       GetCurrentProcess(),
                       &hOut,
@@ -1236 +1409 @@
                       TRUE,
                       DUPLICATE_SAME_ACCESS) == FALSE) {
-    fprintf(stderr,
-           "process_easy: DuplicateHandle(Out) failed (e=%ld)\n",
-           GetLastError());
-    return INVALID_HANDLE_VALUE;
+    if ((e = GetLastError()) == ERROR_INVALID_HANDLE) {
+      tmpOut = CreateFile("NUL", GENERIC_WRITE,
+                          FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
+                          OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+      if (tmpOut != INVALID_HANDLE_VALUE
+          && DuplicateHandle(GetCurrentProcess(),
+                             tmpOut,
+                             GetCurrentProcess(),
+                             &hOut,
+                             0,
+                             TRUE,
+                             DUPLICATE_SAME_ACCESS) == FALSE)
+        CloseHandle(tmpOut);
+    }
+    if (hOut == INVALID_HANDLE_VALUE) {
+      fprintf(stderr, "process_easy: DuplicateHandle(Out) failed (e=%ld)\n", e);
+      return INVALID_HANDLE_VALUE;
+    }
   }
+  if (errfd >= 0)
+    tmpErr = (HANDLE)_get_osfhandle (errfd);
+  else
+    tmpErr = GetStdHandle(STD_ERROR_HANDLE);
   if (DuplicateHandle(GetCurrentProcess(),
-                      GetStdHandle(STD_ERROR_HANDLE),
+                      tmpErr,
                       GetCurrentProcess(),
                       &hErr,
@@ -1248 +1439 @@
                       TRUE,
                       DUPLICATE_SAME_ACCESS) == FALSE) {
-    fprintf(stderr,
-            "process_easy: DuplicateHandle(Err) failed (e=%ld)\n",
-            GetLastError());
-    return INVALID_HANDLE_VALUE;
+    if ((e = GetLastError()) == ERROR_INVALID_HANDLE) {
+      tmpErr = CreateFile("NUL", GENERIC_WRITE,
+                          FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
+                          OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+      if (tmpErr != INVALID_HANDLE_VALUE
+          && DuplicateHandle(GetCurrentProcess(),
+                             tmpErr,
+                             GetCurrentProcess(),
+                             &hErr,
+                             0,
+                             TRUE,
+                             DUPLICATE_SAME_ACCESS) == FALSE)
+        CloseHandle(tmpErr);
+    }
+    if (hErr == INVALID_HANDLE_VALUE) {
+      fprintf(stderr, "process_easy: DuplicateHandle(Err) failed (e=%ld)\n", e);
+      return INVALID_HANDLE_VALUE;
+    }
   }
 
@@ -1264 +1469 @@
 
     /* close up unused handles */
-    CloseHandle(hIn);
-    CloseHandle(hOut);
-    CloseHandle(hErr);
+    if (hIn != INVALID_HANDLE_VALUE)
+      CloseHandle(hIn);
+    if (hOut != INVALID_HANDLE_VALUE)
+      CloseHandle(hOut);
+    if (hErr != INVALID_HANDLE_VALUE)
+      CloseHandle(hErr);
   }
 

vendor/gnumake/current/w32/subproc/w32err.c

@@ -1 +1 @@
 /* Error handling for Windows
-Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
-2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+Copyright (C) 1996-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 
@@ -16 +15 @@
 this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
+#include <stdlib.h>
 #include <windows.h>
+#include "makeint.h"
 #include "w32err.h"
 
@@ -27 +28 @@
  *      comp.os.ms-windows.programmer.win32
  */
-char *
+const char *
 map_windows32_error_to_string (DWORD ercode) {
-/* __declspec (thread) necessary if you will use multiple threads on MSVC */
-#ifdef _MSC_VER
-__declspec (thread) static char szMessageBuffer[128];
-#else
-static char szMessageBuffer[128];
-#endif
-        /* Fill message buffer with a default message in
-         * case FormatMessage fails
-         */
+/*
+ * We used to have an MSVC-specific '__declspec (thread)' qualifier
+ * here, with the following comment:
+ *
+ * __declspec (thread) necessary if you will use multiple threads on MSVC
+ *
+ * However, Make was never multithreaded on Windows (except when
+ * Ctrl-C is hit, in which case the main thread is stopped
+ * immediately, so it doesn't matter in this context).  The functions
+ * on sub_proc.c that started and stopped additional threads were
+ * never used, and are now #ifdef'ed away.  Until we need more than
+ * one thread, we have no problems with the following buffer being
+ * static.  (If and when we do need it to be in thread-local storage,
+ * the corresponding GCC qualifier is '__thread'.)
+ */
+    static char szMessageBuffer[128];
+        /* Fill message buffer with a default message in
+         * case FormatMessage fails
+         */
     wsprintf (szMessageBuffer, "Error %ld\n", ercode);
 
-        /*
-         *  Special code for winsock error handling.
-         */
-        if (ercode > WSABASEERR) {
-                HMODULE hModule = GetModuleHandle("wsock32");
-                if (hModule != NULL) {
-                        FormatMessage(FORMAT_MESSAGE_FROM_HMODULE,
-                                hModule,
-                                ercode,
-                                LANG_NEUTRAL,
-                                szMessageBuffer,
-                                sizeof(szMessageBuffer),
-                                NULL);
-                        FreeLibrary(hModule);
-                }
-        } else {
-                /*
-                 *  Default system message handling
-                 */
-        FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM,
-                  NULL,
-                  ercode,
-                  LANG_NEUTRAL,
-                  szMessageBuffer,
-                  sizeof(szMessageBuffer),
-                  NULL);
-        }
+        /*
+         *  Special code for winsock error handling.
+         */
+        if (ercode > WSABASEERR) {
+#if 0
+                HMODULE hModule = GetModuleHandle("wsock32");
+                if (hModule != NULL) {
+                        FormatMessage(FORMAT_MESSAGE_FROM_HMODULE,
+                                hModule,
+                                ercode,
+                                LANG_NEUTRAL,
+                                szMessageBuffer,
+                                sizeof(szMessageBuffer),
+                                NULL);
+                        FreeLibrary(hModule);
+                }
+#else
+                O (fatal, NILF, szMessageBuffer);
+#endif
+        } else {
+                /*
+                 *  Default system message handling
+                 */
+                FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM,
+                        NULL,
+                        ercode,
+                        LANG_NEUTRAL,
+                        szMessageBuffer,
+                        sizeof(szMessageBuffer),
+                        NULL);
+        }
     return szMessageBuffer;
 }