|
|
|
@ -19,18 +19,772 @@ |
|
|
|
* IN THE SOFTWARE. |
|
|
|
*/ |
|
|
|
|
|
|
|
#include <assert.h> |
|
|
|
|
|
|
|
#include "uv.h" |
|
|
|
#include "../uv-common.h" |
|
|
|
#include "internal.h" |
|
|
|
|
|
|
|
#include <stdio.h> |
|
|
|
#include <assert.h> |
|
|
|
#include <stdlib.h> |
|
|
|
#include <windows.h> |
|
|
|
|
|
|
|
#define UTF8_TO_UTF16(s, t) \ |
|
|
|
size = uv_utf8_to_utf16(s, NULL, 0) * sizeof(wchar_t); \ |
|
|
|
t = (wchar_t*)malloc(size); \ |
|
|
|
if (!t) { \ |
|
|
|
uv_fatal_error(ERROR_OUTOFMEMORY, "malloc"); \ |
|
|
|
} \ |
|
|
|
if (!uv_utf8_to_utf16(s, t, size / sizeof(wchar_t))) { \ |
|
|
|
uv_set_sys_error(GetLastError()); \ |
|
|
|
err = -1; \ |
|
|
|
goto done; \ |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static const wchar_t DEFAULT_PATH[1] = L""; |
|
|
|
static const wchar_t DEFAULT_PATH_EXT[20] = L".COM;.EXE;.BAT;.CMD"; |
|
|
|
|
|
|
|
|
|
|
|
static void uv_process_init(uv_process_t* handle) { |
|
|
|
handle->type = UV_PROCESS; |
|
|
|
handle->flags = 0; |
|
|
|
handle->error = uv_ok_; |
|
|
|
handle->exit_cb = NULL; |
|
|
|
handle->pid = 0; |
|
|
|
handle->exit_signal = 0; |
|
|
|
handle->wait_handle = INVALID_HANDLE_VALUE; |
|
|
|
handle->process_handle = INVALID_HANDLE_VALUE; |
|
|
|
handle->close_handle = INVALID_HANDLE_VALUE; |
|
|
|
handle->stdio_pipes[0].server_pipe = NULL; |
|
|
|
handle->stdio_pipes[0].child_pipe = INVALID_HANDLE_VALUE; |
|
|
|
handle->stdio_pipes[1].server_pipe = NULL; |
|
|
|
handle->stdio_pipes[1].child_pipe = INVALID_HANDLE_VALUE; |
|
|
|
handle->stdio_pipes[2].server_pipe = NULL; |
|
|
|
handle->stdio_pipes[2].child_pipe = INVALID_HANDLE_VALUE; |
|
|
|
|
|
|
|
uv_req_init((uv_req_t*)&handle->exit_req); |
|
|
|
handle->exit_req.type = UV_PROCESS_EXIT; |
|
|
|
handle->exit_req.data = handle; |
|
|
|
uv_req_init((uv_req_t*)&handle->close_req); |
|
|
|
handle->close_req.type = UV_PROCESS_CLOSE; |
|
|
|
handle->close_req.data = handle; |
|
|
|
|
|
|
|
uv_counters()->handle_init++; |
|
|
|
uv_counters()->process_init++; |
|
|
|
|
|
|
|
uv_ref(); |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Path search functions |
|
|
|
*/ |
|
|
|
|
|
|
|
/*
|
|
|
|
* Helper function for search_path |
|
|
|
*/ |
|
|
|
static wchar_t* search_path_join_test(const wchar_t* dir, |
|
|
|
int dir_len, |
|
|
|
const wchar_t* name, |
|
|
|
int name_len, |
|
|
|
const wchar_t* ext, |
|
|
|
int ext_len, |
|
|
|
const wchar_t* cwd, |
|
|
|
int cwd_len) { |
|
|
|
wchar_t *result, *result_pos; |
|
|
|
DWORD attrs; |
|
|
|
|
|
|
|
if (dir_len >= 1 && (dir[0] == L'/' || dir[0] == L'\\')) { |
|
|
|
/* It's a full path without drive letter, use cwd's drive letter only */ |
|
|
|
cwd_len = 2; |
|
|
|
} else if (dir_len >= 2 && dir[1] == L':' && |
|
|
|
(dir_len < 3 || (dir[2] != L'/' && dir[2] != L'\\'))) { |
|
|
|
/* It's a relative path with drive letter (ext.g. D:../some/file)
|
|
|
|
* Replace drive letter in dir by full cwd if it points to the same drive, |
|
|
|
* otherwise use the dir only. |
|
|
|
*/ |
|
|
|
if (cwd_len < 2 || _wcsnicmp(cwd, dir, 2) != 0) { |
|
|
|
cwd_len = 0; |
|
|
|
} else { |
|
|
|
dir += 2; |
|
|
|
dir_len -= 2; |
|
|
|
} |
|
|
|
} else if (dir_len > 2 && dir[1] == L':') { |
|
|
|
/* It's an absolute path with drive letter
|
|
|
|
* Don't use the cwd at all |
|
|
|
*/ |
|
|
|
cwd_len = 0; |
|
|
|
} |
|
|
|
|
|
|
|
/* Allocate buffer for output */ |
|
|
|
result = result_pos = |
|
|
|
(wchar_t*)malloc(sizeof(wchar_t) * (cwd_len + 1 + dir_len + 1 + name_len + 1 + ext_len + 1)); |
|
|
|
|
|
|
|
/* Copy cwd */ |
|
|
|
wcsncpy(result_pos, cwd, cwd_len); |
|
|
|
result_pos += cwd_len; |
|
|
|
|
|
|
|
/* Add a path separator if cwd didn't end with one */ |
|
|
|
if (cwd_len && wcsrchr(L"\\/:", result_pos[-1]) == NULL) { |
|
|
|
result_pos[0] = L'\\'; |
|
|
|
result_pos++; |
|
|
|
} |
|
|
|
|
|
|
|
/* Copy dir */ |
|
|
|
wcsncpy(result_pos, dir, dir_len); |
|
|
|
result_pos += dir_len; |
|
|
|
|
|
|
|
/* Add a separator if the dir didn't end with one */ |
|
|
|
if (dir_len && wcsrchr(L"\\/:", result_pos[-1]) == NULL) { |
|
|
|
result_pos[0] = L'\\'; |
|
|
|
result_pos++; |
|
|
|
} |
|
|
|
|
|
|
|
/* Copy filename */ |
|
|
|
wcsncpy(result_pos, name, name_len); |
|
|
|
result_pos += name_len; |
|
|
|
|
|
|
|
/* Copy extension */ |
|
|
|
if (ext_len) { |
|
|
|
result_pos[0] = L'.'; |
|
|
|
result_pos++; |
|
|
|
wcsncpy(result_pos, ext, ext_len); |
|
|
|
result_pos += ext_len; |
|
|
|
} |
|
|
|
|
|
|
|
/* Null terminator */ |
|
|
|
result_pos[0] = L'\0'; |
|
|
|
|
|
|
|
attrs = GetFileAttributesW(result); |
|
|
|
|
|
|
|
if (attrs != INVALID_FILE_ATTRIBUTES && |
|
|
|
!(attrs & (FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_REPARSE_POINT))) { |
|
|
|
return result; |
|
|
|
} |
|
|
|
|
|
|
|
free(result); |
|
|
|
return NULL; |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Helper function for search_path |
|
|
|
*/ |
|
|
|
static wchar_t* path_search_walk_ext(const wchar_t *dir, |
|
|
|
int dir_len, |
|
|
|
const wchar_t *name, |
|
|
|
int name_len, |
|
|
|
wchar_t *cwd, |
|
|
|
int cwd_len, |
|
|
|
const wchar_t *path_ext, |
|
|
|
int name_has_ext) { |
|
|
|
wchar_t* result = NULL; |
|
|
|
|
|
|
|
const wchar_t *ext_start, |
|
|
|
*ext_end = path_ext; |
|
|
|
|
|
|
|
/* If the name itself has a nonemtpy extension, try this extension first */ |
|
|
|
if (name_has_ext) { |
|
|
|
result = search_path_join_test(dir, dir_len, |
|
|
|
name, name_len, |
|
|
|
L"", 0, |
|
|
|
cwd, cwd_len); |
|
|
|
} |
|
|
|
|
|
|
|
/* Add path_ext extensions and try to find a name that matches */ |
|
|
|
while (result == NULL) { |
|
|
|
if (*ext_end == L'\0') { |
|
|
|
break; |
|
|
|
} |
|
|
|
|
|
|
|
/* Skip the separator that ext_end now points to */ |
|
|
|
if (ext_end != path_ext) { |
|
|
|
ext_end++; |
|
|
|
} |
|
|
|
|
|
|
|
/* Find the next dot in path_ext */ |
|
|
|
ext_start = wcschr(ext_end, L'.'); |
|
|
|
if (ext_start == NULL) { |
|
|
|
break; |
|
|
|
} |
|
|
|
|
|
|
|
/* Skip the dot */ |
|
|
|
ext_start++; |
|
|
|
|
|
|
|
/* Slice until we found a ; or alternatively a \0 */ |
|
|
|
ext_end = wcschr(ext_start, L';'); |
|
|
|
if (ext_end == NULL) { |
|
|
|
ext_end = wcschr(ext_start, '\0'); |
|
|
|
} |
|
|
|
|
|
|
|
result = search_path_join_test(dir, dir_len, |
|
|
|
name, name_len, |
|
|
|
ext_start, (ext_end - ext_start), |
|
|
|
cwd, cwd_len); |
|
|
|
} |
|
|
|
|
|
|
|
return result; |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* search_path searches the system path for an executable filename - |
|
|
|
* the windows API doesn't provide this as a standalone function nor as an |
|
|
|
* option to CreateProcess. |
|
|
|
* |
|
|
|
* It tries to return an absolute filename. |
|
|
|
* |
|
|
|
* Furthermore, it tries to follow the semantics that cmd.exe uses as closely |
|
|
|
* as possible: |
|
|
|
* |
|
|
|
* - Do not search the path if the filename already contains a path (either |
|
|
|
* relative or absolute). |
|
|
|
* (but do use path_ext) |
|
|
|
* |
|
|
|
* - If there's really only a filename, check the current directory for file, |
|
|
|
* then search all path directories. |
|
|
|
* |
|
|
|
* - If filename specifies has *any* extension, search for the file with the |
|
|
|
* specified extension first. |
|
|
|
* (not necessary an executable one or one that appears in path_ext; |
|
|
|
* *but* no extension or just a dot is *not* allowed) |
|
|
|
* |
|
|
|
* - If the literal filename is not found in a directory, try *appending* |
|
|
|
* (not replacing) extensions from path_ext in the specified order. |
|
|
|
* (an extension consisting of just a dot *may* appear in path_ext; |
|
|
|
* unlike what happens if the specified filename ends with a dot, |
|
|
|
* if path_ext specifies a single dot cmd.exe *does* look for an |
|
|
|
* extension-less file) |
|
|
|
* |
|
|
|
* - The path variable may contain relative paths; relative paths are relative |
|
|
|
* to the cwd. |
|
|
|
* |
|
|
|
* - Directories in path may or may not end with a trailing backslash. |
|
|
|
* |
|
|
|
* - Extensions path_ext portions must always start with a dot. |
|
|
|
* |
|
|
|
* - CMD does not trim leading/trailing whitespace from path/pathex entries |
|
|
|
* nor from the environment variables as a whole. |
|
|
|
* |
|
|
|
* - When cmd.exe cannot read a directory, it wil just skip it and go on |
|
|
|
* searching. However, unlike posix-y systems, it will happily try to run a |
|
|
|
* file that is not readable/executable; if the spawn fails it will not |
|
|
|
* continue searching. |
|
|
|
* |
|
|
|
* TODO: correctly interpret UNC paths |
|
|
|
* TODO: check with cmd what should happen when a pathext entry does not start |
|
|
|
* with a dot |
|
|
|
*/ |
|
|
|
static wchar_t* search_path(const wchar_t *file, |
|
|
|
wchar_t *cwd, |
|
|
|
const wchar_t *path, |
|
|
|
const wchar_t *path_ext) { |
|
|
|
int file_has_dir; |
|
|
|
wchar_t* result = NULL; |
|
|
|
wchar_t *file_name_start; |
|
|
|
wchar_t *dot; |
|
|
|
int name_has_ext; |
|
|
|
|
|
|
|
int file_len = wcslen(file); |
|
|
|
int cwd_len = wcslen(cwd); |
|
|
|
|
|
|
|
/* If the caller supplies an empty filename,
|
|
|
|
* we're not gonna return c:\windows\.exe -- GFY! |
|
|
|
*/ |
|
|
|
if (file_len == 0 |
|
|
|
|| (file_len == 1 && file[0] == L'.')) { |
|
|
|
return NULL; |
|
|
|
} |
|
|
|
|
|
|
|
/* Find the start of the filename so we can split the directory from the name */ |
|
|
|
for (file_name_start = (wchar_t*)file + file_len; |
|
|
|
file_name_start > file |
|
|
|
&& file_name_start[-1] != L'\\' |
|
|
|
&& file_name_start[-1] != L'/' |
|
|
|
&& file_name_start[-1] != L':'; |
|
|
|
file_name_start--); |
|
|
|
|
|
|
|
file_has_dir = file_name_start != file; |
|
|
|
|
|
|
|
/* Check if the filename includes an extension */ |
|
|
|
dot = wcschr(file_name_start, L'.'); |
|
|
|
name_has_ext = (dot != NULL && dot[1] != L'\0'); |
|
|
|
|
|
|
|
if (file_has_dir) { |
|
|
|
/* The file has a path inside, don't use path (but do use path_ex) */ |
|
|
|
result = path_search_walk_ext( |
|
|
|
file, file_name_start - file, |
|
|
|
file_name_start, file_len - (file_name_start - file), |
|
|
|
cwd, cwd_len, |
|
|
|
path_ext, name_has_ext); |
|
|
|
|
|
|
|
} else { |
|
|
|
const wchar_t *dir_start, |
|
|
|
*dir_end = path; |
|
|
|
|
|
|
|
/* The file is really only a name; look in cwd first, then scan path */ |
|
|
|
result = path_search_walk_ext(L"", 0, |
|
|
|
file, file_len, |
|
|
|
cwd, cwd_len, |
|
|
|
path_ext, name_has_ext); |
|
|
|
|
|
|
|
while (result == NULL) { |
|
|
|
if (*dir_end == L'\0') { |
|
|
|
break; |
|
|
|
} |
|
|
|
|
|
|
|
/* Skip the separator that dir_end now points to */ |
|
|
|
if (dir_end != path) { |
|
|
|
dir_end++; |
|
|
|
} |
|
|
|
|
|
|
|
/* Next slice starts just after where the previous one ended */ |
|
|
|
dir_start = dir_end; |
|
|
|
|
|
|
|
/* Slice until the next ; or \0 is found */ |
|
|
|
dir_end = wcschr(dir_start, L';'); |
|
|
|
if (dir_end == NULL) { |
|
|
|
dir_end = wcschr(dir_start, L'\0'); |
|
|
|
} |
|
|
|
|
|
|
|
/* If the slice is zero-length, don't bother */ |
|
|
|
if (dir_end - dir_start == 0) { |
|
|
|
continue; |
|
|
|
} |
|
|
|
|
|
|
|
result = path_search_walk_ext(dir_start, dir_end - dir_start, |
|
|
|
file, file_len, |
|
|
|
cwd, cwd_len, |
|
|
|
path_ext, name_has_ext); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
return result; |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static wchar_t* make_program_args(char** args) { |
|
|
|
wchar_t* dst; |
|
|
|
wchar_t* ptr; |
|
|
|
char** arg; |
|
|
|
size_t size = 0; |
|
|
|
size_t len; |
|
|
|
int arg_count = 0; |
|
|
|
|
|
|
|
/* Count the required size. */ |
|
|
|
for (arg = args; *arg; arg++) { |
|
|
|
size += (uv_utf8_to_utf16(*arg, NULL, 0) * sizeof(wchar_t)); |
|
|
|
arg_count++; |
|
|
|
} |
|
|
|
|
|
|
|
/* Arguments are separated with a space. */ |
|
|
|
if (arg_count > 0) { |
|
|
|
size += arg_count - 1; |
|
|
|
} |
|
|
|
|
|
|
|
dst = (wchar_t*)malloc(size); |
|
|
|
if (!dst) { |
|
|
|
uv_fatal_error(ERROR_OUTOFMEMORY, "malloc"); |
|
|
|
} |
|
|
|
|
|
|
|
ptr = dst; |
|
|
|
for (arg = args; *arg; arg++, ptr += len) { |
|
|
|
len = uv_utf8_to_utf16(*arg, ptr, (size_t)(size - (ptr - dst))); |
|
|
|
if (!len) { |
|
|
|
free(dst); |
|
|
|
return NULL; |
|
|
|
} |
|
|
|
|
|
|
|
if (*(arg + 1)) { |
|
|
|
/* Replace with a space if there are more args. */ |
|
|
|
*((ptr + len) - 1) = L' '; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
return dst; |
|
|
|
} |
|
|
|
|
|
|
|
/*
|
|
|
|
* The way windows takes environment variables is different than what C does; |
|
|
|
* Windows wants a contiguous block of null-terminated strings, terminated |
|
|
|
* with an additional null. |
|
|
|
* Get a pointer to the pathext and path environment variables as well, |
|
|
|
* because search_path needs it. These are just pointers into env_win. |
|
|
|
*/ |
|
|
|
wchar_t* make_program_env(char** env_block, const wchar_t **path, const wchar_t **path_ext) { |
|
|
|
wchar_t* dst; |
|
|
|
wchar_t* ptr; |
|
|
|
char** env; |
|
|
|
int env_len = 1 * sizeof(wchar_t); /* room for closing null */ |
|
|
|
int len; |
|
|
|
|
|
|
|
for (env = env_block; *env; env++) { |
|
|
|
env_len += (uv_utf8_to_utf16(*env, NULL, 0) * sizeof(wchar_t)); |
|
|
|
} |
|
|
|
|
|
|
|
dst = (wchar_t*)malloc(env_len); |
|
|
|
if (!dst) { |
|
|
|
uv_fatal_error(ERROR_OUTOFMEMORY, "malloc"); |
|
|
|
} |
|
|
|
|
|
|
|
ptr = dst; |
|
|
|
|
|
|
|
for (env = env_block; *env; env++, ptr += len) { |
|
|
|
len = uv_utf8_to_utf16(*env, ptr, (size_t)(env_len - (ptr - dst))); |
|
|
|
if (!len) { |
|
|
|
free(dst); |
|
|
|
return NULL; |
|
|
|
} |
|
|
|
|
|
|
|
/* Try to get a pointer to PATH and PATHEXT */ |
|
|
|
if (_wcsnicmp(L"PATH=", ptr, 5) == 0) { |
|
|
|
*path = ptr + 5; |
|
|
|
} |
|
|
|
if (_wcsnicmp(L"PATHEXT=", ptr, 8) == 0) { |
|
|
|
*path_ext = ptr + 8; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
*ptr = L'\0'; |
|
|
|
return dst; |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Called on Windows thread-pool thread to indicate that |
|
|
|
* a child process has exited. |
|
|
|
*/ |
|
|
|
static void CALLBACK exit_wait_callback(void* data, BOOLEAN didTimeout) { |
|
|
|
uv_process_t* process = (uv_process_t*)data; |
|
|
|
|
|
|
|
assert(didTimeout == FALSE); |
|
|
|
assert(process); |
|
|
|
|
|
|
|
memset(&process->exit_req.overlapped, 0, sizeof(process->exit_req.overlapped)); |
|
|
|
|
|
|
|
/* Post completed */ |
|
|
|
if (!PostQueuedCompletionStatus(LOOP->iocp, |
|
|
|
0, |
|
|
|
0, |
|
|
|
&process->exit_req.overlapped)) { |
|
|
|
uv_fatal_error(GetLastError(), "PostQueuedCompletionStatus"); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Called on Windows thread-pool thread to indicate that |
|
|
|
* UnregisterWaitEx has completed. |
|
|
|
*/ |
|
|
|
static void CALLBACK close_wait_callback(void* data, BOOLEAN didTimeout) { |
|
|
|
uv_process_t* process = (uv_process_t*)data; |
|
|
|
|
|
|
|
assert(didTimeout == FALSE); |
|
|
|
assert(process); |
|
|
|
|
|
|
|
memset(&process->close_req.overlapped, 0, sizeof(process->close_req.overlapped)); |
|
|
|
|
|
|
|
/* Post completed */ |
|
|
|
if (!PostQueuedCompletionStatus(LOOP->iocp, |
|
|
|
0, |
|
|
|
0, |
|
|
|
&process->close_req.overlapped)) { |
|
|
|
uv_fatal_error(GetLastError(), "PostQueuedCompletionStatus"); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
/* Called on main thread after a child process has exited. */ |
|
|
|
void uv_process_proc_exit(uv_process_t* handle) { |
|
|
|
int i; |
|
|
|
DWORD exit_code; |
|
|
|
|
|
|
|
/* Close stdio handles. */ |
|
|
|
for (i = 0; i < COUNTOF(handle->stdio_pipes); i++) { |
|
|
|
if (handle->stdio_pipes[i].child_pipe != INVALID_HANDLE_VALUE) { |
|
|
|
CloseHandle(handle->stdio_pipes[i].child_pipe); |
|
|
|
handle->stdio_pipes[i].child_pipe = INVALID_HANDLE_VALUE; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
/* Unregister from process notification. */ |
|
|
|
if (handle->wait_handle != INVALID_HANDLE_VALUE) { |
|
|
|
UnregisterWait(handle->wait_handle); |
|
|
|
handle->wait_handle = INVALID_HANDLE_VALUE; |
|
|
|
} |
|
|
|
|
|
|
|
/* Clean-up the process handle. */ |
|
|
|
if (handle->process_handle != INVALID_HANDLE_VALUE) { |
|
|
|
/* Get the exit code. */ |
|
|
|
if (!GetExitCodeProcess(handle->process_handle, &exit_code)) { |
|
|
|
exit_code = 1; |
|
|
|
} |
|
|
|
|
|
|
|
CloseHandle(handle->process_handle); |
|
|
|
handle->process_handle = INVALID_HANDLE_VALUE; |
|
|
|
} |
|
|
|
|
|
|
|
/* Fire the exit callback. */ |
|
|
|
if (handle->exit_cb) { |
|
|
|
handle->exit_cb(handle, exit_code, handle->exit_signal); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
/* Called on main thread after UnregisterWaitEx finishes. */ |
|
|
|
void uv_process_proc_close(uv_process_t* handle) { |
|
|
|
uv_want_endgame((uv_handle_t*)handle); |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
void uv_process_endgame(uv_process_t* handle) { |
|
|
|
if (handle->flags & UV_HANDLE_CLOSING) { |
|
|
|
assert(!(handle->flags & UV_HANDLE_CLOSED)); |
|
|
|
handle->flags |= UV_HANDLE_CLOSED; |
|
|
|
|
|
|
|
if (handle->close_cb) { |
|
|
|
handle->close_cb((uv_handle_t*)handle); |
|
|
|
} |
|
|
|
|
|
|
|
uv_unref(); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
void uv_process_close(uv_process_t* handle) { |
|
|
|
if (handle->wait_handle != INVALID_HANDLE_VALUE) { |
|
|
|
handle->close_handle = CreateEvent(NULL, FALSE, FALSE, NULL); |
|
|
|
UnregisterWaitEx(handle->wait_handle, handle->close_handle); |
|
|
|
handle->wait_handle = NULL; |
|
|
|
|
|
|
|
RegisterWaitForSingleObject(&handle->wait_handle, handle->close_handle, |
|
|
|
close_wait_callback, (void*)handle, INFINITE, |
|
|
|
WT_EXECUTEINWAITTHREAD | WT_EXECUTEONLYONCE); |
|
|
|
} else { |
|
|
|
uv_want_endgame((uv_handle_t*)handle); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int uv_create_stdio_pipe_pair(uv_pipe_t* server_pipe, HANDLE* child_pipe, DWORD server_access, DWORD child_access) { |
|
|
|
int err; |
|
|
|
SECURITY_ATTRIBUTES sa = { sizeof(SECURITY_ATTRIBUTES), NULL, TRUE }; |
|
|
|
char pipe_name[64]; |
|
|
|
DWORD mode = PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT; |
|
|
|
|
|
|
|
if (server_pipe->type != UV_NAMED_PIPE) { |
|
|
|
uv_set_error(UV_EINVAL, 0); |
|
|
|
err = -1; |
|
|
|
goto done; |
|
|
|
} |
|
|
|
|
|
|
|
/* Create server pipe handle. */ |
|
|
|
err = uv_stdio_pipe_server(server_pipe, server_access, pipe_name, sizeof(pipe_name)); |
|
|
|
if (err) { |
|
|
|
goto done; |
|
|
|
} |
|
|
|
|
|
|
|
/* Create child pipe handle. */ |
|
|
|
*child_pipe = CreateFileA(pipe_name, |
|
|
|
child_access, |
|
|
|
0, |
|
|
|
&sa, |
|
|
|
OPEN_EXISTING, |
|
|
|
0, |
|
|
|
NULL); |
|
|
|
|
|
|
|
if (*child_pipe == INVALID_HANDLE_VALUE) { |
|
|
|
uv_set_sys_error(GetLastError()); |
|
|
|
err = -1; |
|
|
|
goto done; |
|
|
|
} |
|
|
|
|
|
|
|
if (!SetNamedPipeHandleState(*child_pipe, &mode, NULL, NULL)) { |
|
|
|
uv_set_sys_error(GetLastError()); |
|
|
|
err = -1; |
|
|
|
goto done; |
|
|
|
} |
|
|
|
|
|
|
|
/* Do a blocking ConnectNamedPipe. This should not block because
|
|
|
|
* we have both ends of the pipe created. |
|
|
|
*/ |
|
|
|
if (!ConnectNamedPipe(server_pipe->handle, NULL)) { |
|
|
|
if (GetLastError() != ERROR_PIPE_CONNECTED) { |
|
|
|
uv_set_sys_error(GetLastError()); |
|
|
|
err = -1; |
|
|
|
goto done; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
err = 0; |
|
|
|
|
|
|
|
done: |
|
|
|
if (err) { |
|
|
|
if (server_pipe->handle != INVALID_HANDLE_VALUE) { |
|
|
|
close_pipe(server_pipe, NULL, NULL); |
|
|
|
} |
|
|
|
|
|
|
|
if (*child_pipe != INVALID_HANDLE_VALUE) { |
|
|
|
CloseHandle(*child_pipe); |
|
|
|
*child_pipe = INVALID_HANDLE_VALUE; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
return err; |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
int uv_spawn(uv_process_t* process, uv_process_options_t options) { |
|
|
|
assert(0 && "implement me"); |
|
|
|
int err, i; |
|
|
|
const wchar_t* path = NULL; |
|
|
|
const wchar_t* path_ext = NULL; |
|
|
|
int size; |
|
|
|
wchar_t* application_path, *application, *arguments, *env, *cwd; |
|
|
|
STARTUPINFOW startup; |
|
|
|
PROCESS_INFORMATION info; |
|
|
|
|
|
|
|
uv_process_init(process); |
|
|
|
|
|
|
|
process->exit_cb = options.exit_cb; |
|
|
|
UTF8_TO_UTF16(options.file, application); |
|
|
|
arguments = options.args ? make_program_args(options.args) : NULL; |
|
|
|
env = options.env ? make_program_env(options.env, &path, &path_ext) : NULL; |
|
|
|
|
|
|
|
if (options.cwd) { |
|
|
|
UTF8_TO_UTF16(options.cwd, cwd); |
|
|
|
} else { |
|
|
|
size = GetCurrentDirectoryW(0, NULL) * sizeof(wchar_t); |
|
|
|
if (size) { |
|
|
|
cwd = (wchar_t*)malloc(size); |
|
|
|
if (!cwd) { |
|
|
|
uv_fatal_error(ERROR_OUTOFMEMORY, "malloc"); |
|
|
|
} |
|
|
|
GetCurrentDirectoryW(size, cwd); |
|
|
|
} else { |
|
|
|
uv_set_sys_error(GetLastError()); |
|
|
|
err = -1; |
|
|
|
goto done; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
application_path = search_path(application, |
|
|
|
cwd, |
|
|
|
path ? path : DEFAULT_PATH, |
|
|
|
path_ext ? path_ext : DEFAULT_PATH_EXT); |
|
|
|
|
|
|
|
if (!application_path) { |
|
|
|
uv_set_error(UV_EINVAL, 0); |
|
|
|
err = -1; |
|
|
|
goto done; |
|
|
|
} |
|
|
|
|
|
|
|
/* Create stdio pipes. */ |
|
|
|
if (options.stdin_stream) { |
|
|
|
err = uv_create_stdio_pipe_pair(options.stdin_stream, &process->stdio_pipes[0].child_pipe, PIPE_ACCESS_OUTBOUND, GENERIC_READ | FILE_WRITE_ATTRIBUTES); |
|
|
|
if (err) { |
|
|
|
goto done; |
|
|
|
} |
|
|
|
|
|
|
|
process->stdio_pipes[0].server_pipe = options.stdin_stream; |
|
|
|
} |
|
|
|
|
|
|
|
if (options.stdout_stream) { |
|
|
|
err = uv_create_stdio_pipe_pair(options.stdout_stream, &process->stdio_pipes[1].child_pipe, PIPE_ACCESS_INBOUND, GENERIC_WRITE); |
|
|
|
if (err) { |
|
|
|
goto done; |
|
|
|
} |
|
|
|
|
|
|
|
process->stdio_pipes[1].server_pipe = options.stdout_stream; |
|
|
|
} |
|
|
|
|
|
|
|
if (options.stderr_stream) { |
|
|
|
err = uv_create_stdio_pipe_pair(options.stderr_stream, &process->stdio_pipes[2].child_pipe, PIPE_ACCESS_INBOUND, GENERIC_WRITE); |
|
|
|
if (err) { |
|
|
|
goto done; |
|
|
|
} |
|
|
|
|
|
|
|
process->stdio_pipes[2].server_pipe = options.stderr_stream; |
|
|
|
} |
|
|
|
|
|
|
|
startup.cb = sizeof(startup); |
|
|
|
startup.lpReserved = NULL; |
|
|
|
startup.lpDesktop = NULL; |
|
|
|
startup.lpTitle = NULL; |
|
|
|
startup.dwFlags = STARTF_USESTDHANDLES; |
|
|
|
startup.cbReserved2 = 0; |
|
|
|
startup.lpReserved2 = NULL; |
|
|
|
startup.hStdInput = process->stdio_pipes[0].child_pipe; |
|
|
|
startup.hStdOutput = process->stdio_pipes[1].child_pipe; |
|
|
|
startup.hStdError = process->stdio_pipes[2].child_pipe; |
|
|
|
|
|
|
|
if (!CreateProcessW(application_path, |
|
|
|
arguments, |
|
|
|
NULL, |
|
|
|
NULL, |
|
|
|
1, |
|
|
|
CREATE_UNICODE_ENVIRONMENT, |
|
|
|
env, |
|
|
|
cwd, |
|
|
|
&startup, |
|
|
|
&info)) { |
|
|
|
uv_set_sys_error(GetLastError()); |
|
|
|
err = -1; |
|
|
|
goto done; |
|
|
|
} |
|
|
|
|
|
|
|
process->process_handle = info.hProcess; |
|
|
|
process->pid = info.dwProcessId; |
|
|
|
|
|
|
|
/* Setup notifications for when the child process exits. */ |
|
|
|
if (!RegisterWaitForSingleObject(&process->wait_handle, process->process_handle, |
|
|
|
exit_wait_callback, (void*)process, INFINITE, |
|
|
|
WT_EXECUTEINWAITTHREAD | WT_EXECUTEONLYONCE)) { |
|
|
|
uv_set_sys_error(GetLastError()); |
|
|
|
err = -1; |
|
|
|
goto done; |
|
|
|
} |
|
|
|
|
|
|
|
CloseHandle(info.hThread); |
|
|
|
err = 0; |
|
|
|
|
|
|
|
done: |
|
|
|
free(application_path); |
|
|
|
free(application); |
|
|
|
free(arguments); |
|
|
|
free(cwd); |
|
|
|
free(env); |
|
|
|
|
|
|
|
if (err) { |
|
|
|
for (i = 0; i < COUNTOF(process->stdio_pipes); i++) { |
|
|
|
if (process->stdio_pipes[i].child_pipe != INVALID_HANDLE_VALUE) { |
|
|
|
CloseHandle(process->stdio_pipes[i].child_pipe); |
|
|
|
process->stdio_pipes[i].child_pipe = INVALID_HANDLE_VALUE; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
if (process->wait_handle != INVALID_HANDLE_VALUE) { |
|
|
|
UnregisterWait(process->wait_handle); |
|
|
|
process->wait_handle = INVALID_HANDLE_VALUE; |
|
|
|
} |
|
|
|
|
|
|
|
if (process->process_handle != INVALID_HANDLE_VALUE) { |
|
|
|
CloseHandle(process->process_handle); |
|
|
|
process->process_handle = INVALID_HANDLE_VALUE; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
return err; |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
int uv_process_kill(uv_process_t* process, int signum) { |
|
|
|
assert(0 && "implement me"); |
|
|
|
process->exit_signal = signum; |
|
|
|
|
|
|
|
/* On windows killed processes normally return 1 */ |
|
|
|
if (process->process_handle != INVALID_HANDLE_VALUE && |
|
|
|
TerminateProcess(process->process_handle, 1)) { |
|
|
|
return 0; |
|
|
|
} |
|
|
|
|
|
|
|
return -1; |
|
|
|
} |
|
|
|
|
Ryan Dahl
14 years ago