#include <stdlib.h>
#include <stdio.h>
#include <process.h>
#include <signal.h>
#include <windows.h>
#include "sub_proc.h"
#include "proc.h"
#include "w32err.h"
#include "config.h"
#include "debug.h"
static char *make_command_line(char *shell_name, char *exec_path, char **argv);
typedef struct sub_process_t {
int sv_stdin[2];
int sv_stdout[2];
int sv_stderr[2];
int using_pipes;
char *inp;
DWORD incnt;
char * volatile outp;
volatile DWORD outcnt;
char * volatile errp;
volatile DWORD errcnt;
int pid;
int exit_code;
int signal;
long last_err;
long lerrno;
} sub_process;
static sub_process *proc_array[MAXIMUM_WAIT_OBJECTS];
static int proc_index = 0;
static int fake_exits_pending = 0;
static void
process_adjust_wait_state(sub_process* pproc)
{
int i;
if (!proc_index)
return;
for (i = 0; i < proc_index; i++)
if (proc_array[i]->pid == pproc->pid)
break;
if (i < proc_index) {
proc_index--;
if (i != proc_index)
memmove(&proc_array[i], &proc_array[i+1],
(proc_index-i) * sizeof(sub_process*));
proc_array[proc_index] = NULL;
}
}
static sub_process *
process_wait_for_any_private(void)
{
HANDLE handles[MAXIMUM_WAIT_OBJECTS];
DWORD retval, which;
int i;
if (!proc_index)
return NULL;
for (i = 0; i < proc_index; i++) {
handles[i] = (HANDLE) proc_array[i]->pid;
if (fake_exits_pending && proc_array[i]->exit_code)
break;
}
if (!fake_exits_pending) {
retval = WaitForMultipleObjects(proc_index, handles, FALSE, INFINITE);
which = retval - WAIT_OBJECT_0;
} else {
fake_exits_pending--;
retval = !WAIT_FAILED;
which = i;
}
if (retval != WAIT_FAILED) {
sub_process* pproc = proc_array[which];
process_adjust_wait_state(pproc);
return pproc;
} else
return NULL;
}
BOOL
process_kill(HANDLE proc, int signal)
{
sub_process* pproc = (sub_process*) proc;
pproc->signal = signal;
return (TerminateProcess((HANDLE) pproc->pid, signal));
}
void
process_register(HANDLE proc)
{
if (proc_index < MAXIMUM_WAIT_OBJECTS)
proc_array[proc_index++] = (sub_process *) proc;
}
int
process_used_slots(void)
{
return proc_index;
}
HANDLE
process_wait_for_any(void)
{
sub_process* pproc = process_wait_for_any_private();
if (!pproc)
return NULL;
else {
(void) process_file_io(pproc);
return ((HANDLE) pproc);
}
}
long
process_signal(HANDLE proc)
{
if (proc == INVALID_HANDLE_VALUE) return 0;
return (((sub_process *)proc)->signal);
}
long
process_last_err(HANDLE proc)
{
if (proc == INVALID_HANDLE_VALUE) return ERROR_INVALID_HANDLE;
return (((sub_process *)proc)->last_err);
}
long
process_exit_code(HANDLE proc)
{
if (proc == INVALID_HANDLE_VALUE) return EXIT_FAILURE;
return (((sub_process *)proc)->exit_code);
}
HANDLE
process_init()
{
sub_process *pproc;
HANDLE stdin_pipes[2];
HANDLE stdout_pipes[2];
HANDLE stderr_pipes[2];
SECURITY_ATTRIBUTES inherit;
BYTE sd[SECURITY_DESCRIPTOR_MIN_LENGTH];
pproc = malloc(sizeof(*pproc));
memset(pproc, 0, sizeof(*pproc));
if (!InitializeSecurityDescriptor((PSECURITY_DESCRIPTOR)(&sd),
SECURITY_DESCRIPTOR_REVISION)) {
pproc->last_err = GetLastError();
pproc->lerrno = E_SCALL;
return((HANDLE)pproc);
}
inherit.nLength = sizeof(inherit);
inherit.lpSecurityDescriptor = (PSECURITY_DESCRIPTOR)(&sd);
inherit.bInheritHandle = TRUE;
if (CreatePipe( &stdin_pipes[1], &stdin_pipes[0], &inherit, 0) == FALSE ||
CreatePipe( &stdout_pipes[0], &stdout_pipes[1], &inherit, 0) == FALSE ||
CreatePipe( &stderr_pipes[0], &stderr_pipes[1], &inherit, 0) == FALSE) {
pproc->last_err = GetLastError();
pproc->lerrno = E_SCALL;
return((HANDLE)pproc);
}
if (SetHandleInformation(stdin_pipes[0],
HANDLE_FLAG_INHERIT, 0) == FALSE ||
SetHandleInformation(stdout_pipes[0],
HANDLE_FLAG_INHERIT, 0) == FALSE ||
SetHandleInformation(stderr_pipes[0],
HANDLE_FLAG_INHERIT, 0) == FALSE) {
pproc->last_err = GetLastError();
pproc->lerrno = E_SCALL;
return((HANDLE)pproc);
}
pproc->sv_stdin[0] = (int) stdin_pipes[0];
pproc->sv_stdin[1] = (int) stdin_pipes[1];
pproc->sv_stdout[0] = (int) stdout_pipes[0];
pproc->sv_stdout[1] = (int) stdout_pipes[1];
pproc->sv_stderr[0] = (int) stderr_pipes[0];
pproc->sv_stderr[1] = (int) stderr_pipes[1];
pproc->using_pipes = 1;
pproc->lerrno = 0;
return((HANDLE)pproc);
}
HANDLE
process_init_fd(HANDLE stdinh, HANDLE stdouth, HANDLE stderrh)
{
sub_process *pproc;
pproc = malloc(sizeof(*pproc));
memset(pproc, 0, sizeof(*pproc));
pproc->sv_stdin[1] = (int) stdinh;
pproc->sv_stdout[1] = (int) stdouth;
pproc->sv_stderr[1] = (int) stderrh;
pproc->last_err = pproc->lerrno = 0;
return((HANDLE)pproc);
}
static HANDLE
find_file(char *exec_path, LPOFSTRUCT file_info)
{
HANDLE exec_handle;
char *fname;
char *ext;
fname = malloc(strlen(exec_path) + 5);
strcpy(fname, exec_path);
ext = fname + strlen(fname);
strcpy(ext, ".exe");
if ((exec_handle = (HANDLE)OpenFile(fname, file_info,
OF_READ | OF_SHARE_COMPAT)) != (HANDLE)HFILE_ERROR) {
free(fname);
return(exec_handle);
}
strcpy(ext, ".cmd");
if ((exec_handle = (HANDLE)OpenFile(fname, file_info,
OF_READ | OF_SHARE_COMPAT)) != (HANDLE)HFILE_ERROR) {
free(fname);
return(exec_handle);
}
strcpy(ext, ".bat");
if ((exec_handle = (HANDLE)OpenFile(fname, file_info,
OF_READ | OF_SHARE_COMPAT)) != (HANDLE)HFILE_ERROR) {
free(fname);
return(exec_handle);
}
if ((exec_handle = (HANDLE)OpenFile(exec_path, file_info,
OF_READ | OF_SHARE_COMPAT)) != (HANDLE)HFILE_ERROR) {
free(fname);
return(exec_handle);
}
strcpy(ext, ".com");
if ((exec_handle = (HANDLE)OpenFile(fname, file_info,
OF_READ | OF_SHARE_COMPAT)) != (HANDLE)HFILE_ERROR) {
free(fname);
return(exec_handle);
}
free(fname);
return(exec_handle);
}
long
process_begin(
HANDLE proc,
char **argv,
char **envp,
char *exec_path,
char *as_user)
{
sub_process *pproc = (sub_process *)proc;
char *shell_name = 0;
int file_not_found=0;
HANDLE exec_handle;
char buf[256];
DWORD bytes_returned;
DWORD flags;
char *command_line;
STARTUPINFO startInfo;
PROCESS_INFORMATION procInfo;
char *envblk=NULL;
OFSTRUCT file_info;
exec_handle = find_file(exec_path, &file_info);
if (exec_handle == (HANDLE)HFILE_ERROR) {
file_not_found++;
}
else {
if (ReadFile( exec_handle,
buf, sizeof(buf) - 1,
&bytes_returned, 0) == FALSE || bytes_returned < 2) {
pproc->last_err = GetLastError();
pproc->lerrno = E_IO;
CloseHandle(exec_handle);
return(-1);
}
if (buf[0] == '#' && buf[1] == '!') {
char *p;
buf[bytes_returned] = 0;
p= strchr(buf, '\n');
if (p)
*p = 0;
p = strchr(buf, '\r');
if (p)
*p = 0;
shell_name = strrchr( buf, '/');
if (shell_name) {
shell_name++;
} else {
shell_name = &buf[2];
}
}
CloseHandle(exec_handle);
}
flags = 0;
if (file_not_found)
command_line = make_command_line( shell_name, exec_path, argv);
else
command_line = make_command_line( shell_name, file_info.szPathName,
argv);
if ( command_line == NULL ) {
pproc->last_err = 0;
pproc->lerrno = E_NO_MEM;
return(-1);
}
if (envp) {
if (arr2envblk(envp, &envblk) ==FALSE) {
pproc->last_err = 0;
pproc->lerrno = E_NO_MEM;
free( command_line );
return(-1);
}
}
if ((shell_name) || (file_not_found)) {
exec_path = 0;
} else {
exec_path = file_info.szPathName;
}
GetStartupInfo(&startInfo);
startInfo.dwFlags = STARTF_USESTDHANDLES;
startInfo.lpReserved = 0;
startInfo.cbReserved2 = 0;
startInfo.lpReserved2 = 0;
startInfo.lpTitle = shell_name ? shell_name : exec_path;
startInfo.hStdInput = (HANDLE)pproc->sv_stdin[1];
startInfo.hStdOutput = (HANDLE)pproc->sv_stdout[1];
startInfo.hStdError = (HANDLE)pproc->sv_stderr[1];
if (as_user) {
if (envblk) free(envblk);
return -1;
} else {
DB (DB_JOBS, ("CreateProcess(%s,%s,...)\n",
exec_path ? exec_path : "NULL",
command_line ? command_line : "NULL"));
if (CreateProcess(
exec_path,
command_line,
NULL,
0,
TRUE,
flags,
envblk,
0,
&startInfo,
&procInfo) == FALSE) {
pproc->last_err = GetLastError();
pproc->lerrno = E_FORK;
fprintf(stderr, "process_begin: CreateProcess(%s, %s, ...) failed.\n",
exec_path ? exec_path : "NULL", command_line);
if (envblk) free(envblk);
free( command_line );
return(-1);
}
}
pproc->pid = (int)procInfo.hProcess;
CloseHandle(procInfo.hThread);
CloseHandle((HANDLE)pproc->sv_stdin[1]);
CloseHandle((HANDLE)pproc->sv_stdout[1]);
CloseHandle((HANDLE)pproc->sv_stderr[1]);
pproc->sv_stdin[1] = 0;
pproc->sv_stdout[1] = 0;
pproc->sv_stderr[1] = 0;
free( command_line );
if (envblk) free(envblk);
pproc->lerrno=0;
return 0;
}
static DWORD
proc_stdin_thread(sub_process *pproc)
{
DWORD in_done;
for (;;) {
if (WriteFile( (HANDLE) pproc->sv_stdin[0], pproc->inp, pproc->incnt,
&in_done, NULL) == FALSE)
_endthreadex(0);
if (in_done < pproc->incnt) {
pproc->incnt -= in_done;
pproc->inp += in_done;
} else {
_endthreadex(0);
}
}
return 0; }
static DWORD
proc_stdout_thread(sub_process *pproc)
{
DWORD bufsize = 1024;
char c;
DWORD nread;
pproc->outp = malloc(bufsize);
if (pproc->outp == NULL)
_endthreadex(0);
pproc->outcnt = 0;
for (;;) {
if (ReadFile( (HANDLE)pproc->sv_stdout[0], &c, 1, &nread, NULL)
== FALSE) {
_endthreadex(0);
}
if (nread == 0)
_endthreadex(0);
if (pproc->outcnt + nread > bufsize) {
bufsize += nread + 512;
pproc->outp = realloc(pproc->outp, bufsize);
if (pproc->outp == NULL) {
pproc->outcnt = 0;
_endthreadex(0);
}
}
pproc->outp[pproc->outcnt++] = c;
}
return 0;
}
static DWORD
proc_stderr_thread(sub_process *pproc)
{
DWORD bufsize = 1024;
char c;
DWORD nread;
pproc->errp = malloc(bufsize);
if (pproc->errp == NULL)
_endthreadex(0);
pproc->errcnt = 0;
for (;;) {
if (ReadFile( (HANDLE)pproc->sv_stderr[0], &c, 1, &nread, NULL) == FALSE) {
map_windows32_error_to_string(GetLastError());
_endthreadex(0);
}
if (nread == 0)
_endthreadex(0);
if (pproc->errcnt + nread > bufsize) {
bufsize += nread + 512;
pproc->errp = realloc(pproc->errp, bufsize);
if (pproc->errp == NULL) {
pproc->errcnt = 0;
_endthreadex(0);
}
}
pproc->errp[pproc->errcnt++] = c;
}
return 0;
}
long
process_pipe_io(
HANDLE proc,
char *stdin_data,
int stdin_data_len)
{
sub_process *pproc = (sub_process *)proc;
bool_t stdin_eof = FALSE, stdout_eof = FALSE, stderr_eof = FALSE;
HANDLE childhand = (HANDLE) pproc->pid;
HANDLE tStdin = NULL, tStdout = NULL, tStderr = NULL;
unsigned int dwStdin, dwStdout, dwStderr;
HANDLE wait_list[4];
DWORD wait_count;
DWORD wait_return;
HANDLE ready_hand;
bool_t child_dead = FALSE;
BOOL GetExitCodeResult;
pproc->inp = stdin_data;
pproc->incnt = stdin_data_len;
if (!pproc->inp) {
stdin_eof = TRUE;
CloseHandle((HANDLE)pproc->sv_stdin[0]);
pproc->sv_stdin[0] = 0;
} else {
tStdin = (HANDLE) _beginthreadex( 0, 1024,
(unsigned (__stdcall *) (void *))proc_stdin_thread,
pproc, 0, &dwStdin);
if (tStdin == 0) {
pproc->last_err = GetLastError();
pproc->lerrno = E_SCALL;
goto done;
}
}
tStdout = (HANDLE) _beginthreadex( 0, 1024,
(unsigned (__stdcall *) (void *))proc_stdout_thread, pproc, 0,
&dwStdout);
tStderr = (HANDLE) _beginthreadex( 0, 1024,
(unsigned (__stdcall *) (void *))proc_stderr_thread, pproc, 0,
&dwStderr);
if (tStdout == 0 || tStderr == 0) {
pproc->last_err = GetLastError();
pproc->lerrno = E_SCALL;
goto done;
}
while (!stdin_eof || !stdout_eof || !stderr_eof || !child_dead) {
wait_count = 0;
if (!stdin_eof) {
wait_list[wait_count++] = tStdin;
}
if (!stdout_eof) {
wait_list[wait_count++] = tStdout;
}
if (!stderr_eof) {
wait_list[wait_count++] = tStderr;
}
if (!child_dead) {
wait_list[wait_count++] = childhand;
}
wait_return = WaitForMultipleObjects(wait_count, wait_list,
FALSE,
child_dead? 1000 :INFINITE);
if (wait_return == WAIT_FAILED) {
pproc->last_err = GetLastError();
pproc->lerrno = E_SCALL;
goto done;
}
ready_hand = wait_list[wait_return - WAIT_OBJECT_0];
if (ready_hand == tStdin) {
CloseHandle((HANDLE)pproc->sv_stdin[0]);
pproc->sv_stdin[0] = 0;
CloseHandle(tStdin);
tStdin = 0;
stdin_eof = TRUE;
} else if (ready_hand == tStdout) {
CloseHandle((HANDLE)pproc->sv_stdout[0]);
pproc->sv_stdout[0] = 0;
CloseHandle(tStdout);
tStdout = 0;
stdout_eof = TRUE;
} else if (ready_hand == tStderr) {
CloseHandle((HANDLE)pproc->sv_stderr[0]);
pproc->sv_stderr[0] = 0;
CloseHandle(tStderr);
tStderr = 0;
stderr_eof = TRUE;
} else if (ready_hand == childhand) {
DWORD ierr;
GetExitCodeResult = GetExitCodeProcess(childhand, &ierr);
if (ierr == CONTROL_C_EXIT) {
pproc->signal = SIGINT;
} else {
pproc->exit_code = ierr;
}
if (GetExitCodeResult == FALSE) {
pproc->last_err = GetLastError();
pproc->lerrno = E_SCALL;
goto done;
}
child_dead = TRUE;
} else {
pproc->last_err = 0;
pproc->lerrno = E_FAIL;
goto done;
}
}
done:
if (tStdin != 0)
CloseHandle(tStdin);
if (tStdout != 0)
CloseHandle(tStdout);
if (tStderr != 0)
CloseHandle(tStderr);
if (pproc->lerrno)
return(-1);
else
return(0);
}
long
process_file_io(
HANDLE proc)
{
sub_process *pproc;
HANDLE childhand;
DWORD wait_return;
BOOL GetExitCodeResult;
DWORD ierr;
if (proc == NULL)
pproc = process_wait_for_any_private();
else
pproc = (sub_process *)proc;
if (!pproc)
return -1;
childhand = (HANDLE) pproc->pid;
if (pproc->sv_stdin[0]) {
CloseHandle((HANDLE)pproc->sv_stdin[0]);
pproc->sv_stdin[0] = 0;
}
if (pproc->sv_stdout[0]) {
CloseHandle((HANDLE)pproc->sv_stdout[0]);
pproc->sv_stdout[0] = 0;
}
if (pproc->sv_stderr[0]) {
CloseHandle((HANDLE)pproc->sv_stderr[0]);
pproc->sv_stderr[0] = 0;
}
wait_return = WaitForSingleObject(childhand, INFINITE);
if (wait_return != WAIT_OBJECT_0) {
pproc->last_err = GetLastError();
pproc->lerrno = E_SCALL;
goto done2;
}
GetExitCodeResult = GetExitCodeProcess(childhand, &ierr);
if (ierr == CONTROL_C_EXIT) {
pproc->signal = SIGINT;
} else {
pproc->exit_code = ierr;
}
if (GetExitCodeResult == FALSE) {
pproc->last_err = GetLastError();
pproc->lerrno = E_SCALL;
}
done2:
if (pproc->lerrno)
return(-1);
else
return(0);
}
void
process_cleanup(
HANDLE proc)
{
sub_process *pproc = (sub_process *)proc;
int i;
if (pproc->using_pipes) {
for (i= 0; i <= 1; i++) {
if ((HANDLE)pproc->sv_stdin[i])
CloseHandle((HANDLE)pproc->sv_stdin[i]);
if ((HANDLE)pproc->sv_stdout[i])
CloseHandle((HANDLE)pproc->sv_stdout[i]);
if ((HANDLE)pproc->sv_stderr[i])
CloseHandle((HANDLE)pproc->sv_stderr[i]);
}
}
if ((HANDLE)pproc->pid)
CloseHandle((HANDLE)pproc->pid);
free(pproc);
}
static char *
make_command_line( char *shell_name, char *full_exec_path, char **argv)
{
int argc = 0;
char** argvi;
int* enclose_in_quotes = NULL;
int* enclose_in_quotes_i;
unsigned int bytes_required = 0;
char* command_line;
char* command_line_i;
int cygwin_mode = 0;
int have_sh = 0;
#ifdef HAVE_CYGWIN_SHELL
have_sh = (shell_name != NULL || strstr(full_exec_path, "sh.exe"));
cygwin_mode = 1;
#endif
if (shell_name && full_exec_path) {
bytes_required
= strlen(shell_name) + 1 + strlen(full_exec_path);
if (*argv) argv++;
if (*argv) bytes_required++;
}
argvi = argv;
while (*(argvi++)) argc++;
if (argc) {
enclose_in_quotes = (int*) calloc(1, argc * sizeof(int));
if (!enclose_in_quotes) {
return NULL;
}
}
argvi = argv;
enclose_in_quotes_i = enclose_in_quotes;
while(*argvi) {
char* p = *argvi;
unsigned int backslash_count = 0;
if (!(*p)) *enclose_in_quotes_i = 1;
while(*p) {
switch (*p) {
case '\"':
bytes_required += (backslash_count + 1);
backslash_count = 0;
break;
#if !defined(HAVE_MKS_SHELL) && !defined(HAVE_CYGWIN_SHELL)
case '\\':
backslash_count++;
break;
#endif
case ' ':
case '\t':
*enclose_in_quotes_i = 1;
default:
backslash_count = 0;
break;
}
bytes_required++;
p++;
}
if (*enclose_in_quotes_i) {
bytes_required += (backslash_count + 2);
}
if (*(++argvi)) bytes_required++;
enclose_in_quotes_i++;
}
bytes_required++;
command_line = (char*) malloc(bytes_required);
if (!command_line) {
if (enclose_in_quotes) free(enclose_in_quotes);
return NULL;
}
command_line_i = command_line;
if (shell_name && full_exec_path) {
while(*shell_name) {
*(command_line_i++) = *(shell_name++);
}
*(command_line_i++) = ' ';
while(*full_exec_path) {
*(command_line_i++) = *(full_exec_path++);
}
if (*argv) {
*(command_line_i++) = ' ';
}
}
argvi = argv;
enclose_in_quotes_i = enclose_in_quotes;
while(*argvi) {
char* p = *argvi;
unsigned int backslash_count = 0;
if (*enclose_in_quotes_i) {
*(command_line_i++) = '\"';
}
while(*p) {
if (*p == '\"') {
if (cygwin_mode && have_sh) {
*(command_line_i++) = '\"';
} else {
backslash_count++;
while(backslash_count) {
*(command_line_i++) = '\\';
backslash_count--;
};
}
#if !defined(HAVE_MKS_SHELL) && !defined(HAVE_CYGWIN_SHELL)
} else if (*p == '\\') {
backslash_count++;
} else {
backslash_count = 0;
#endif
}
*(command_line_i++) = *(p++);
}
if (*enclose_in_quotes_i) {
#if !defined(HAVE_MKS_SHELL) && !defined(HAVE_CYGWIN_SHELL)
while(backslash_count--) {
*(command_line_i++) = '\\';
};
#endif
*(command_line_i++) = '\"';
}
if (*(++argvi)) {
*(command_line_i++) = ' ';
}
enclose_in_quotes_i++;
}
*command_line_i = '\0';
if (enclose_in_quotes) free(enclose_in_quotes);
return command_line;
}
HANDLE
process_easy(
char **argv,
char **envp)
{
HANDLE hIn;
HANDLE hOut;
HANDLE hErr;
HANDLE hProcess;
if (proc_index >= MAXIMUM_WAIT_OBJECTS) {
DB (DB_JOBS, ("process_easy: All process slots used up\n"));
return INVALID_HANDLE_VALUE;
}
if (DuplicateHandle(GetCurrentProcess(),
GetStdHandle(STD_INPUT_HANDLE),
GetCurrentProcess(),
&hIn,
0,
TRUE,
DUPLICATE_SAME_ACCESS) == FALSE) {
fprintf(stderr,
"process_easy: DuplicateHandle(In) failed (e=%ld)\n",
GetLastError());
return INVALID_HANDLE_VALUE;
}
if (DuplicateHandle(GetCurrentProcess(),
GetStdHandle(STD_OUTPUT_HANDLE),
GetCurrentProcess(),
&hOut,
0,
TRUE,
DUPLICATE_SAME_ACCESS) == FALSE) {
fprintf(stderr,
"process_easy: DuplicateHandle(Out) failed (e=%ld)\n",
GetLastError());
return INVALID_HANDLE_VALUE;
}
if (DuplicateHandle(GetCurrentProcess(),
GetStdHandle(STD_ERROR_HANDLE),
GetCurrentProcess(),
&hErr,
0,
TRUE,
DUPLICATE_SAME_ACCESS) == FALSE) {
fprintf(stderr,
"process_easy: DuplicateHandle(Err) failed (e=%ld)\n",
GetLastError());
return INVALID_HANDLE_VALUE;
}
hProcess = process_init_fd(hIn, hOut, hErr);
if (process_begin(hProcess, argv, envp, argv[0], NULL)) {
fake_exits_pending++;
if (!((sub_process*) hProcess)->last_err)
((sub_process*) hProcess)->last_err = -1;
((sub_process*) hProcess)->exit_code = process_last_err(hProcess);
CloseHandle(hIn);
CloseHandle(hOut);
CloseHandle(hErr);
}
process_register(hProcess);
return hProcess;
}