1234 lines
35 KiB
C
1234 lines
35 KiB
C
/*=========================================================================
|
|
|
|
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;
|
|
|
|
/* 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,
|
|
cp->Win9x? CREATE_NEW_CONSOLE:DETACHED_PROCESS, 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;
|
|
|
|
/* 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;
|
|
}
|