|
|
@@ -0,0 +1,1234 @@
|
|
|
+/*=========================================================================
|
|
|
+
|
|
|
+Program: KWSys - Kitware System Library
|
|
|
+Module: $RCSfile$
|
|
|
+Language: C++
|
|
|
+Date: $Date$
|
|
|
+Version: $Revision$
|
|
|
+
|
|
|
+Copyright (c) 2002 Kitware, Inc., Insight Consortium. All rights reserved.
|
|
|
+See http://www.cmake.org/HTML/Copyright.html for details.
|
|
|
+
|
|
|
+This software is distributed WITHOUT ANY WARRANTY; without even
|
|
|
+the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
|
|
+PURPOSE. See the above copyright notices for more information.
|
|
|
+
|
|
|
+=========================================================================*/
|
|
|
+#define KWSYS_IN_PROCESS_C
|
|
|
+#include <Process.h>
|
|
|
+
|
|
|
+/*
|
|
|
+
|
|
|
+Implementation for Windows
|
|
|
+
|
|
|
+On windows, a thread is created to wait for data on each pipe. The
|
|
|
+threads are synchronized with the main thread to simulate the use of
|
|
|
+a UNIX-style select system call.
|
|
|
+
|
|
|
+On Windows9x platforms, a small WIN32 console application is spawned
|
|
|
+in-between the calling process and the actual child to be executed.
|
|
|
+This is to work-around a problem with connecting pipes from WIN16
|
|
|
+console applications to WIN32 applications.
|
|
|
+
|
|
|
+For more information, please check Microsoft Knowledge Base Articles
|
|
|
+Q190351 and Q150956.
|
|
|
+
|
|
|
+*/
|
|
|
+
|
|
|
+#include <windows.h> /* Windows API */
|
|
|
+#include <string.h> /* strlen, strdup */
|
|
|
+#include <stdio.h> /* sprintf */
|
|
|
+#include <process.h> /* _getpid */
|
|
|
+#include <io.h> /* _unlink */
|
|
|
+
|
|
|
+/* The number of pipes for the child's output. The standard stdout
|
|
|
+ and stderr pipes are the first two. One more pipe is used on Win9x
|
|
|
+ for the forwarding executable to use in reporting problems. */
|
|
|
+#define CMPE_PIPE_COUNT 3
|
|
|
+#define CMPE_PIPE_STDOUT 0
|
|
|
+#define CMPE_PIPE_STDERR 1
|
|
|
+#define CMPE_PIPE_ERROR 2
|
|
|
+
|
|
|
+/* The maximum amount to read from a pipe at a time. */
|
|
|
+#define CMPE_PIPE_BUFFER_SIZE 1024
|
|
|
+
|
|
|
+#define kwsysEncodedWriteArrayProcessFwd kwsys(EncodedWriteArrayProcessFwd)
|
|
|
+
|
|
|
+typedef LARGE_INTEGER kwsysProcessTime;
|
|
|
+
|
|
|
+/*--------------------------------------------------------------------------*/
|
|
|
+typedef struct kwsysProcessPipeData_s kwsysProcessPipeData;
|
|
|
+static DWORD WINAPI kwsysProcessPipeThread(LPVOID ptd);
|
|
|
+static void kwsysProcessPipeThreadReadPipe(kwsysProcess* cp, kwsysProcessPipeData* td);
|
|
|
+static void kwsysProcessCleanupHandle(PHANDLE h);
|
|
|
+static void kwsysProcessCleanup(kwsysProcess* cp, int error);
|
|
|
+static int kwsysProcessGetTimeoutTime(kwsysProcess* cp, double* userTimeout,
|
|
|
+ kwsysProcessTime* timeoutTime);
|
|
|
+static int kwsysProcessGetTimeoutLeft(kwsysProcess* cp, kwsysProcessTime* timeoutTime,
|
|
|
+ kwsysProcessTime* timeoutLength);
|
|
|
+static kwsysProcessTime kwsysProcessTimeGetCurrent();
|
|
|
+static DWORD kwsysProcessTimeToDWORD(kwsysProcessTime t);
|
|
|
+static double kwsysProcessTimeToDouble(kwsysProcessTime t);
|
|
|
+static kwsysProcessTime kwsysProcessTimeFromDouble(double d);
|
|
|
+static int kwsysProcessTimeLess(kwsysProcessTime in1, kwsysProcessTime in2);
|
|
|
+static kwsysProcessTime kwsysProcessTimeAdd(kwsysProcessTime in1, kwsysProcessTime in2);
|
|
|
+static kwsysProcessTime kwsysProcessTimeSubtract(kwsysProcessTime in1, kwsysProcessTime in2);
|
|
|
+extern int kwsysEncodedWriteArrayProcessFwd9x(const char* fname);
|
|
|
+
|
|
|
+/*--------------------------------------------------------------------------*/
|
|
|
+/* A structure containing data for each pipe's thread. */
|
|
|
+struct kwsysProcessPipeData_s
|
|
|
+{
|
|
|
+ /* ------------- Data managed per instance of kwsysProcess ------------- */
|
|
|
+
|
|
|
+ /* Handle for the thread for this pipe. */
|
|
|
+ HANDLE Thread;
|
|
|
+
|
|
|
+ /* Semaphore indicating a process and pipe are available. */
|
|
|
+ HANDLE Ready;
|
|
|
+
|
|
|
+ /* Semaphore indicating when this thread's buffer is empty. */
|
|
|
+ HANDLE Empty;
|
|
|
+
|
|
|
+ /* Semaphore indicating a pipe thread has reset for another process. */
|
|
|
+ HANDLE Reset;
|
|
|
+
|
|
|
+ /* Index of this pipe. */
|
|
|
+ int Index;
|
|
|
+
|
|
|
+ /* The kwsysProcess instance owning this pipe. */
|
|
|
+ kwsysProcess* Process;
|
|
|
+
|
|
|
+ /* ------------- Data managed per call to Execute ------------- */
|
|
|
+
|
|
|
+ /* Buffer for data read in this pipe's thread. */
|
|
|
+ char DataBuffer[CMPE_PIPE_BUFFER_SIZE];
|
|
|
+
|
|
|
+ /* The length of the data stored in the buffer. */
|
|
|
+ DWORD DataLength;
|
|
|
+
|
|
|
+ /* Whether the pipe has been closed. */
|
|
|
+ int Closed;
|
|
|
+
|
|
|
+ /* Handle for the read end of this pipe. */
|
|
|
+ HANDLE Read;
|
|
|
+
|
|
|
+ /* Handle for the write end of this pipe. */
|
|
|
+ HANDLE Write;
|
|
|
+};
|
|
|
+
|
|
|
+/*--------------------------------------------------------------------------*/
|
|
|
+/* Structure containing data used to implement the child's execution. */
|
|
|
+struct kwsysProcess_s
|
|
|
+{
|
|
|
+ /* ------------- Data managed per instance of kwsysProcess ------------- */
|
|
|
+
|
|
|
+ /* The status of the process. */
|
|
|
+ int State;
|
|
|
+
|
|
|
+ /* The command line to execute. */
|
|
|
+ char* Command;
|
|
|
+
|
|
|
+ /* On Win9x platforms, the path to the forwarding executable. */
|
|
|
+ char* Win9x;
|
|
|
+
|
|
|
+ /* On Win9x platforms, the kill event for the forwarding executable. */
|
|
|
+ HANDLE Win9xKillEvent;
|
|
|
+
|
|
|
+ /* Mutex to protect the shared index used by threads to report data. */
|
|
|
+ HANDLE SharedIndexMutex;
|
|
|
+
|
|
|
+ /* Semaphore used by threads to signal data ready. */
|
|
|
+ HANDLE Full;
|
|
|
+
|
|
|
+ /* The number of pipes needed to implement the child's execution.
|
|
|
+ This is 3 on Win9x and 2 otherwise. */
|
|
|
+ int PipeCount;
|
|
|
+
|
|
|
+ /* Whether we are currently deleting this kwsysProcess instance. */
|
|
|
+ int Deleting;
|
|
|
+
|
|
|
+ /* Data specific to each pipe and its thread. */
|
|
|
+ kwsysProcessPipeData Pipe[CMPE_PIPE_COUNT];
|
|
|
+
|
|
|
+ /* ------------- Data managed per call to Execute ------------- */
|
|
|
+
|
|
|
+ /* The process exit code, if any. */
|
|
|
+ int ExitCode;
|
|
|
+
|
|
|
+ /* Index of last pipe to report data, if any. */
|
|
|
+ int CurrentIndex;
|
|
|
+
|
|
|
+ /* Index shared by threads to report data. */
|
|
|
+ int SharedIndex;
|
|
|
+
|
|
|
+ /* The timeout length. */
|
|
|
+ double Timeout;
|
|
|
+
|
|
|
+ /* Time at which the child started. */
|
|
|
+ kwsysProcessTime StartTime;
|
|
|
+
|
|
|
+ /* Time at which the child will timeout. Negative for no timeout. */
|
|
|
+ kwsysProcessTime TimeoutTime;
|
|
|
+
|
|
|
+ /* Flag for whether the process was killed. */
|
|
|
+ int Killed;
|
|
|
+
|
|
|
+ /* Flag for whether the timeout expired. */
|
|
|
+ int TimeoutExpired;
|
|
|
+
|
|
|
+ /* Flag for whether the process has terminated. */
|
|
|
+ int Terminated;
|
|
|
+
|
|
|
+ /* The number of pipes still open during execution and while waiting
|
|
|
+ for pipes to close after process termination. */
|
|
|
+ int PipesLeft;
|
|
|
+
|
|
|
+ /* Buffer for error messages (possibly from Win9x child). */
|
|
|
+ char ErrorMessage[CMPE_PIPE_BUFFER_SIZE+1];
|
|
|
+ int ErrorMessageLength;
|
|
|
+
|
|
|
+ /* The actual command line that will be used to create the process. */
|
|
|
+ char* RealCommand;
|
|
|
+
|
|
|
+ /* Windows process information data. */
|
|
|
+ PROCESS_INFORMATION ProcessInformation;
|
|
|
+};
|
|
|
+
|
|
|
+/*--------------------------------------------------------------------------*/
|
|
|
+kwsysProcess* kwsysProcess_New()
|
|
|
+{
|
|
|
+ int i;
|
|
|
+
|
|
|
+ /* Process control structure. */
|
|
|
+ kwsysProcess* cp;
|
|
|
+
|
|
|
+ /* Path to Win9x forwarding executable. */
|
|
|
+ char* win9x = 0;
|
|
|
+
|
|
|
+ /* Windows version number data. */
|
|
|
+ OSVERSIONINFO osv;
|
|
|
+
|
|
|
+ /* Allocate a process control structure. */
|
|
|
+ cp = (kwsysProcess*)malloc(sizeof(kwsysProcess));
|
|
|
+ ZeroMemory(cp, sizeof(*cp));
|
|
|
+
|
|
|
+ /* Set initial status. */
|
|
|
+ cp->State = kwsysProcess_Starting;
|
|
|
+
|
|
|
+ /* Choose a method of running the child based on version of
|
|
|
+ windows. */
|
|
|
+ ZeroMemory(&osv, sizeof(osv));
|
|
|
+ osv.dwOSVersionInfoSize = sizeof(osv);
|
|
|
+ GetVersionEx(&osv);
|
|
|
+ if(osv.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS)
|
|
|
+ {
|
|
|
+ /* This is Win9x. We need the console forwarding executable to
|
|
|
+ work-around a Windows 9x bug. */
|
|
|
+ char fwdName[_MAX_FNAME+1] = "";
|
|
|
+ char tempDir[_MAX_PATH+1] = "";
|
|
|
+
|
|
|
+ /* We will try putting the executable in the system temp
|
|
|
+ directory. */
|
|
|
+ DWORD length = GetEnvironmentVariable("TEMP", tempDir, _MAX_PATH);
|
|
|
+
|
|
|
+ /* Construct the executable name from the process id and kwsysProcess
|
|
|
+ instance. This should be unique. */
|
|
|
+ sprintf(fwdName, "cmw9xfwd_%u_%p.exe", _getpid(), cp);
|
|
|
+
|
|
|
+ /* If the environment variable "TEMP" gave us a directory, use it. */
|
|
|
+ if(length > 0 && length <= _MAX_PATH)
|
|
|
+ {
|
|
|
+ /* Make sure there is no trailing slash. */
|
|
|
+ size_t tdlen = strlen(tempDir);
|
|
|
+ if(tempDir[tdlen-1] == '/' || tempDir[tdlen-1] == '\\')
|
|
|
+ {
|
|
|
+ tempDir[tdlen-1] = 0;
|
|
|
+ --tdlen;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Allocate a buffer to hold the forwarding executable path. */
|
|
|
+ win9x = (char*)malloc(tdlen + strlen(fwdName) + 2);
|
|
|
+ if(!win9x)
|
|
|
+ {
|
|
|
+ kwsysProcess_Delete(cp);
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Construct the full path to the forwarding executable. */
|
|
|
+ sprintf(win9x, "%s/%s", tempDir, fwdName);
|
|
|
+ }
|
|
|
+
|
|
|
+ /* If we found a place to put the forwarding executable, try to
|
|
|
+ write it. */
|
|
|
+ if(win9x)
|
|
|
+ {
|
|
|
+ if(!kwsysEncodedWriteArrayProcessFwd9x(win9x))
|
|
|
+ {
|
|
|
+ /* Failed to create forwarding executable. Give up. */
|
|
|
+ free(win9x);
|
|
|
+ kwsysProcess_Delete(cp);
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ /* Failed to find a place to put forwarding executable. */
|
|
|
+ kwsysProcess_Delete(cp);
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /* We need the extra error pipe on Win9x. */
|
|
|
+ cp->Win9x = win9x;
|
|
|
+ cp->PipeCount = cp->Win9x? 3:2;
|
|
|
+
|
|
|
+ /* Initially no thread owns the mutex. Initialize semaphore to 1. */
|
|
|
+ if(!(cp->SharedIndexMutex = CreateSemaphore(0, 1, 1, 0)))
|
|
|
+ {
|
|
|
+ kwsysProcess_Delete(cp);
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Initially no data are available. Initialize semaphore to 0. */
|
|
|
+ if(!(cp->Full = CreateSemaphore(0, 0, 1, 0)))
|
|
|
+ {
|
|
|
+ kwsysProcess_Delete(cp);
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ if(cp->Win9x)
|
|
|
+ {
|
|
|
+ /* Create an event to tell the forwarding executable to kill the
|
|
|
+ child. */
|
|
|
+ SECURITY_ATTRIBUTES sa;
|
|
|
+ ZeroMemory(&sa, sizeof(sa));
|
|
|
+ sa.nLength = sizeof(sa);
|
|
|
+ sa.bInheritHandle = TRUE;
|
|
|
+ if(!(cp->Win9xKillEvent = CreateEvent(&sa, TRUE, 0, 0)))
|
|
|
+ {
|
|
|
+ kwsysProcess_Delete(cp);
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Create the thread to read each pipe. */
|
|
|
+ for(i=0; i < cp->PipeCount; ++i)
|
|
|
+ {
|
|
|
+ DWORD dummy=0;
|
|
|
+
|
|
|
+ /* Assign the thread its index. */
|
|
|
+ cp->Pipe[i].Index = i;
|
|
|
+
|
|
|
+ /* Give the thread a pointer back to the kwsysProcess instance. */
|
|
|
+ cp->Pipe[i].Process = cp;
|
|
|
+
|
|
|
+ /* The pipe is not yet ready to read. Initialize semaphore to 0. */
|
|
|
+ if(!(cp->Pipe[i].Ready = CreateSemaphore(0, 0, 1, 0)))
|
|
|
+ {
|
|
|
+ kwsysProcess_Delete(cp);
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* The pipe is not yet reset. Initialize semaphore to 0. */
|
|
|
+ if(!(cp->Pipe[i].Reset = CreateSemaphore(0, 0, 1, 0)))
|
|
|
+ {
|
|
|
+ kwsysProcess_Delete(cp);
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* The thread's buffer is initially empty. Initialize semaphore to 1. */
|
|
|
+ if(!(cp->Pipe[i].Empty = CreateSemaphore(0, 1, 1, 0)))
|
|
|
+ {
|
|
|
+ kwsysProcess_Delete(cp);
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Create the thread. It will block immediately. */
|
|
|
+ if(!(cp->Pipe[i].Thread = CreateThread(0, 0, kwsysProcessPipeThread,
|
|
|
+ &cp->Pipe[i], 0, &dummy)))
|
|
|
+ {
|
|
|
+ kwsysProcess_Delete(cp);
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return cp;
|
|
|
+}
|
|
|
+
|
|
|
+/*--------------------------------------------------------------------------*/
|
|
|
+void kwsysProcess_Delete(kwsysProcess* cp)
|
|
|
+{
|
|
|
+ int i;
|
|
|
+
|
|
|
+ /* If the process is executing, wait for it to finish. */
|
|
|
+ if(cp->State == kwsysProcess_Executing)
|
|
|
+ {
|
|
|
+ kwsysProcess_WaitForExit(cp, 0);
|
|
|
+ }
|
|
|
+
|
|
|
+ /* We are deleting the kwsysProcess instance. */
|
|
|
+ cp->Deleting = 1;
|
|
|
+
|
|
|
+ /* Terminate each of the threads. */
|
|
|
+ for(i=0; i < cp->PipeCount; ++i)
|
|
|
+ {
|
|
|
+ if(cp->Pipe[i].Thread)
|
|
|
+ {
|
|
|
+ /* Signal the thread we are ready for it. It will terminate
|
|
|
+ immediately since Deleting is set. */
|
|
|
+ ReleaseSemaphore(cp->Pipe[i].Ready, 1, 0);
|
|
|
+
|
|
|
+ /* Wait for the thread to exit. */
|
|
|
+ WaitForSingleObject(cp->Pipe[i].Thread, INFINITE);
|
|
|
+
|
|
|
+ /* Close the handle to the thread. */
|
|
|
+ kwsysProcessCleanupHandle(&cp->Pipe[i].Thread);
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Cleanup the pipe's semaphores. */
|
|
|
+ kwsysProcessCleanupHandle(&cp->Pipe[i].Ready);
|
|
|
+ kwsysProcessCleanupHandle(&cp->Pipe[i].Empty);
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Close the shared semaphores. */
|
|
|
+ kwsysProcessCleanupHandle(&cp->SharedIndexMutex);
|
|
|
+ kwsysProcessCleanupHandle(&cp->Full);
|
|
|
+
|
|
|
+ /* Close the Win9x kill event handle. */
|
|
|
+ if(cp->Win9x)
|
|
|
+ {
|
|
|
+ kwsysProcessCleanupHandle(&cp->Win9xKillEvent);
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Free memory. */
|
|
|
+ kwsysProcess_SetCommand(cp, 0);
|
|
|
+ if(cp->Win9x)
|
|
|
+ {
|
|
|
+ _unlink(cp->Win9x);
|
|
|
+ free(cp->Win9x);
|
|
|
+ }
|
|
|
+ free(cp);
|
|
|
+}
|
|
|
+
|
|
|
+/*--------------------------------------------------------------------------*/
|
|
|
+void kwsysProcess_SetCommand(kwsysProcess* cp, char const* const* command)
|
|
|
+{
|
|
|
+ if(cp->Command)
|
|
|
+ {
|
|
|
+ free(cp->Command);
|
|
|
+ cp->Command = 0;
|
|
|
+ }
|
|
|
+ if(command)
|
|
|
+ {
|
|
|
+ /* We need to construct a single string representing the command
|
|
|
+ and its arguments. We will surround each argument with
|
|
|
+ double-quotes so it can contain spaces. We need to escape
|
|
|
+ double-quotes and all backslashes before them. We also need to
|
|
|
+ escape backslashes at the end of an argument because they come
|
|
|
+ before the closing double-quote for the argument. */
|
|
|
+ char* cmd;
|
|
|
+ char const* const* arg;
|
|
|
+ int length = 0;
|
|
|
+ /* First determine the length of the final string. */
|
|
|
+ for(arg = command; *arg; ++arg)
|
|
|
+ {
|
|
|
+ /* Keep track of how many backslashes have been encountered in a
|
|
|
+ row in this argument. */
|
|
|
+ int backslashes = 0;
|
|
|
+ const char* c;
|
|
|
+
|
|
|
+ /* Add the length of the argument, plus 3 for the double quotes
|
|
|
+ and space separating the arguments. */
|
|
|
+ length += strlen(*arg) + 3;
|
|
|
+
|
|
|
+ /* Scan the string to find characters that need escaping. */
|
|
|
+ for(c=*arg; *c; ++c)
|
|
|
+ {
|
|
|
+ if(*c == '\\')
|
|
|
+ {
|
|
|
+ /* Found a backslash. It may need to be escaped later. */
|
|
|
+ ++backslashes;
|
|
|
+ }
|
|
|
+ else if(*c == '"')
|
|
|
+ {
|
|
|
+ /* Found a double-quote. We need to escape it and all
|
|
|
+ immediately preceding backslashes. */
|
|
|
+ length += backslashes + 1;
|
|
|
+ backslashes = 0;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ /* Found another character. This eliminates the possibility
|
|
|
+ that any immediately preceding backslashes will be
|
|
|
+ escaped. */
|
|
|
+ backslashes = 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /* We need to escape all ending backslashes. */
|
|
|
+ length += backslashes;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Allocate enough space for the command. We do not need an extra
|
|
|
+ byte for the terminating null because we allocated a space for
|
|
|
+ the first argument that we will not use. */
|
|
|
+ cp->Command = (char*)malloc(length);
|
|
|
+
|
|
|
+ /* Construct the command line in the allocated buffer. */
|
|
|
+ cmd = cp->Command;
|
|
|
+ for(arg = command; *arg; ++arg)
|
|
|
+ {
|
|
|
+ /* Keep track of how many backslashes have been encountered in a
|
|
|
+ row in an argument. */
|
|
|
+ int backslashes = 0;
|
|
|
+ const char* c;
|
|
|
+
|
|
|
+ /* Add the separating space if this is not the first argument. */
|
|
|
+ if(arg != command)
|
|
|
+ {
|
|
|
+ *cmd++ = ' ';
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Add the opening double-quote for this argument. */
|
|
|
+ *cmd++ = '"';
|
|
|
+
|
|
|
+ /* Add the characters of the argument, possibly escaping them. */
|
|
|
+ for(c=*arg; *c; ++c)
|
|
|
+ {
|
|
|
+ if(*c == '\\')
|
|
|
+ {
|
|
|
+ /* Found a backslash. It may need to be escaped later. */
|
|
|
+ ++backslashes;
|
|
|
+ *cmd++ = '\\';
|
|
|
+ }
|
|
|
+ else if(*c == '"')
|
|
|
+ {
|
|
|
+ /* Add enough backslashes to escape any that preceded the
|
|
|
+ double-quote. */
|
|
|
+ while(backslashes > 0)
|
|
|
+ {
|
|
|
+ --backslashes;
|
|
|
+ *cmd++ = '\\';
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Add the backslash to escape the double-quote. */
|
|
|
+ *cmd++ = '\\';
|
|
|
+
|
|
|
+ /* Add the double-quote itself. */
|
|
|
+ *cmd++ = '"';
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ /* We encountered a normal character. This eliminates any
|
|
|
+ escaping needed for preceding backslashes. Add the
|
|
|
+ character. */
|
|
|
+ backslashes = 0;
|
|
|
+ *cmd++ = *c;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Add enough backslashes to escape any trailing ones. */
|
|
|
+ while(backslashes > 0)
|
|
|
+ {
|
|
|
+ --backslashes;
|
|
|
+ *cmd++ = '\\';
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Add the opening double-quote for this argument. */
|
|
|
+ *cmd++ = '"';
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Add the terminating null character to the command line. */
|
|
|
+ *cmd++ = 0;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*--------------------------------------------------------------------------*/
|
|
|
+void kwsysProcess_SetTimeout(kwsysProcess* cp, double timeout)
|
|
|
+{
|
|
|
+ cp->Timeout = timeout;
|
|
|
+}
|
|
|
+
|
|
|
+/*--------------------------------------------------------------------------*/
|
|
|
+int kwsysProcess_GetState(kwsysProcess* cp)
|
|
|
+{
|
|
|
+ return cp->State;
|
|
|
+}
|
|
|
+
|
|
|
+/*--------------------------------------------------------------------------*/
|
|
|
+int kwsysProcess_GetExitCode(kwsysProcess* cp)
|
|
|
+{
|
|
|
+ return cp->ExitCode;
|
|
|
+}
|
|
|
+
|
|
|
+/*--------------------------------------------------------------------------*/
|
|
|
+const char* kwsysProcess_GetErrorString(kwsysProcess* cp)
|
|
|
+{
|
|
|
+ return cp->ErrorMessage;
|
|
|
+}
|
|
|
+
|
|
|
+/*--------------------------------------------------------------------------*/
|
|
|
+void kwsysProcess_Execute(kwsysProcess* cp)
|
|
|
+{
|
|
|
+ int i=0;
|
|
|
+
|
|
|
+ /* Windows child startup control data. */
|
|
|
+ STARTUPINFO si;
|
|
|
+
|
|
|
+ /* Do not execute a second time. */
|
|
|
+ if(cp->State == kwsysProcess_Executing)
|
|
|
+ {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Initialize startup info data. */
|
|
|
+ ZeroMemory(&si, sizeof(si));
|
|
|
+ si.cb = sizeof(si);
|
|
|
+
|
|
|
+ /* Reset internal status flags. */
|
|
|
+ cp->TimeoutExpired = 0;
|
|
|
+ cp->Terminated = 0;
|
|
|
+ cp->Killed = 0;
|
|
|
+
|
|
|
+ /* Reset error data. */
|
|
|
+ cp->ErrorMessage[0] = 0;
|
|
|
+ cp->ErrorMessageLength = 0;
|
|
|
+
|
|
|
+ /* Reset the Win9x kill event. */
|
|
|
+ if(cp->Win9x)
|
|
|
+ {
|
|
|
+ if(!ResetEvent(cp->Win9xKillEvent))
|
|
|
+ {
|
|
|
+ kwsysProcessCleanup(cp, 1);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Create a pipe for each child output. */
|
|
|
+ for(i=0; i < cp->PipeCount; ++i)
|
|
|
+ {
|
|
|
+ HANDLE writeEnd;
|
|
|
+ DWORD dummy=0;
|
|
|
+
|
|
|
+ /* The pipe is not closed. */
|
|
|
+ cp->Pipe[i].Closed = 0;
|
|
|
+
|
|
|
+ /* Create the pipe. Neither end is directly inherited. */
|
|
|
+ if(!CreatePipe(&cp->Pipe[i].Read, &writeEnd, 0, 0))
|
|
|
+ {
|
|
|
+ kwsysProcessCleanup(cp, 1);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Create an inherited duplicate of the write end. This also closes
|
|
|
+ the non-inherited version. */
|
|
|
+ if(!DuplicateHandle(GetCurrentProcess(), writeEnd,
|
|
|
+ GetCurrentProcess(), &cp->Pipe[i].Write,
|
|
|
+ 0, TRUE, (DUPLICATE_CLOSE_SOURCE |
|
|
|
+ DUPLICATE_SAME_ACCESS)))
|
|
|
+ {
|
|
|
+ kwsysProcessCleanup(cp, 1);
|
|
|
+ CloseHandle(writeEnd);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Construct the real command line. */
|
|
|
+ if(cp->Win9x)
|
|
|
+ {
|
|
|
+ /* Windows 9x */
|
|
|
+
|
|
|
+ /* The forwarding executable is given a handle to the error pipe
|
|
|
+ and a handle to the kill event. */
|
|
|
+ cp->RealCommand = malloc(strlen(cp->Win9x)+strlen(cp->Command)+100);
|
|
|
+ sprintf(cp->RealCommand, "%s %d %d %s", cp->Win9x,
|
|
|
+ cp->Pipe[CMPE_PIPE_ERROR].Write,
|
|
|
+ cp->Win9xKillEvent, cp->Command);
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ /* Not Windows 9x */
|
|
|
+ cp->RealCommand = strdup(cp->Command);
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Connect the child's output pipes to the threads. */
|
|
|
+ si.dwFlags = STARTF_USESTDHANDLES;
|
|
|
+ si.hStdOutput = cp->Pipe[CMPE_PIPE_STDOUT].Write;
|
|
|
+ si.hStdError = cp->Pipe[CMPE_PIPE_STDERR].Write;
|
|
|
+
|
|
|
+ /* Hide the forwarding executable console on Windows 9x. */
|
|
|
+ si.dwFlags |= STARTF_USESHOWWINDOW;
|
|
|
+ if(cp->Win9x)
|
|
|
+ {
|
|
|
+ si.wShowWindow = SW_HIDE;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ si.wShowWindow = SW_SHOWDEFAULT;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* The timeout period starts now. */
|
|
|
+ cp->StartTime = kwsysProcessTimeGetCurrent();
|
|
|
+ cp->TimeoutTime = kwsysProcessTimeFromDouble(-1);
|
|
|
+
|
|
|
+ /* CREATE THE CHILD PROCESS */
|
|
|
+ if(!CreateProcess(0, cp->RealCommand, 0, 0, TRUE, CREATE_NEW_CONSOLE, 0,
|
|
|
+ 0, &si, &cp->ProcessInformation))
|
|
|
+ {
|
|
|
+ kwsysProcessCleanup(cp, 1);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* ---- It is no longer safe to call kwsysProcessCleanup. ----- */
|
|
|
+ /* Tell the pipe threads that a process has started. */
|
|
|
+ for(i=0; i < cp->PipeCount; ++i)
|
|
|
+ {
|
|
|
+ ReleaseSemaphore(cp->Pipe[i].Ready, 1, 0);
|
|
|
+ }
|
|
|
+
|
|
|
+ /* We don't care about the child's main thread. */
|
|
|
+ kwsysProcessCleanupHandle(&cp->ProcessInformation.hThread);
|
|
|
+
|
|
|
+ /* No pipe has reported data. */
|
|
|
+ cp->CurrentIndex = CMPE_PIPE_COUNT;
|
|
|
+ cp->PipesLeft = cp->PipeCount;
|
|
|
+
|
|
|
+ /* The process has now started. */
|
|
|
+ cp->State = kwsysProcess_Executing;
|
|
|
+}
|
|
|
+
|
|
|
+/*--------------------------------------------------------------------------*/
|
|
|
+
|
|
|
+int kwsysProcess_WaitForData(kwsysProcess* cp, int pipes, char** data, int* length,
|
|
|
+ double* userTimeout)
|
|
|
+{
|
|
|
+ kwsysProcessTime userStartTime;
|
|
|
+ kwsysProcessTime timeoutLength;
|
|
|
+ kwsysProcessTime timeoutTime;
|
|
|
+ DWORD timeout;
|
|
|
+ int user;
|
|
|
+ int done = 0;
|
|
|
+ int expired = 0;
|
|
|
+ int pipeId = 0;
|
|
|
+ DWORD w;
|
|
|
+ HANDLE events[2];
|
|
|
+
|
|
|
+ /* Make sure we are executing a process. */
|
|
|
+ if(cp->State != kwsysProcess_Executing || cp->Killed || cp->TimeoutExpired)
|
|
|
+ {
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* We will wait for data until the process termiantes or data are
|
|
|
+ available. */
|
|
|
+ events[0] = cp->Full;
|
|
|
+ events[1] = cp->ProcessInformation.hProcess;
|
|
|
+
|
|
|
+ /* Record the time at which user timeout period starts. */
|
|
|
+ if(userTimeout)
|
|
|
+ {
|
|
|
+ userStartTime = kwsysProcessTimeGetCurrent();
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Calculate the time at which a timeout will expire, and whether it
|
|
|
+ is the user or process timeout. */
|
|
|
+ user = kwsysProcessGetTimeoutTime(cp, userTimeout, &timeoutTime);
|
|
|
+
|
|
|
+ /* Loop until we have a reason to return. */
|
|
|
+ while(!done && cp->PipesLeft > 0)
|
|
|
+ {
|
|
|
+ /* If we previously got data from a thread, let it know we are
|
|
|
+ done with the data. */
|
|
|
+ if(cp->CurrentIndex < CMPE_PIPE_COUNT)
|
|
|
+ {
|
|
|
+ ReleaseSemaphore(cp->Pipe[cp->CurrentIndex].Empty, 1, 0);
|
|
|
+ cp->CurrentIndex = CMPE_PIPE_COUNT;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Setup a timeout if required. */
|
|
|
+ if(kwsysProcessGetTimeoutLeft(cp, &timeoutTime, &timeoutLength))
|
|
|
+ {
|
|
|
+ /* Timeout has already expired. */
|
|
|
+ expired = 1;
|
|
|
+ done = 1;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ if(timeoutTime.QuadPart < 0)
|
|
|
+ {
|
|
|
+ timeout = INFINITE;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ timeout = kwsysProcessTimeToDWORD(timeoutLength);
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Wait for a pipe's thread to signal or the application to
|
|
|
+ terminate. */
|
|
|
+ w = WaitForMultipleObjects(cp->Terminated?1:2, events, 0, timeout);
|
|
|
+ if(w == WAIT_TIMEOUT)
|
|
|
+ {
|
|
|
+ /* Timeout has expired. */
|
|
|
+ expired = 1;
|
|
|
+ done = 1;
|
|
|
+ }
|
|
|
+ else if(w == WAIT_OBJECT_0)
|
|
|
+ {
|
|
|
+ /* Save the index of the reporting thread and release the mutex.
|
|
|
+ The thread will block until we signal its Empty mutex. */
|
|
|
+ cp->CurrentIndex = cp->SharedIndex;
|
|
|
+ ReleaseSemaphore(cp->SharedIndexMutex, 1, 0);
|
|
|
+
|
|
|
+ /* Data are available or a pipe closed. */
|
|
|
+ if(cp->Pipe[cp->CurrentIndex].Closed)
|
|
|
+ {
|
|
|
+ /* The pipe closed. */
|
|
|
+ --cp->PipesLeft;
|
|
|
+ }
|
|
|
+ else if(cp->CurrentIndex == CMPE_PIPE_ERROR)
|
|
|
+ {
|
|
|
+ /* This is data on the special error reporting pipe for Win9x.
|
|
|
+ Append it to the error buffer. */
|
|
|
+ int length = cp->Pipe[cp->CurrentIndex].DataLength;
|
|
|
+ if(length > CMPE_PIPE_BUFFER_SIZE - cp->ErrorMessageLength)
|
|
|
+ {
|
|
|
+ length = CMPE_PIPE_BUFFER_SIZE - cp->ErrorMessageLength;
|
|
|
+ }
|
|
|
+ if(length > 0)
|
|
|
+ {
|
|
|
+ memcpy(cp->ErrorMessage+cp->ErrorMessageLength,
|
|
|
+ cp->Pipe[cp->CurrentIndex].DataBuffer, length);
|
|
|
+ cp->ErrorMessageLength += length;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ cp->ErrorMessage[cp->ErrorMessageLength] = 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else if(pipes & (1 << cp->CurrentIndex))
|
|
|
+ {
|
|
|
+ /* Caller wants this data. Report it. */
|
|
|
+ *data = cp->Pipe[cp->CurrentIndex].DataBuffer;
|
|
|
+ *length = cp->Pipe[cp->CurrentIndex].DataLength;
|
|
|
+ pipeId = (1 << cp->CurrentIndex);
|
|
|
+ done = 1;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ /* Caller does not care about this pipe. Ignore the data. */
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ int i;
|
|
|
+
|
|
|
+ /* Process has terminated. */
|
|
|
+ cp->Terminated = 1;
|
|
|
+
|
|
|
+ /* Close our copies of the pipe write handles so the pipe
|
|
|
+ threads can detect end-of-data. */
|
|
|
+ for(i=0; i < cp->PipeCount; ++i)
|
|
|
+ {
|
|
|
+ kwsysProcessCleanupHandle(&cp->Pipe[i].Write);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Update the user timeout. */
|
|
|
+ if(userTimeout)
|
|
|
+ {
|
|
|
+ kwsysProcessTime userEndTime = kwsysProcessTimeGetCurrent();
|
|
|
+ kwsysProcessTime difference = kwsysProcessTimeSubtract(userEndTime,
|
|
|
+ userStartTime);
|
|
|
+ double d = kwsysProcessTimeToDouble(difference);
|
|
|
+ *userTimeout -= d;
|
|
|
+ if(*userTimeout < 0)
|
|
|
+ {
|
|
|
+ *userTimeout = 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Check what happened. */
|
|
|
+ if(pipeId)
|
|
|
+ {
|
|
|
+ /* Data are ready on a pipe. */
|
|
|
+ return pipeId;
|
|
|
+ }
|
|
|
+ else if(expired)
|
|
|
+ {
|
|
|
+ /* A timeout has expired. */
|
|
|
+ if(user)
|
|
|
+ {
|
|
|
+ /* The user timeout has expired. It has no time left. */
|
|
|
+ return kwsysProcess_Timeout;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ /* The process timeout has expired. Kill the child now. */
|
|
|
+ kwsysProcess_Kill(cp);
|
|
|
+ cp->TimeoutExpired = 1;
|
|
|
+ cp->Killed = 0;
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ /* The process has terminated and no more data are available. */
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*--------------------------------------------------------------------------*/
|
|
|
+int kwsysProcess_WaitForExit(kwsysProcess* cp, double* userTimeout)
|
|
|
+{
|
|
|
+ int i;
|
|
|
+ int pipe = 0;
|
|
|
+ int pipesLeft = cp->PipeCount;
|
|
|
+
|
|
|
+ /* Buffer for child's return value. */
|
|
|
+ int childReturnValue = 0;
|
|
|
+
|
|
|
+ /* Make sure we are executing a process. */
|
|
|
+ if(cp->State != kwsysProcess_Executing)
|
|
|
+ {
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Wait for the process to terminate. Ignore all data. */
|
|
|
+ while((pipe = kwsysProcess_WaitForData(cp, 0, 0, 0, userTimeout)) > 0)
|
|
|
+ {
|
|
|
+ if(pipe == kwsysProcess_Timeout)
|
|
|
+ {
|
|
|
+ /* The user timeout has expired. */
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /* When the last pipe closes in WaitForData, the loop terminates
|
|
|
+ without releaseing the pipe's thread. Release it now. */
|
|
|
+ if(cp->CurrentIndex < CMPE_PIPE_COUNT)
|
|
|
+ {
|
|
|
+ ReleaseSemaphore(cp->Pipe[cp->CurrentIndex].Empty, 1, 0);
|
|
|
+ cp->CurrentIndex = CMPE_PIPE_COUNT;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Wait for all pipe threads to reset. */
|
|
|
+ for(i=0; i < cp->PipeCount; ++i)
|
|
|
+ {
|
|
|
+ WaitForSingleObject(cp->Pipe[i].Reset, INFINITE);
|
|
|
+ }
|
|
|
+
|
|
|
+ /* ---- It is now safe again to call kwsysProcessCleanup. ----- */
|
|
|
+ /* Close all the pipes. */
|
|
|
+ kwsysProcessCleanup(cp, 0);
|
|
|
+
|
|
|
+ /* We are done reading all data. Wait for the child to terminate.
|
|
|
+ This will only block if we killed the child and are waiting for
|
|
|
+ it to cleanup. */
|
|
|
+ WaitForSingleObject(cp->ProcessInformation.hProcess, INFINITE);
|
|
|
+
|
|
|
+ /* Determine the outcome. */
|
|
|
+ if(cp->Killed)
|
|
|
+ {
|
|
|
+ /* We killed the child. */
|
|
|
+ cp->State = kwsysProcess_Killed;
|
|
|
+ }
|
|
|
+ else if(cp->ErrorMessageLength)
|
|
|
+ {
|
|
|
+ /* Failed to run the process. */
|
|
|
+ cp->State = kwsysProcess_Error;
|
|
|
+ }
|
|
|
+ else if(cp->TimeoutExpired)
|
|
|
+ {
|
|
|
+ /* The timeout expired. */
|
|
|
+ cp->State = kwsysProcess_Expired;
|
|
|
+ }
|
|
|
+ else if(GetExitCodeProcess(cp->ProcessInformation.hProcess,
|
|
|
+ &childReturnValue))
|
|
|
+ {
|
|
|
+ /* The child exited. */
|
|
|
+ cp->State = kwsysProcess_Exited;
|
|
|
+ cp->ExitCode = childReturnValue;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ /* Error getting the child return code. */
|
|
|
+ strcpy(cp->ErrorMessage, "Error getting child return code.");
|
|
|
+ cp->State = kwsysProcess_Error;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* The child process is terminated. */
|
|
|
+ CloseHandle(cp->ProcessInformation.hProcess);
|
|
|
+
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+/*--------------------------------------------------------------------------*/
|
|
|
+void kwsysProcess_Kill(kwsysProcess* cp)
|
|
|
+{
|
|
|
+ int i;
|
|
|
+
|
|
|
+ /* Make sure we are executing a process. */
|
|
|
+ if(cp->State != kwsysProcess_Executing || cp->TimeoutExpired || cp->Killed ||
|
|
|
+ cp->Terminated)
|
|
|
+ {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* If we are killing a process that just reported data, release
|
|
|
+ the pipe's thread. */
|
|
|
+ if(cp->CurrentIndex < CMPE_PIPE_COUNT)
|
|
|
+ {
|
|
|
+ ReleaseSemaphore(cp->Pipe[cp->CurrentIndex].Empty, 1, 0);
|
|
|
+ cp->CurrentIndex = CMPE_PIPE_COUNT;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Wake up all the pipe threads with dummy data. */
|
|
|
+ for(i=0; i < cp->PipeCount; ++i)
|
|
|
+ {
|
|
|
+ DWORD dummy;
|
|
|
+ WriteFile(cp->Pipe[i].Write, "", 1, &dummy, 0);
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Tell pipe threads to reset until we run another process. */
|
|
|
+ while(cp->PipesLeft > 0)
|
|
|
+ {
|
|
|
+ WaitForSingleObject(cp->Full, INFINITE);
|
|
|
+ cp->CurrentIndex = cp->SharedIndex;
|
|
|
+ ReleaseSemaphore(cp->SharedIndexMutex, 1, 0);
|
|
|
+ cp->Pipe[cp->CurrentIndex].Closed = 1;
|
|
|
+ ReleaseSemaphore(cp->Pipe[cp->CurrentIndex].Empty, 1, 0);
|
|
|
+ --cp->PipesLeft;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Kill the child. */
|
|
|
+ cp->Killed = 1;
|
|
|
+ if(cp->Win9x)
|
|
|
+ {
|
|
|
+ /* Windows 9x. Tell the forwarding executable to kill the child. */
|
|
|
+ SetEvent(cp->Win9xKillEvent);
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ /* Not Windows 9x. Just terminate the child. */
|
|
|
+ TerminateProcess(cp->ProcessInformation.hProcess, -1);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*--------------------------------------------------------------------------*/
|
|
|
+
|
|
|
+/*
|
|
|
+ Function executed for each pipe's thread. Argument is a pointer to
|
|
|
+ the kwsysProcessPipeData instance for this thread.
|
|
|
+*/
|
|
|
+DWORD WINAPI kwsysProcessPipeThread(LPVOID ptd)
|
|
|
+{
|
|
|
+ kwsysProcessPipeData* td = (kwsysProcessPipeData*)ptd;
|
|
|
+ kwsysProcess* cp = td->Process;
|
|
|
+
|
|
|
+ /* Wait for a process to be ready. */
|
|
|
+ while((WaitForSingleObject(td->Ready, INFINITE), !cp->Deleting))
|
|
|
+ {
|
|
|
+ /* Read output from the process for this thread's pipe. */
|
|
|
+ kwsysProcessPipeThreadReadPipe(cp, td);
|
|
|
+
|
|
|
+ /* We were signalled to exit with our buffer empty. Reset the
|
|
|
+ mutex for a new process. */
|
|
|
+ ReleaseSemaphore(td->Empty, 1, 0);
|
|
|
+
|
|
|
+ /* Signal the main thread we have reset for a new process. */
|
|
|
+ ReleaseSemaphore(td->Reset, 1, 0);
|
|
|
+ }
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+/*--------------------------------------------------------------------------*/
|
|
|
+
|
|
|
+/*
|
|
|
+ Function called in each pipe's thread to handle data for one
|
|
|
+ execution of a subprocess.
|
|
|
+*/
|
|
|
+void kwsysProcessPipeThreadReadPipe(kwsysProcess* cp, kwsysProcessPipeData* td)
|
|
|
+{
|
|
|
+ /* Wait for space in the thread's buffer. */
|
|
|
+ while((WaitForSingleObject(td->Empty, INFINITE), !td->Closed))
|
|
|
+ {
|
|
|
+ /* Read data from the pipe. This may block until data are available. */
|
|
|
+ if(!ReadFile(td->Read, td->DataBuffer, CMPE_PIPE_BUFFER_SIZE,
|
|
|
+ &td->DataLength, 0))
|
|
|
+ {
|
|
|
+ if(GetLastError() != ERROR_BROKEN_PIPE)
|
|
|
+ {
|
|
|
+ /* UNEXPECTED failure to read the pipe. */
|
|
|
+ }
|
|
|
+
|
|
|
+ /* The pipe closed. There are no more data to read. */
|
|
|
+ td->Closed = 1;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Wait for our turn to be handled by the main thread. */
|
|
|
+ WaitForSingleObject(cp->SharedIndexMutex, INFINITE);
|
|
|
+
|
|
|
+ /* Tell the main thread we have something to report. */
|
|
|
+ cp->SharedIndex = td->Index;
|
|
|
+ ReleaseSemaphore(cp->Full, 1, 0);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*--------------------------------------------------------------------------*/
|
|
|
+
|
|
|
+/* Close the given handle if it is open. Reset its value to 0. */
|
|
|
+void kwsysProcessCleanupHandle(PHANDLE h)
|
|
|
+{
|
|
|
+ if(h && *h)
|
|
|
+ {
|
|
|
+ CloseHandle(*h);
|
|
|
+ *h = 0;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*--------------------------------------------------------------------------*/
|
|
|
+
|
|
|
+/* Close all handles created by kwsysProcess_Execute. */
|
|
|
+void kwsysProcessCleanup(kwsysProcess* cp, int error)
|
|
|
+{
|
|
|
+ int i;
|
|
|
+
|
|
|
+ /* If this is an error case, report the error. */
|
|
|
+ if(error)
|
|
|
+ {
|
|
|
+ FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
|
|
|
+ 0, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
|
|
|
+ cp->ErrorMessage, CMPE_PIPE_BUFFER_SIZE, 0);
|
|
|
+ cp->State = kwsysProcess_Error;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Free memory. */
|
|
|
+ if(cp->RealCommand)
|
|
|
+ {
|
|
|
+ free(cp->RealCommand);
|
|
|
+ cp->RealCommand = 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Close each pipe. */
|
|
|
+ for(i=0; i < cp->PipeCount; ++i)
|
|
|
+ {
|
|
|
+ kwsysProcessCleanupHandle(&cp->Pipe[i].Write);
|
|
|
+ kwsysProcessCleanupHandle(&cp->Pipe[i].Read);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*--------------------------------------------------------------------------*/
|
|
|
+/* Get the time at which either the process or user timeout will
|
|
|
+ expire. Returns 1 if the user timeout is first, and 0 otherwise. */
|
|
|
+int kwsysProcessGetTimeoutTime(kwsysProcess* cp, double* userTimeout,
|
|
|
+ kwsysProcessTime* timeoutTime)
|
|
|
+{
|
|
|
+ /* The first time this is called, we need to calculate the time at
|
|
|
+ which the child will timeout. */
|
|
|
+ if(cp->Timeout && cp->TimeoutTime.QuadPart < 0)
|
|
|
+ {
|
|
|
+ kwsysProcessTime length = kwsysProcessTimeFromDouble(cp->Timeout);
|
|
|
+ cp->TimeoutTime = kwsysProcessTimeAdd(cp->StartTime, length);
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Start with process timeout. */
|
|
|
+ *timeoutTime = cp->TimeoutTime;
|
|
|
+
|
|
|
+ /* Check if the user timeout is earlier. */
|
|
|
+ if(userTimeout)
|
|
|
+ {
|
|
|
+ kwsysProcessTime currentTime = kwsysProcessTimeGetCurrent();
|
|
|
+ kwsysProcessTime userTimeoutLength = kwsysProcessTimeFromDouble(*userTimeout);
|
|
|
+ kwsysProcessTime userTimeoutTime = kwsysProcessTimeAdd(currentTime,
|
|
|
+ userTimeoutLength);
|
|
|
+ if(kwsysProcessTimeLess(userTimeoutTime, *timeoutTime))
|
|
|
+ {
|
|
|
+ *timeoutTime = userTimeoutTime;
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+/*--------------------------------------------------------------------------*/
|
|
|
+/* Get the length of time before the given timeout time arrives.
|
|
|
+ Returns 1 if the time has already arrived, and 0 otherwise. */
|
|
|
+int kwsysProcessGetTimeoutLeft(kwsysProcess* cp, kwsysProcessTime* timeoutTime,
|
|
|
+ kwsysProcessTime* timeoutLength)
|
|
|
+{
|
|
|
+ if(timeoutTime->QuadPart < 0)
|
|
|
+ {
|
|
|
+ /* No timeout time has been requested. */
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ /* Calculate the remaining time. */
|
|
|
+ kwsysProcessTime currentTime = kwsysProcessTimeGetCurrent();
|
|
|
+ *timeoutLength = kwsysProcessTimeSubtract(*timeoutTime, currentTime);
|
|
|
+ if(timeoutLength->QuadPart < 0)
|
|
|
+ {
|
|
|
+ /* Timeout has already expired. */
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ /* There is some time left. */
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*--------------------------------------------------------------------------*/
|
|
|
+kwsysProcessTime kwsysProcessTimeGetCurrent()
|
|
|
+{
|
|
|
+ kwsysProcessTime current;
|
|
|
+ FILETIME ft;
|
|
|
+ GetSystemTimeAsFileTime(&ft);
|
|
|
+ current.LowPart = ft.dwLowDateTime;
|
|
|
+ current.HighPart = ft.dwHighDateTime;
|
|
|
+ return current;
|
|
|
+}
|
|
|
+
|
|
|
+/*--------------------------------------------------------------------------*/
|
|
|
+DWORD kwsysProcessTimeToDWORD(kwsysProcessTime t)
|
|
|
+{
|
|
|
+ return (DWORD)(t.QuadPart * 0.0001);
|
|
|
+}
|
|
|
+
|
|
|
+/*--------------------------------------------------------------------------*/
|
|
|
+double kwsysProcessTimeToDouble(kwsysProcessTime t)
|
|
|
+{
|
|
|
+ return t.QuadPart * 0.0000001;
|
|
|
+}
|
|
|
+
|
|
|
+/*--------------------------------------------------------------------------*/
|
|
|
+kwsysProcessTime kwsysProcessTimeFromDouble(double d)
|
|
|
+{
|
|
|
+ kwsysProcessTime t;
|
|
|
+ t.QuadPart = (LONGLONG)(d*10000000);
|
|
|
+ return t;
|
|
|
+}
|
|
|
+
|
|
|
+/*--------------------------------------------------------------------------*/
|
|
|
+int kwsysProcessTimeLess(kwsysProcessTime in1, kwsysProcessTime in2)
|
|
|
+{
|
|
|
+ return in1.QuadPart < in2.QuadPart;
|
|
|
+}
|
|
|
+
|
|
|
+/*--------------------------------------------------------------------------*/
|
|
|
+kwsysProcessTime kwsysProcessTimeAdd(kwsysProcessTime in1, kwsysProcessTime in2)
|
|
|
+{
|
|
|
+ kwsysProcessTime out;
|
|
|
+ out.QuadPart = in1.QuadPart + in2.QuadPart;
|
|
|
+ return out;
|
|
|
+}
|
|
|
+
|
|
|
+/*--------------------------------------------------------------------------*/
|
|
|
+kwsysProcessTime kwsysProcessTimeSubtract(kwsysProcessTime in1, kwsysProcessTime in2)
|
|
|
+{
|
|
|
+ kwsysProcessTime out;
|
|
|
+ out.QuadPart = in1.QuadPart - in2.QuadPart;
|
|
|
+ return out;
|
|
|
+}
|
Brad King