ENH: Added Process execution implementation.
This commit is contained in:
Brad King
parent
89cf5d538c
commit
96ccaed54d
|
|
@ -29,9 +29,19 @@ SET(KWSYS_NO_ANSI_STRING_STREAM ${CMAKE_NO_ANSI_STRING_STREAM})
|
||||||
SET(KWSYS_NO_ANSI_FOR_SCOPE ${CMAKE_NO_ANSI_FOR_SCOPE})
|
SET(KWSYS_NO_ANSI_FOR_SCOPE ${CMAKE_NO_ANSI_FOR_SCOPE})
|
||||||
|
|
||||||
SET(CLASSES Directory RegularExpression SystemTools)
|
SET(CLASSES Directory RegularExpression SystemTools)
|
||||||
SET(HEADERS Configure)
|
SET(H Process)
|
||||||
|
SET(HXX Configure)
|
||||||
|
|
||||||
|
IF(NOT UNIX)
|
||||||
|
ADD_EXECUTABLE(${KWSYS_NAMESPACE}ProcessFwd9x ProcessFwd9x.c)
|
||||||
|
ADD_EXECUTABLE(${KWSYS_NAMESPACE}EncodeExecutable EncodeExecutable.c)
|
||||||
|
SET(SRCS ProcessWin32.c ${CMAKE_CURRENT_BINARY_DIR}/${KWSYS_NAMESPACE}ProcessFwd9xEnc.c)
|
||||||
|
SET_SOURCE_FILES_PROPERTIES(${CMAKE_CURRENT_BINARY_DIR}/${KWSYS_NAMESPACE}ProcessFwd9xEnc.c
|
||||||
|
PROPERTIES GENERATED 1)
|
||||||
|
ELSE(NOT UNIX)
|
||||||
|
SET(SRCS ProcessUNIX.c)
|
||||||
|
ENDIF(NOT UNIX)
|
||||||
|
|
||||||
SET(SRCS)
|
|
||||||
SET(KWSYS_INCLUDES)
|
SET(KWSYS_INCLUDES)
|
||||||
FOREACH(c ${CLASSES})
|
FOREACH(c ${CLASSES})
|
||||||
SET(SRCS ${SRCS} ${c}.cxx)
|
SET(SRCS ${SRCS} ${c}.cxx)
|
||||||
|
|
@ -42,7 +52,15 @@ FOREACH(c ${CLASSES})
|
||||||
${PROJECT_BINARY_DIR}/../${KWSYS_NAMESPACE}/${c}.hxx)
|
${PROJECT_BINARY_DIR}/../${KWSYS_NAMESPACE}/${c}.hxx)
|
||||||
ENDFOREACH(c)
|
ENDFOREACH(c)
|
||||||
|
|
||||||
FOREACH(h ${HEADERS})
|
FOREACH(h ${H})
|
||||||
|
CONFIGURE_FILE(${PROJECT_SOURCE_DIR}/${h}.h.in
|
||||||
|
${PROJECT_BINARY_DIR}/../${KWSYS_NAMESPACE}/${h}.h
|
||||||
|
@ONLY IMMEDIATE)
|
||||||
|
SET(KWSYS_INCLUDES ${KWSYS_INCLUDES}
|
||||||
|
${PROJECT_BINARY_DIR}/../${KWSYS_NAMESPACE}/${h}.h)
|
||||||
|
ENDFOREACH(h)
|
||||||
|
|
||||||
|
FOREACH(h ${HXX})
|
||||||
CONFIGURE_FILE(${PROJECT_SOURCE_DIR}/${h}.hxx.in
|
CONFIGURE_FILE(${PROJECT_SOURCE_DIR}/${h}.hxx.in
|
||||||
${PROJECT_BINARY_DIR}/../${KWSYS_NAMESPACE}/${h}.hxx
|
${PROJECT_BINARY_DIR}/../${KWSYS_NAMESPACE}/${h}.hxx
|
||||||
@ONLY IMMEDIATE)
|
@ONLY IMMEDIATE)
|
||||||
|
|
@ -93,3 +111,29 @@ IF(KWSYS_DEFAULTS)
|
||||||
ADD_EXECUTABLE(test1 test1.cxx)
|
ADD_EXECUTABLE(test1 test1.cxx)
|
||||||
TARGET_LINK_LIBRARIES(test1 ${KWSYS_NAMESPACE})
|
TARGET_LINK_LIBRARIES(test1 ${KWSYS_NAMESPACE})
|
||||||
ENDIF(KWSYS_DEFAULTS)
|
ENDIF(KWSYS_DEFAULTS)
|
||||||
|
|
||||||
|
IF(NOT UNIX)
|
||||||
|
SET(BIN_DIR ${CMAKE_CURRENT_BINARY_DIR})
|
||||||
|
IF(EXECUTABLE_OUTPUT_PATH)
|
||||||
|
SET(BIN_DIR ${EXECUTABLE_OUTPUT_PATH})
|
||||||
|
ENDIF(EXECUTABLE_OUTPUT_PATH)
|
||||||
|
|
||||||
|
SET(MAKE_SYSTEM)
|
||||||
|
SET(CFG_INTDIR "/${CMAKE_CFG_INTDIR}")
|
||||||
|
IF(CMAKE_BUILD_TOOL MATCHES "make")
|
||||||
|
SET(CFG_INTDIR "")
|
||||||
|
ENDIF(CMAKE_BUILD_TOOL MATCHES "make")
|
||||||
|
|
||||||
|
SET(CMD ${BIN_DIR}${CFG_INTDIR}/${KWSYS_NAMESPACE}EncodeExecutable.exe)
|
||||||
|
SET(FWD ${BIN_DIR}${CFG_INTDIR}/${KWSYS_NAMESPACE}ProcessFwd9x.exe)
|
||||||
|
ADD_CUSTOM_COMMAND(
|
||||||
|
TARGET ${KWSYS_NAMESPACE}
|
||||||
|
SOURCE ${CMAKE_CURRENT_SOURCE_DIR}/ProcessFwd9x.c
|
||||||
|
COMMAND ${CMD}
|
||||||
|
ARGS ${FWD} ${CMAKE_CURRENT_BINARY_DIR}/${KWSYS_NAMESPACE}ProcessFwd9xEnc.c
|
||||||
|
${KWSYS_NAMESPACE} ProcessFwd9x
|
||||||
|
OUTPUTS ${CMAKE_CURRENT_BINARY_DIR}/${KWSYS_NAMESPACE}ProcessFwd9xEnc.c
|
||||||
|
DEPENDS ${CMD} ${FWD})
|
||||||
|
ADD_DEPENDENCIES(${KWSYS_NAMESPACE} ${KWSYS_NAMESPACE}ProcessFwd9x
|
||||||
|
${KWSYS_NAMESPACE}EncodeExecutable)
|
||||||
|
ENDIF(NOT UNIX)
|
||||||
|
|
|
||||||
|
|
@ -0,0 +1,99 @@
|
||||||
|
/*=========================================================================
|
||||||
|
|
||||||
|
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.
|
||||||
|
|
||||||
|
=========================================================================*/
|
||||||
|
#include <stdio.h>
|
||||||
|
|
||||||
|
int main(int argc, char* argv[])
|
||||||
|
{
|
||||||
|
FILE* ifp;
|
||||||
|
FILE* ofp;
|
||||||
|
int i;
|
||||||
|
int n;
|
||||||
|
int count = 0;
|
||||||
|
unsigned char buffer[1024];
|
||||||
|
|
||||||
|
/* Check arguments. */
|
||||||
|
if(argc != 5)
|
||||||
|
{
|
||||||
|
fprintf(stderr, "Usage: %s <input> <output> <kwsys-name> <array>\n",
|
||||||
|
argv[0]);
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Open the input file. */
|
||||||
|
ifp = fopen(argv[1], "rb");
|
||||||
|
if(!ifp)
|
||||||
|
{
|
||||||
|
fprintf(stderr, "Cannot open input file: \"%s\"\n", argv[1]);
|
||||||
|
return 2;
|
||||||
|
}
|
||||||
|
ofp = fopen(argv[2], "w");
|
||||||
|
if(!ofp)
|
||||||
|
{
|
||||||
|
fprintf(stderr, "Cannot open output file: \"%s\"\n", argv[2]);
|
||||||
|
return 2;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Prepend header comment. */
|
||||||
|
fprintf(ofp, "/*\n * DO NOT EDIT\n * This file is generated by:\n");
|
||||||
|
fprintf(ofp, " * %s\n */\n\n", argv[0]);
|
||||||
|
fprintf(ofp, "#include <stdio.h>\n\n");
|
||||||
|
|
||||||
|
/* Split file up in 1024-byte chunks. */
|
||||||
|
while((n = fread(buffer, 1, 1024, ifp)) > 0)
|
||||||
|
{
|
||||||
|
fprintf(ofp, "static unsigned char kwsysEncodedArray%s_%d[%d] = {\n",
|
||||||
|
argv[4], count++, n);
|
||||||
|
for(i=0; i < n-1; ++i)
|
||||||
|
{
|
||||||
|
fprintf(ofp, "0x%02X", buffer[i]);
|
||||||
|
if(i%10 == 9)
|
||||||
|
{
|
||||||
|
fprintf(ofp, ",\n");
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
fprintf(ofp, ", ");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
fprintf(ofp, "0x%02X};\n\n", buffer[n-1]);
|
||||||
|
}
|
||||||
|
fclose(ifp);
|
||||||
|
|
||||||
|
/* Provide a function to write the data to a file. */
|
||||||
|
fprintf(ofp, "extern int %sEncodedWriteArray%s(const char* fname)\n",
|
||||||
|
argv[3], argv[4]);
|
||||||
|
fprintf(ofp, "{\n");
|
||||||
|
fprintf(ofp, " FILE* ofp = fopen(fname, \"wb\");\n");
|
||||||
|
fprintf(ofp, " if(!ofp) { return 0; }\n");
|
||||||
|
for(i=0; i < count; ++i)
|
||||||
|
{
|
||||||
|
fprintf(ofp, " if(fwrite(kwsysEncodedArray%s_%d, 1,\n"
|
||||||
|
" sizeof(kwsysEncodedArray%s_%d), ofp) !=\n"
|
||||||
|
" sizeof(kwsysEncodedArray%s_%d))\n",
|
||||||
|
argv[4], i, argv[4], i, argv[4], i);
|
||||||
|
fprintf(ofp, " {\n");
|
||||||
|
fprintf(ofp, " fclose(ofp);\n");
|
||||||
|
fprintf(ofp, " _unlink(fname);\n");
|
||||||
|
fprintf(ofp, " return 0;\n");
|
||||||
|
fprintf(ofp, " }\n");
|
||||||
|
}
|
||||||
|
fprintf(ofp, " fclose(ofp);\n");
|
||||||
|
fprintf(ofp, " return 1;\n");
|
||||||
|
fprintf(ofp, "}\n");
|
||||||
|
fclose(ofp);
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,172 @@
|
||||||
|
/*=========================================================================
|
||||||
|
|
||||||
|
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.
|
||||||
|
|
||||||
|
=========================================================================*/
|
||||||
|
#ifndef @KWSYS_NAMESPACE@_Process_h
|
||||||
|
#define @KWSYS_NAMESPACE@_Process_h
|
||||||
|
|
||||||
|
#define kwsys(x) @KWSYS_NAMESPACE@##x
|
||||||
|
#define kwsysProcess_STDOUT kwsys(Process_STDOUT)
|
||||||
|
#define kwsysProcess_STDERR kwsys(Process_STDERR)
|
||||||
|
#define kwsysProcess_Timeout kwsys(Process_Timeout)
|
||||||
|
#define kwsysProcess_Starting kwsys(Process_Starting)
|
||||||
|
#define kwsysProcess_Executing kwsys(Process_Executing)
|
||||||
|
#define kwsysProcess_Expired kwsys(Process_Expired)
|
||||||
|
#define kwsysProcess_Exited kwsys(Process_Exited)
|
||||||
|
#define kwsysProcess_Killed kwsys(Process_Killed)
|
||||||
|
#define kwsysProcess_Signalled kwsys(Process_Signalled)
|
||||||
|
#define kwsysProcess_Error kwsys(Process_Error)
|
||||||
|
#define kwsysProcess_State kwsys(Process_State)
|
||||||
|
#define kwsysProcess_Pipes_e kwsys(Process_Pipes_e)
|
||||||
|
#define kwsysProcess_State_e kwsys(Process_State_e)
|
||||||
|
#define kwsysProcess_s kwsys(Process_s)
|
||||||
|
#define kwsysProcess kwsys(Process)
|
||||||
|
#define kwsysProcess_New kwsys(Process_New)
|
||||||
|
#define kwsysProcess_Delete kwsys(Process_Delete)
|
||||||
|
#define kwsysProcess_SetCommand kwsys(Process_SetCommand)
|
||||||
|
#define kwsysProcess_SetTimeout kwsys(Process_SetTimeout)
|
||||||
|
#define kwsysProcess_GetState kwsys(Process_GetState)
|
||||||
|
#define kwsysProcess_GetExitCode kwsys(Process_GetExitCode)
|
||||||
|
#define kwsysProcess_GetErrorString kwsys(Process_GetErrorString)
|
||||||
|
#define kwsysProcess_Execute kwsys(Process_Execute)
|
||||||
|
#define kwsysProcess_WaitForData kwsys(Process_WaitForData)
|
||||||
|
#define kwsysProcess_WaitForExit kwsys(Process_WaitForExit)
|
||||||
|
#define kwsysProcess_Kill kwsys(Process_Kill)
|
||||||
|
|
||||||
|
#if defined(__cplusplus)
|
||||||
|
extern "C"
|
||||||
|
{
|
||||||
|
#endif
|
||||||
|
|
||||||
|
typedef enum kwsysProcess_Pipes_e
|
||||||
|
{
|
||||||
|
kwsysProcess_STDOUT=1,
|
||||||
|
kwsysProcess_STDERR=2,
|
||||||
|
kwsysProcess_Timeout=255
|
||||||
|
} kwsysProcess_Pipes;
|
||||||
|
|
||||||
|
typedef enum kwsysProcess_State_e
|
||||||
|
{
|
||||||
|
kwsysProcess_Starting, /* Between New and Execute; No process run yet */
|
||||||
|
kwsysProcess_Executing, /* Process is running */
|
||||||
|
kwsysProcess_Expired, /* Process timeout expired and was killed */
|
||||||
|
kwsysProcess_Exited, /* Process exited */
|
||||||
|
kwsysProcess_Killed, /* Process was killed by Kill */
|
||||||
|
kwsysProcess_Signalled, /* Process was terminated by a signal (crash / ctrl-C) */
|
||||||
|
kwsysProcess_Error /* Internal error of Process */
|
||||||
|
} kwsysProcess_State;
|
||||||
|
|
||||||
|
typedef struct kwsysProcess_s kwsysProcess;
|
||||||
|
|
||||||
|
kwsysProcess* kwsysProcess_New();
|
||||||
|
|
||||||
|
void kwsysProcess_Delete(kwsysProcess* cp);
|
||||||
|
|
||||||
|
void kwsysProcess_SetCommand(kwsysProcess* cp, char const* const* command);
|
||||||
|
|
||||||
|
void kwsysProcess_SetTimeout(kwsysProcess* cp, double timeout);
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Get the current internal state of the kwsysProcess instance
|
||||||
|
*/
|
||||||
|
int kwsysProcess_GetState(kwsysProcess* cp);
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Get process return code or when signalled, get the signal code
|
||||||
|
*/
|
||||||
|
int kwsysProcess_GetExitCode(kwsysProcess* cp);
|
||||||
|
|
||||||
|
/*
|
||||||
|
* On kwsysProcess_Error get the error message
|
||||||
|
*/
|
||||||
|
const char* kwsysProcess_GetErrorString(kwsysProcess* cp);
|
||||||
|
|
||||||
|
void kwsysProcess_Execute(kwsysProcess* cp);
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Block until data available on requested pipe or one of the timeouts expired,
|
||||||
|
* or the process exits. If the pipe is not specified, data on that pipe are
|
||||||
|
* ignored.
|
||||||
|
*
|
||||||
|
* pipes - a list of interested pipes - kwsysProcess_STDOUT | kwsysProcess_STDERR
|
||||||
|
* data - returns pointer to data if read, NULL otherwise
|
||||||
|
* length - length of the returned data
|
||||||
|
* userTimeout - timeout for the current kwsysProcess_WaitForData call
|
||||||
|
* the userTimeout will contain the remaining time
|
||||||
|
*
|
||||||
|
* Returns:
|
||||||
|
* 0 - Process exited or killed or process timeout expired with no data
|
||||||
|
* available, or no process running.
|
||||||
|
* PIPE id otherwise:
|
||||||
|
* kwsysProcess_STDOUT - if stdout is returned
|
||||||
|
* kwsysProcess_STDERR - if stderr is returned
|
||||||
|
* kwsysProcess_Timeout - if user timeout expired
|
||||||
|
*/
|
||||||
|
int kwsysProcess_WaitForData(kwsysProcess* cp, int pipes, char** data, int* length,
|
||||||
|
double* userTimeout);
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Block until the process exits or the timeout expires. If no process is
|
||||||
|
* running, return immediatly.
|
||||||
|
*
|
||||||
|
* Returns:
|
||||||
|
* 0 - When user timeout expires
|
||||||
|
* 1 - Otherwise
|
||||||
|
*/
|
||||||
|
int kwsysProcess_WaitForExit(kwsysProcess* cp, double* userTimeout);
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Kills the process. kwsysProcess_WaitForExit should still be called
|
||||||
|
* after kwsysProcess_Kill.
|
||||||
|
*/
|
||||||
|
void kwsysProcess_Kill(kwsysProcess* cp);
|
||||||
|
|
||||||
|
#if defined(__cplusplus)
|
||||||
|
} /* extern "C" */
|
||||||
|
#endif
|
||||||
|
|
||||||
|
|
||||||
|
/* If we are building a kwsysProcess .c file, let it use these macros. */
|
||||||
|
#if !defined(KWSYS_IN_PROCESS_C)
|
||||||
|
# undef kwsys
|
||||||
|
# undef kwsysProcess_STDOUT
|
||||||
|
# undef kwsysProcess_STDERR
|
||||||
|
# undef kwsysProcess_Timeout
|
||||||
|
# undef kwsysProcess_Starting
|
||||||
|
# undef kwsysProcess_Executing
|
||||||
|
# undef kwsysProcess_Expired
|
||||||
|
# undef kwsysProcess_Exited
|
||||||
|
# undef kwsysProcess_Killed
|
||||||
|
# undef kwsysProcess_Signalled
|
||||||
|
# undef kwsysProcess_Error
|
||||||
|
# undef kwsysProcess_State
|
||||||
|
# undef kwsysProcess_Pipes_e
|
||||||
|
# undef kwsysProcess_State_e
|
||||||
|
# undef kwsysProcess_s
|
||||||
|
# undef kwsysProcess
|
||||||
|
# undef kwsysProcess_New
|
||||||
|
# undef kwsysProcess_Delete
|
||||||
|
# undef kwsysProcess_SetCommand
|
||||||
|
# undef kwsysProcess_SetTimeout
|
||||||
|
# undef kwsysProcess_GetState
|
||||||
|
# undef kwsysProcess_GetExitCode
|
||||||
|
# undef kwsysProcess_GetErrorString
|
||||||
|
# undef kwsysProcess_Execute
|
||||||
|
# undef kwsysProcess_WaitForData
|
||||||
|
# undef kwsysProcess_WaitForExit
|
||||||
|
# undef kwsysProcess_Kill
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#endif
|
||||||
|
|
@ -0,0 +1,145 @@
|
||||||
|
/*=========================================================================
|
||||||
|
|
||||||
|
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.
|
||||||
|
|
||||||
|
=========================================================================*/
|
||||||
|
|
||||||
|
/*
|
||||||
|
On Windows9x platforms, this executable is spawned between a parent
|
||||||
|
process and the child it is invoking to work around a bug. See the
|
||||||
|
Win32 implementation file for details.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include <windows.h>
|
||||||
|
#include <stdio.h>
|
||||||
|
|
||||||
|
int main()
|
||||||
|
{
|
||||||
|
/* Process startup information for the real child. */
|
||||||
|
STARTUPINFO si;
|
||||||
|
PROCESS_INFORMATION pi;
|
||||||
|
|
||||||
|
/* The result of waiting for the child to exit. */
|
||||||
|
DWORD waitResult;
|
||||||
|
|
||||||
|
/* The child's process return code. */
|
||||||
|
DWORD retVal;
|
||||||
|
|
||||||
|
/* The command line used to invoke this process. */
|
||||||
|
LPSTR commandLine = GetCommandLine();
|
||||||
|
|
||||||
|
/* Pointer that will be advanced to the beginning of the command
|
||||||
|
line of the real child process. */
|
||||||
|
LPSTR cmdLine = commandLine;
|
||||||
|
|
||||||
|
/* Handle to the error reporting pipe provided by the parent. This
|
||||||
|
is parsed off the command line. */
|
||||||
|
HANDLE errorPipe = 0;
|
||||||
|
|
||||||
|
/* Handle to the event the parent uses to tell us to kill the child.
|
||||||
|
This is parsed off the command line. */
|
||||||
|
HANDLE killEvent = 0;
|
||||||
|
|
||||||
|
/* An array of the handles on which we wait when the child is
|
||||||
|
running. */
|
||||||
|
HANDLE waitHandles[2] = {0, 0};
|
||||||
|
|
||||||
|
/* Move the pointer past the name of this executable. */
|
||||||
|
if(*cmdLine == '"')
|
||||||
|
{
|
||||||
|
++cmdLine;
|
||||||
|
while(*cmdLine && *cmdLine != '"') { ++cmdLine; }
|
||||||
|
if(*cmdLine) { ++cmdLine; }
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
while(*cmdLine && *cmdLine != ' ') { ++cmdLine; }
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Parse the error pipe handle. */
|
||||||
|
while(*cmdLine && *cmdLine == ' ') { ++cmdLine; }
|
||||||
|
sscanf(cmdLine, "%d", &errorPipe);
|
||||||
|
|
||||||
|
/* Parse the kill event handle. */
|
||||||
|
while(*cmdLine && *cmdLine != ' ') { ++cmdLine; }
|
||||||
|
while(*cmdLine && *cmdLine == ' ') { ++cmdLine; }
|
||||||
|
sscanf(cmdLine, "%d", &killEvent);
|
||||||
|
|
||||||
|
/* Skip to the beginning of the command line of the real child. */
|
||||||
|
while(*cmdLine && *cmdLine != ' ') { ++cmdLine; }
|
||||||
|
while(*cmdLine && *cmdLine == ' ') { ++cmdLine; }
|
||||||
|
|
||||||
|
/* Create the subprocess. */
|
||||||
|
ZeroMemory(&si, sizeof(si));
|
||||||
|
ZeroMemory(&pi, sizeof(pi));
|
||||||
|
si.cb = sizeof(si);
|
||||||
|
si.dwFlags = STARTF_USESTDHANDLES|STARTF_USESHOWWINDOW;
|
||||||
|
si.wShowWindow = SW_SHOWDEFAULT;
|
||||||
|
si.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
|
||||||
|
si.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
|
||||||
|
si.hStdError = GetStdHandle(STD_ERROR_HANDLE);
|
||||||
|
if(!CreateProcess(0, cmdLine, 0, 0, TRUE, 0, 0, 0, &si, &pi))
|
||||||
|
{
|
||||||
|
/* Error creating the process. Report the error to the parent
|
||||||
|
process through the special error reporting pipe. */
|
||||||
|
LPVOID lpMsgBuf;
|
||||||
|
DWORD n;
|
||||||
|
FormatMessage(
|
||||||
|
FORMAT_MESSAGE_ALLOCATE_BUFFER |
|
||||||
|
FORMAT_MESSAGE_FROM_SYSTEM |
|
||||||
|
FORMAT_MESSAGE_IGNORE_INSERTS,
|
||||||
|
NULL,
|
||||||
|
GetLastError(),
|
||||||
|
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
|
||||||
|
(LPTSTR) &lpMsgBuf,
|
||||||
|
0,
|
||||||
|
NULL
|
||||||
|
);
|
||||||
|
WriteFile(errorPipe, lpMsgBuf, strlen(lpMsgBuf)+1, &n, 0);
|
||||||
|
LocalFree( lpMsgBuf );
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
CloseHandle(pi.hThread);
|
||||||
|
|
||||||
|
/* Wait for subprocess to exit or for kill event from parent. */
|
||||||
|
waitHandles[0] = killEvent;
|
||||||
|
waitHandles[1] = pi.hProcess;
|
||||||
|
waitResult = WaitForMultipleObjects(2, waitHandles, 0, INFINITE);
|
||||||
|
|
||||||
|
/* Check what happened. */
|
||||||
|
if(waitResult == WAIT_OBJECT_0)
|
||||||
|
{
|
||||||
|
/* We were asked to kill the child. */
|
||||||
|
TerminateProcess(pi.hProcess, -1);
|
||||||
|
WaitForSingleObject(pi.hProcess, INFINITE);
|
||||||
|
CloseHandle(pi.hProcess);
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
else if(GetExitCodeProcess(pi.hProcess, &retVal))
|
||||||
|
{
|
||||||
|
/* The child exited and we could get the return code. */
|
||||||
|
CloseHandle(pi.hProcess);
|
||||||
|
return retVal;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
/* The child exited and we could not get the return code. Report
|
||||||
|
the problem to the parent process. */
|
||||||
|
DWORD n;
|
||||||
|
const char* msg = "Failed to get process return code.";
|
||||||
|
WriteFile(errorPipe, msg, strlen(msg)+1, &n, 0);
|
||||||
|
CloseHandle(pi.hProcess);
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,924 @@
|
||||||
|
/*=========================================================================
|
||||||
|
|
||||||
|
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 UNIX
|
||||||
|
|
||||||
|
On UNIX, a child process is forked to exec the program. Three
|
||||||
|
output pipes from the child are read by the parent process using a
|
||||||
|
select call to block until data are ready. Two of the pipes are
|
||||||
|
stdout and stderr for the child. The third is a special error pipe
|
||||||
|
that has two purposes. First, if the child cannot exec the program,
|
||||||
|
the error is reported through the error pipe. Second, the error
|
||||||
|
pipe is left open until the child exits. This is used in
|
||||||
|
conjunction with the timeout on the select call to implement a
|
||||||
|
timeout for program even when it closes stdout and stderr.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include <stdio.h> /* snprintf */
|
||||||
|
#include <stdlib.h> /* malloc, free */
|
||||||
|
#include <string.h> /* strdup, strerror, memset */
|
||||||
|
#include <sys/time.h> /* struct timeval */
|
||||||
|
#include <sys/types.h> /* pid_t, fd_set */
|
||||||
|
#include <sys/wait.h> /* waitpid */
|
||||||
|
#include <unistd.h> /* pipe, close, fork, execvp, select, _exit */
|
||||||
|
#include <fcntl.h> /* fcntl */
|
||||||
|
#include <errno.h> /* errno */
|
||||||
|
#include <time.h> /* gettimeofday */
|
||||||
|
#include <signal.h> /* sigaction */
|
||||||
|
|
||||||
|
/* The number of pipes for the child's output. The standard stdout
|
||||||
|
and stderr pipes are the first two. One more pipe is used for the
|
||||||
|
child to report errors to the parent before the real process is
|
||||||
|
invoked. */
|
||||||
|
#define KWSYSPE_PIPE_COUNT 3
|
||||||
|
#define KWSYSPE_PIPE_STDOUT 0
|
||||||
|
#define KWSYSPE_PIPE_STDERR 1
|
||||||
|
#define KWSYSPE_PIPE_ERROR 2
|
||||||
|
|
||||||
|
/* The maximum amount to read from a pipe at a time. */
|
||||||
|
#define KWSYSPE_PIPE_BUFFER_SIZE 1024
|
||||||
|
|
||||||
|
typedef struct timeval kwsysProcessTime;
|
||||||
|
|
||||||
|
/*--------------------------------------------------------------------------*/
|
||||||
|
static void kwsysProcessInitialize(kwsysProcess* cp);
|
||||||
|
static void kwsysProcessCleanup(kwsysProcess* cp, int error);
|
||||||
|
static void kwsysProcessCleanupDescriptor(int* pfd);
|
||||||
|
static int kwsysProcessGetTimeoutTime(kwsysProcess* cp, double* userTimeout,
|
||||||
|
kwsysProcessTime* timeoutTime);
|
||||||
|
static int kwsysProcessGetTimeoutLeft(kwsysProcessTime* timeoutTime,
|
||||||
|
kwsysProcessTime* timeoutLength);
|
||||||
|
static kwsysProcessTime kwsysProcessTimeGetCurrent();
|
||||||
|
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);
|
||||||
|
static void kwsysProcessChildErrorExit(kwsysProcess* cp);
|
||||||
|
static void kwsysProcessRestoreDefaultSignalHandlers();
|
||||||
|
|
||||||
|
/*--------------------------------------------------------------------------*/
|
||||||
|
/* Structure containing data used to implement the child's execution. */
|
||||||
|
struct kwsysProcess_s
|
||||||
|
{
|
||||||
|
/* The command line to execute. */
|
||||||
|
char** Command;
|
||||||
|
|
||||||
|
/* Descriptors for the read ends of the child's output pipes. */
|
||||||
|
int PipeReadEnds[KWSYSPE_PIPE_COUNT];
|
||||||
|
|
||||||
|
/* Descriptors for the write ends of the child's output pipes. */
|
||||||
|
int PipeWriteEnds[KWSYSPE_PIPE_COUNT];
|
||||||
|
|
||||||
|
/* Buffer for pipe data. */
|
||||||
|
char PipeBuffer[KWSYSPE_PIPE_BUFFER_SIZE];
|
||||||
|
|
||||||
|
/* Process ID returned by the fork. */
|
||||||
|
pid_t ForkPID;
|
||||||
|
|
||||||
|
/* Flag for whether the child reported an error. */
|
||||||
|
int ChildError;
|
||||||
|
|
||||||
|
/* The timeout length. */
|
||||||
|
float Timeout;
|
||||||
|
|
||||||
|
/* Time at which the child started. Negative for no timeout. */
|
||||||
|
kwsysProcessTime StartTime;
|
||||||
|
|
||||||
|
/* Time at which the child will timeout. Negative for no timeout. */
|
||||||
|
kwsysProcessTime TimeoutTime;
|
||||||
|
|
||||||
|
/* Flag for whether the timeout expired. */
|
||||||
|
int TimeoutExpired;
|
||||||
|
|
||||||
|
/* The old SIGCHLD handler. */
|
||||||
|
struct sigaction OldSigChldAction;
|
||||||
|
|
||||||
|
/* The number of pipes left open during execution. */
|
||||||
|
int PipesLeft;
|
||||||
|
|
||||||
|
/* File descriptor set for call to select. */
|
||||||
|
fd_set PipeSet;
|
||||||
|
|
||||||
|
/* The current status of the child process. */
|
||||||
|
int State;
|
||||||
|
|
||||||
|
/* The exit code of the child process, if any. */
|
||||||
|
int ExitCode;
|
||||||
|
|
||||||
|
/* Whether the process was killed. */
|
||||||
|
int Killed;
|
||||||
|
|
||||||
|
/* Buffer for error message in case of failure. */
|
||||||
|
char ErrorMessage[KWSYSPE_PIPE_BUFFER_SIZE+1];
|
||||||
|
int ErrorMessageLength;
|
||||||
|
};
|
||||||
|
|
||||||
|
/*--------------------------------------------------------------------------*/
|
||||||
|
kwsysProcess* kwsysProcess_New()
|
||||||
|
{
|
||||||
|
/* Allocate a process control structure. */
|
||||||
|
kwsysProcess* cp = (kwsysProcess*)malloc(sizeof(kwsysProcess));
|
||||||
|
if(!cp)
|
||||||
|
{
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
memset(cp, 0, sizeof(kwsysProcess));
|
||||||
|
cp->State = kwsysProcess_Starting;
|
||||||
|
return cp;
|
||||||
|
}
|
||||||
|
|
||||||
|
/*--------------------------------------------------------------------------*/
|
||||||
|
void kwsysProcess_Delete(kwsysProcess* cp)
|
||||||
|
{
|
||||||
|
/* If the process is executing, wait for it to finish. */
|
||||||
|
if(cp->State == kwsysProcess_Executing)
|
||||||
|
{
|
||||||
|
kwsysProcess_WaitForExit(cp, 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Free memory. */
|
||||||
|
kwsysProcess_SetCommand(cp, 0);
|
||||||
|
free(cp);
|
||||||
|
}
|
||||||
|
|
||||||
|
/*--------------------------------------------------------------------------*/
|
||||||
|
void kwsysProcess_SetCommand(kwsysProcess* cp, char const* const* command)
|
||||||
|
{
|
||||||
|
if(cp->Command)
|
||||||
|
{
|
||||||
|
char** c = cp->Command;
|
||||||
|
while(*c)
|
||||||
|
{
|
||||||
|
free(*c++);
|
||||||
|
}
|
||||||
|
free(cp->Command);
|
||||||
|
cp->Command = 0;
|
||||||
|
}
|
||||||
|
if(command)
|
||||||
|
{
|
||||||
|
char const* const* c = command;
|
||||||
|
int n = 0;
|
||||||
|
int i = 0;
|
||||||
|
while(*c++);
|
||||||
|
n = c - command - 1;
|
||||||
|
cp->Command = (char**)malloc((n+1)*sizeof(char*));
|
||||||
|
for(i=0; i < n; ++i)
|
||||||
|
{
|
||||||
|
cp->Command[i] = strdup(command[i]);
|
||||||
|
}
|
||||||
|
cp->Command[n] = 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/*--------------------------------------------------------------------------*/
|
||||||
|
void kwsysProcess_SetTimeout(kwsysProcess* cp, double timeout)
|
||||||
|
{
|
||||||
|
cp->Timeout = timeout;
|
||||||
|
if(cp->Timeout < 0)
|
||||||
|
{
|
||||||
|
cp->Timeout = 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/*--------------------------------------------------------------------------*/
|
||||||
|
int kwsysProcess_GetState(kwsysProcess* cp)
|
||||||
|
{
|
||||||
|
return cp->State;
|
||||||
|
}
|
||||||
|
|
||||||
|
/*--------------------------------------------------------------------------*/
|
||||||
|
int kwsysProcess_GetExitCode(kwsysProcess* cp)
|
||||||
|
{
|
||||||
|
return cp->ExitCode;
|
||||||
|
}
|
||||||
|
|
||||||
|
/*--------------------------------------------------------------------------*/
|
||||||
|
const char* kwsysProcess_GetErrorString(kwsysProcess* cp)
|
||||||
|
{
|
||||||
|
if(cp->State == kwsysProcess_Error)
|
||||||
|
{
|
||||||
|
return cp->PipeBuffer;
|
||||||
|
}
|
||||||
|
return "";
|
||||||
|
}
|
||||||
|
|
||||||
|
/*--------------------------------------------------------------------------*/
|
||||||
|
void kwsysProcess_Execute(kwsysProcess* cp)
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
struct sigaction newSigChldAction;
|
||||||
|
|
||||||
|
/* Do not execute a second copy simultaneously. */
|
||||||
|
if(cp->State == kwsysProcess_Executing)
|
||||||
|
{
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Initialize the control structure for a new process. */
|
||||||
|
kwsysProcessInitialize(cp);
|
||||||
|
|
||||||
|
/* We want no special handling of SIGCHLD. Repeat call until it is
|
||||||
|
not interrupted. */
|
||||||
|
newSigChldAction.sa_handler = SIG_DFL;
|
||||||
|
while((sigaction(SIGCHLD, &newSigChldAction, &cp->OldSigChldAction) < 0) &&
|
||||||
|
(errno == EINTR));
|
||||||
|
|
||||||
|
/* Create pipes for subprocess output. */
|
||||||
|
for(i=0; i < KWSYSPE_PIPE_COUNT; ++i)
|
||||||
|
{
|
||||||
|
int p[2];
|
||||||
|
|
||||||
|
/* Create the pipe. */
|
||||||
|
if(pipe(p) < 0)
|
||||||
|
{
|
||||||
|
kwsysProcessCleanup(cp, 1);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Set close-on-exec flag on the pipe's ends. */
|
||||||
|
if((fcntl(p[0], F_SETFD, FD_CLOEXEC) < 0) ||
|
||||||
|
(fcntl(p[1], F_SETFD, FD_CLOEXEC) < 0))
|
||||||
|
{
|
||||||
|
kwsysProcessCleanup(cp, 1);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Store the pipe. */
|
||||||
|
cp->PipeReadEnds[i] = p[0];
|
||||||
|
cp->PipeWriteEnds[i] = p[1];
|
||||||
|
}
|
||||||
|
|
||||||
|
/* The timeout period starts now. */
|
||||||
|
cp->StartTime = kwsysProcessTimeGetCurrent();
|
||||||
|
cp->TimeoutTime.tv_sec = -1;
|
||||||
|
cp->TimeoutTime.tv_usec = -1;
|
||||||
|
|
||||||
|
/* Fork off a child process. */
|
||||||
|
cp->ForkPID = fork();
|
||||||
|
if(cp->ForkPID < 0)
|
||||||
|
{
|
||||||
|
kwsysProcessCleanup(cp, 1);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* If this is the child process, run the real process. */
|
||||||
|
if(cp->ForkPID == 0)
|
||||||
|
{
|
||||||
|
/* Close stdin. */
|
||||||
|
close(0);
|
||||||
|
|
||||||
|
/* Setup the stdout/stderr pipes. */
|
||||||
|
dup2(cp->PipeWriteEnds[KWSYSPE_PIPE_STDOUT], 1);
|
||||||
|
dup2(cp->PipeWriteEnds[KWSYSPE_PIPE_STDERR], 2);
|
||||||
|
|
||||||
|
/* Clear the close-on-exec flag for stdout, stderr, and the child
|
||||||
|
error report pipe. All other pipe handles will be closed when
|
||||||
|
exec succeeds. */
|
||||||
|
fcntl(1, F_SETFD, 0);
|
||||||
|
fcntl(2, F_SETFD, 0);
|
||||||
|
fcntl(cp->PipeWriteEnds[KWSYSPE_PIPE_ERROR], F_SETFD, 0);
|
||||||
|
|
||||||
|
/* Restore all default signal handlers. */
|
||||||
|
kwsysProcessRestoreDefaultSignalHandlers();
|
||||||
|
|
||||||
|
/* Execute the real process. If successful, this does not return. */
|
||||||
|
execvp(cp->Command[0], cp->Command);
|
||||||
|
|
||||||
|
/* Failure. Report error to parent and terminate. */
|
||||||
|
kwsysProcessChildErrorExit(cp);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* The parent process does not need the pipe write ends. */
|
||||||
|
for(i=0; i < KWSYSPE_PIPE_COUNT; ++i)
|
||||||
|
{
|
||||||
|
kwsysProcessCleanupDescriptor(&cp->PipeWriteEnds[i]);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* All the pipes are now open. */
|
||||||
|
cp->PipesLeft = KWSYSPE_PIPE_COUNT;
|
||||||
|
|
||||||
|
/* The process has now started. */
|
||||||
|
cp->State = kwsysProcess_Executing;
|
||||||
|
}
|
||||||
|
|
||||||
|
/*--------------------------------------------------------------------------*/
|
||||||
|
int kwsysProcess_WaitForData(kwsysProcess* cp, int pipes, char** data, int* length,
|
||||||
|
double* userTimeout)
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
int max = -1;
|
||||||
|
kwsysProcessTime* timeout = 0;
|
||||||
|
kwsysProcessTime timeoutLength;
|
||||||
|
kwsysProcessTime timeoutTime;
|
||||||
|
kwsysProcessTime userStartTime;
|
||||||
|
int user = 0;
|
||||||
|
int expired = 0;
|
||||||
|
int pipeId = 0;
|
||||||
|
int numReady = 0;
|
||||||
|
|
||||||
|
/* 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);
|
||||||
|
|
||||||
|
/* Data can only be available when pipes are open. If the process
|
||||||
|
is not running, cp->PipesLeft will be 0. */
|
||||||
|
while(cp->PipesLeft > 0)
|
||||||
|
{
|
||||||
|
/* Check for any open pipes with data reported ready by the last
|
||||||
|
call to select. */
|
||||||
|
for(i=0; i < KWSYSPE_PIPE_COUNT; ++i)
|
||||||
|
{
|
||||||
|
if(cp->PipeReadEnds[i] >= 0 &&
|
||||||
|
FD_ISSET(cp->PipeReadEnds[i], &cp->PipeSet))
|
||||||
|
{
|
||||||
|
int n;
|
||||||
|
|
||||||
|
/* We are handling this pipe now. Remove it from the set. */
|
||||||
|
FD_CLR(cp->PipeReadEnds[i], &cp->PipeSet);
|
||||||
|
|
||||||
|
/* The pipe is ready to read without blocking. Keep trying to
|
||||||
|
read until the operation is not interrupted. */
|
||||||
|
while(((n = read(cp->PipeReadEnds[i], cp->PipeBuffer,
|
||||||
|
KWSYSPE_PIPE_BUFFER_SIZE)) < 0) && (errno == EINTR));
|
||||||
|
if(n > 0)
|
||||||
|
{
|
||||||
|
/* We have data on this pipe. */
|
||||||
|
if(i == KWSYSPE_PIPE_ERROR)
|
||||||
|
{
|
||||||
|
/* This is data on the special error reporting pipe. The
|
||||||
|
child process failed to execute the program. */
|
||||||
|
cp->ChildError = 1;
|
||||||
|
if(n > KWSYSPE_PIPE_BUFFER_SIZE - cp->ErrorMessageLength)
|
||||||
|
{
|
||||||
|
n = KWSYSPE_PIPE_BUFFER_SIZE - cp->ErrorMessageLength;
|
||||||
|
}
|
||||||
|
if(n > 0)
|
||||||
|
{
|
||||||
|
memcpy(cp->ErrorMessage+cp->ErrorMessageLength,
|
||||||
|
cp->PipeBuffer, n);
|
||||||
|
cp->ErrorMessageLength += n;
|
||||||
|
cp->ErrorMessage[cp->ErrorMessageLength] = 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else if(pipes & (1 << i))
|
||||||
|
{
|
||||||
|
/* Caller wants this data. Report it. */
|
||||||
|
*data = cp->PipeBuffer;
|
||||||
|
*length = n;
|
||||||
|
pipeId = (1 << i);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
/* We are done reading from this pipe. */
|
||||||
|
kwsysProcessCleanupDescriptor(&cp->PipeReadEnds[i]);
|
||||||
|
--cp->PipesLeft;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* If we have data, break early. */
|
||||||
|
if(pipeId)
|
||||||
|
{
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Make sure the set is empty (it should always be empty here
|
||||||
|
anyway). */
|
||||||
|
FD_ZERO(&cp->PipeSet);
|
||||||
|
|
||||||
|
/* Add the pipe reading ends that are still open. */
|
||||||
|
max = -1;
|
||||||
|
for(i=0; i < KWSYSPE_PIPE_COUNT; ++i)
|
||||||
|
{
|
||||||
|
if(cp->PipeReadEnds[i] >= 0)
|
||||||
|
{
|
||||||
|
FD_SET(cp->PipeReadEnds[i], &cp->PipeSet);
|
||||||
|
if(cp->PipeReadEnds[i] > max)
|
||||||
|
{
|
||||||
|
max = cp->PipeReadEnds[i];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Make sure we have a non-empty set. */
|
||||||
|
if(max < 0)
|
||||||
|
{
|
||||||
|
/* All pipes have closed. Child has terminated. */
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Setup a timeout if required. */
|
||||||
|
if(timeoutTime.tv_sec < 0)
|
||||||
|
{
|
||||||
|
timeout = 0;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
timeout = &timeoutLength;
|
||||||
|
}
|
||||||
|
if(kwsysProcessGetTimeoutLeft(&timeoutTime, &timeoutLength))
|
||||||
|
{
|
||||||
|
/* Timeout has already expired. */
|
||||||
|
expired = 1;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Run select to block until data are available. Repeat call
|
||||||
|
until it is not interrupted. */
|
||||||
|
while(((numReady = select(max+1, &cp->PipeSet, 0, 0, timeout)) < 0) &&
|
||||||
|
(errno == EINTR));
|
||||||
|
|
||||||
|
/* Check result of select. */
|
||||||
|
if(numReady == 0)
|
||||||
|
{
|
||||||
|
/* Select's timeout expired. */
|
||||||
|
expired = 1;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
else if(numReady < 0)
|
||||||
|
{
|
||||||
|
/* Select returned an error. Leave the error description in the
|
||||||
|
pipe buffer. */
|
||||||
|
snprintf(cp->ErrorMessage, KWSYSPE_PIPE_BUFFER_SIZE,
|
||||||
|
"%s", strerror(errno));
|
||||||
|
|
||||||
|
/* Kill the child now. */
|
||||||
|
kwsysProcess_Kill(cp);
|
||||||
|
cp->Killed = 0;
|
||||||
|
cp->ChildError = 1;
|
||||||
|
cp->PipesLeft = 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* 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->Killed = 0;
|
||||||
|
cp->TimeoutExpired = 1;
|
||||||
|
cp->PipesLeft = 0;
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
/* No pipes are left open. */
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/*--------------------------------------------------------------------------*/
|
||||||
|
int kwsysProcess_WaitForExit(kwsysProcess* cp, double* userTimeout)
|
||||||
|
{
|
||||||
|
int result = 0;
|
||||||
|
int status = 0;
|
||||||
|
int pipe = 0;
|
||||||
|
|
||||||
|
/* Make sure we are executing a process. */
|
||||||
|
if(cp->State != kwsysProcess_Executing)
|
||||||
|
{
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Wait for all the pipes to close. Ignore all data. */
|
||||||
|
while((pipe = kwsysProcess_WaitForData(cp, 0, 0, 0, userTimeout)) > 0)
|
||||||
|
{
|
||||||
|
if(pipe == kwsysProcess_Timeout)
|
||||||
|
{
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Wait for the child to terminate. The process should have already
|
||||||
|
exited because KWSYSPE_PIPE_ERROR has been closed by this point.
|
||||||
|
Repeat the call until it is not interrupted. */
|
||||||
|
while(((result = waitpid(cp->ForkPID, &status, 0)) < 0) && (errno == EINTR));
|
||||||
|
if(result <= 0)
|
||||||
|
{
|
||||||
|
/* Unexpected error. */
|
||||||
|
kwsysProcessCleanup(cp, 1);
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Check whether the child reported an error invoking the process. */
|
||||||
|
if(cp->ChildError)
|
||||||
|
{
|
||||||
|
/* The error message is already in its buffer. Tell
|
||||||
|
kwsysProcessCleanup to not create it. */
|
||||||
|
kwsysProcessCleanup(cp, 0);
|
||||||
|
cp->State = kwsysProcess_Error;
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Determine the outcome. */
|
||||||
|
if(cp->Killed)
|
||||||
|
{
|
||||||
|
/* We killed the child. */
|
||||||
|
cp->State = kwsysProcess_Killed;
|
||||||
|
}
|
||||||
|
else if(cp->TimeoutExpired)
|
||||||
|
{
|
||||||
|
/* The timeout expired. */
|
||||||
|
cp->State = kwsysProcess_Expired;
|
||||||
|
}
|
||||||
|
else if(WIFEXITED(status))
|
||||||
|
{
|
||||||
|
/* The child exited. */
|
||||||
|
cp->State = kwsysProcess_Exited;
|
||||||
|
cp->ExitCode = (int)WEXITSTATUS(status);
|
||||||
|
}
|
||||||
|
else if(WIFSIGNALED(status))
|
||||||
|
{
|
||||||
|
/* The child received an unhandled signal. */
|
||||||
|
cp->State = kwsysProcess_Signalled;
|
||||||
|
cp->ExitCode = (int)WTERMSIG(status);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
/* Error getting the child return code. */
|
||||||
|
strcpy(cp->ErrorMessage, "Error getting child return code.");
|
||||||
|
cp->State = kwsysProcess_Error;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Normal cleanup. */
|
||||||
|
kwsysProcessCleanup(cp, 0);
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
/*--------------------------------------------------------------------------*/
|
||||||
|
void kwsysProcess_Kill(kwsysProcess* cp)
|
||||||
|
{
|
||||||
|
/* Make sure we are executing a process. */
|
||||||
|
if(cp->State != kwsysProcess_Executing)
|
||||||
|
{
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Kill the child. */
|
||||||
|
cp->Killed = 1;
|
||||||
|
kill(cp->ForkPID, SIGKILL);
|
||||||
|
}
|
||||||
|
|
||||||
|
/*--------------------------------------------------------------------------*/
|
||||||
|
/* Initialize a process control structure for kwsysProcess_Execute. */
|
||||||
|
void kwsysProcessInitialize(kwsysProcess* cp)
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
for(i=0; i < KWSYSPE_PIPE_COUNT; ++i)
|
||||||
|
{
|
||||||
|
cp->PipeReadEnds[i] = -1;
|
||||||
|
cp->PipeWriteEnds[i] = -1;
|
||||||
|
}
|
||||||
|
cp->ForkPID = -1;
|
||||||
|
cp->ChildError = 0;
|
||||||
|
cp->StartTime.tv_sec = -1;
|
||||||
|
cp->StartTime.tv_usec = -1;
|
||||||
|
cp->TimeoutTime.tv_sec = -1;
|
||||||
|
cp->TimeoutTime.tv_usec = -1;
|
||||||
|
cp->TimeoutExpired = 0;
|
||||||
|
cp->PipesLeft = 0;
|
||||||
|
FD_ZERO(&cp->PipeSet);
|
||||||
|
cp->State = kwsysProcess_Starting;
|
||||||
|
cp->Killed = 0;
|
||||||
|
cp->ExitCode = 0;
|
||||||
|
cp->ErrorMessage[0] = 0;
|
||||||
|
cp->ErrorMessageLength = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/*--------------------------------------------------------------------------*/
|
||||||
|
/* Free all resources used by the given kwsysProcess instance that were
|
||||||
|
allocated by kwsysProcess_Execute. */
|
||||||
|
void kwsysProcessCleanup(kwsysProcess* cp, int error)
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
|
||||||
|
/* If cleaning up due to an error, report the error message. */
|
||||||
|
if(error)
|
||||||
|
{
|
||||||
|
snprintf(cp->ErrorMessage, KWSYSPE_PIPE_BUFFER_SIZE, "%s", strerror(errno));
|
||||||
|
cp->State = kwsysProcess_Error;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Restore the SIGCHLD handler. */
|
||||||
|
while((sigaction(SIGCHLD, &cp->OldSigChldAction, 0) < 0) &&
|
||||||
|
(errno == EINTR));
|
||||||
|
|
||||||
|
/* Close pipe handles. */
|
||||||
|
for(i=0; i < KWSYSPE_PIPE_COUNT; ++i)
|
||||||
|
{
|
||||||
|
kwsysProcessCleanupDescriptor(&cp->PipeReadEnds[i]);
|
||||||
|
kwsysProcessCleanupDescriptor(&cp->PipeWriteEnds[i]);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/*--------------------------------------------------------------------------*/
|
||||||
|
/* Close the given file descriptor if it is open. Reset its value to -1. */
|
||||||
|
void kwsysProcessCleanupDescriptor(int* pfd)
|
||||||
|
{
|
||||||
|
if(pfd && *pfd >= 0)
|
||||||
|
{
|
||||||
|
/* Keep trying to close until it is not interrupted by a
|
||||||
|
* signal. */
|
||||||
|
while((close(*pfd) < 0) && (errno == EINTR));
|
||||||
|
*pfd = -1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/*--------------------------------------------------------------------------*/
|
||||||
|
/* 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.tv_sec < 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(kwsysProcessTime* timeoutTime,
|
||||||
|
kwsysProcessTime* timeoutLength)
|
||||||
|
{
|
||||||
|
if(timeoutTime->tv_sec < 0)
|
||||||
|
{
|
||||||
|
/* No timeout time has been requested. */
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
/* Calculate the remaining time. */
|
||||||
|
kwsysProcessTime currentTime = kwsysProcessTimeGetCurrent();
|
||||||
|
*timeoutLength = kwsysProcessTimeSubtract(*timeoutTime, currentTime);
|
||||||
|
if(timeoutLength->tv_sec < 0)
|
||||||
|
{
|
||||||
|
/* Timeout has already expired. */
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
/* There is some time left. */
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/*--------------------------------------------------------------------------*/
|
||||||
|
kwsysProcessTime kwsysProcessTimeGetCurrent()
|
||||||
|
{
|
||||||
|
kwsysProcessTime current;
|
||||||
|
gettimeofday(¤t, 0);
|
||||||
|
return current;
|
||||||
|
}
|
||||||
|
|
||||||
|
/*--------------------------------------------------------------------------*/
|
||||||
|
double kwsysProcessTimeToDouble(kwsysProcessTime t)
|
||||||
|
{
|
||||||
|
return (double)t.tv_sec + t.tv_usec*0.000001;
|
||||||
|
}
|
||||||
|
|
||||||
|
/*--------------------------------------------------------------------------*/
|
||||||
|
kwsysProcessTime kwsysProcessTimeFromDouble(double d)
|
||||||
|
{
|
||||||
|
kwsysProcessTime t;
|
||||||
|
t.tv_sec = (long)d;
|
||||||
|
t.tv_usec = (long)((d-t.tv_sec)*1000000);
|
||||||
|
return t;
|
||||||
|
}
|
||||||
|
|
||||||
|
/*--------------------------------------------------------------------------*/
|
||||||
|
int kwsysProcessTimeLess(kwsysProcessTime in1, kwsysProcessTime in2)
|
||||||
|
{
|
||||||
|
return ((in1.tv_sec < in2.tv_sec) ||
|
||||||
|
((in1.tv_sec == in2.tv_sec) && (in1.tv_usec < in2.tv_usec)));
|
||||||
|
}
|
||||||
|
|
||||||
|
/*--------------------------------------------------------------------------*/
|
||||||
|
kwsysProcessTime kwsysProcessTimeAdd(kwsysProcessTime in1, kwsysProcessTime in2)
|
||||||
|
{
|
||||||
|
kwsysProcessTime out;
|
||||||
|
out.tv_sec = in1.tv_sec + in2.tv_sec;
|
||||||
|
out.tv_usec = in1.tv_usec + in2.tv_usec;
|
||||||
|
if(out.tv_usec > 1000000)
|
||||||
|
{
|
||||||
|
out.tv_usec -= 1000000;
|
||||||
|
out.tv_sec += 1;
|
||||||
|
}
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
|
||||||
|
/*--------------------------------------------------------------------------*/
|
||||||
|
kwsysProcessTime kwsysProcessTimeSubtract(kwsysProcessTime in1, kwsysProcessTime in2)
|
||||||
|
{
|
||||||
|
kwsysProcessTime out;
|
||||||
|
out.tv_sec = in1.tv_sec - in2.tv_sec;
|
||||||
|
out.tv_usec = in1.tv_usec - in2.tv_usec;
|
||||||
|
if(out.tv_usec < 0)
|
||||||
|
{
|
||||||
|
out.tv_usec += 1000000;
|
||||||
|
out.tv_sec -= 1;
|
||||||
|
}
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
|
||||||
|
/*--------------------------------------------------------------------------*/
|
||||||
|
/* When the child process encounters an error before its program is
|
||||||
|
invoked, this is called to report the error to the parent and
|
||||||
|
exit. */
|
||||||
|
void kwsysProcessChildErrorExit(kwsysProcess* cp)
|
||||||
|
{
|
||||||
|
/* Construct the error message. */
|
||||||
|
char buffer[KWSYSPE_PIPE_BUFFER_SIZE];
|
||||||
|
snprintf(buffer, KWSYSPE_PIPE_BUFFER_SIZE, "%s", strerror(errno));
|
||||||
|
|
||||||
|
/* Report the error to the parent through the special pipe. */
|
||||||
|
write(cp->PipeWriteEnds[KWSYSPE_PIPE_ERROR], buffer, strlen(buffer));
|
||||||
|
|
||||||
|
/* Terminate without cleanup. */
|
||||||
|
_exit(1);
|
||||||
|
}
|
||||||
|
|
||||||
|
/*--------------------------------------------------------------------------*/
|
||||||
|
/* Restores all signal handlers to their default values. */
|
||||||
|
void kwsysProcessRestoreDefaultSignalHandlers()
|
||||||
|
{
|
||||||
|
struct sigaction act;
|
||||||
|
act.sa_handler = SIG_DFL;
|
||||||
|
#ifdef SIGHUP
|
||||||
|
sigaction(SIGHUP, &act, 0);
|
||||||
|
#endif
|
||||||
|
#ifdef SIGINT
|
||||||
|
sigaction(SIGINT, &act, 0);
|
||||||
|
#endif
|
||||||
|
#ifdef SIGQUIT
|
||||||
|
sigaction(SIGQUIT, &act, 0);
|
||||||
|
#endif
|
||||||
|
#ifdef SIGILL
|
||||||
|
sigaction(SIGILL, &act, 0);
|
||||||
|
#endif
|
||||||
|
#ifdef SIGTRAP
|
||||||
|
sigaction(SIGTRAP, &act, 0);
|
||||||
|
#endif
|
||||||
|
#ifdef SIGABRT
|
||||||
|
sigaction(SIGABRT, &act, 0);
|
||||||
|
#endif
|
||||||
|
#ifdef SIGIOT
|
||||||
|
sigaction(SIGIOT, &act, 0);
|
||||||
|
#endif
|
||||||
|
#ifdef SIGBUS
|
||||||
|
sigaction(SIGBUS, &act, 0);
|
||||||
|
#endif
|
||||||
|
#ifdef SIGFPE
|
||||||
|
sigaction(SIGFPE, &act, 0);
|
||||||
|
#endif
|
||||||
|
#ifdef SIGUSR1
|
||||||
|
sigaction(SIGUSR1, &act, 0);
|
||||||
|
#endif
|
||||||
|
#ifdef SIGSEGV
|
||||||
|
sigaction(SIGSEGV, &act, 0);
|
||||||
|
#endif
|
||||||
|
#ifdef SIGUSR2
|
||||||
|
sigaction(SIGUSR2, &act, 0);
|
||||||
|
#endif
|
||||||
|
#ifdef SIGPIPE
|
||||||
|
sigaction(SIGPIPE, &act, 0);
|
||||||
|
#endif
|
||||||
|
#ifdef SIGALRM
|
||||||
|
sigaction(SIGALRM, &act, 0);
|
||||||
|
#endif
|
||||||
|
#ifdef SIGTERM
|
||||||
|
sigaction(SIGTERM, &act, 0);
|
||||||
|
#endif
|
||||||
|
#ifdef SIGSTKFLT
|
||||||
|
sigaction(SIGSTKFLT, &act, 0);
|
||||||
|
#endif
|
||||||
|
#ifdef SIGCLD
|
||||||
|
sigaction(SIGCLD, &act, 0);
|
||||||
|
#endif
|
||||||
|
#ifdef SIGCHLD
|
||||||
|
sigaction(SIGCHLD, &act, 0);
|
||||||
|
#endif
|
||||||
|
#ifdef SIGCONT
|
||||||
|
sigaction(SIGCONT, &act, 0);
|
||||||
|
#endif
|
||||||
|
#ifdef SIGTSTP
|
||||||
|
sigaction(SIGTSTP, &act, 0);
|
||||||
|
#endif
|
||||||
|
#ifdef SIGTTIN
|
||||||
|
sigaction(SIGTTIN, &act, 0);
|
||||||
|
#endif
|
||||||
|
#ifdef SIGTTOU
|
||||||
|
sigaction(SIGTTOU, &act, 0);
|
||||||
|
#endif
|
||||||
|
#ifdef SIGURG
|
||||||
|
sigaction(SIGURG, &act, 0);
|
||||||
|
#endif
|
||||||
|
#ifdef SIGXCPU
|
||||||
|
sigaction(SIGXCPU, &act, 0);
|
||||||
|
#endif
|
||||||
|
#ifdef SIGXFSZ
|
||||||
|
sigaction(SIGXFSZ, &act, 0);
|
||||||
|
#endif
|
||||||
|
#ifdef SIGVTALRM
|
||||||
|
sigaction(SIGVTALRM, &act, 0);
|
||||||
|
#endif
|
||||||
|
#ifdef SIGPROF
|
||||||
|
sigaction(SIGPROF, &act, 0);
|
||||||
|
#endif
|
||||||
|
#ifdef SIGWINCH
|
||||||
|
sigaction(SIGWINCH, &act, 0);
|
||||||
|
#endif
|
||||||
|
#ifdef SIGPOLL
|
||||||
|
sigaction(SIGPOLL, &act, 0);
|
||||||
|
#endif
|
||||||
|
#ifdef SIGIO
|
||||||
|
sigaction(SIGIO, &act, 0);
|
||||||
|
#endif
|
||||||
|
#ifdef SIGPWR
|
||||||
|
sigaction(SIGPWR, &act, 0);
|
||||||
|
#endif
|
||||||
|
#ifdef SIGSYS
|
||||||
|
sigaction(SIGSYS, &act, 0);
|
||||||
|
#endif
|
||||||
|
#ifdef SIGUNUSED
|
||||||
|
sigaction(SIGUNUSED, &act, 0);
|
||||||
|
#endif
|
||||||
|
}
|
||||||
File diff suppressed because it is too large
Load Diff
Loading…
Reference in New Issue