Something went wrong. Try again.
Reactos
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452//// spawnv.cpp//// Copyright (c) Microsoft Corporation. All rights reserved.//// Defines the -v and -ve flavors of the _exec() and _spawn() functions.//// There are many varieties of the _exec() and _spawn() functions. A high level// summary of the behavioral differences is as follows://// All of these functions execute a new process. The _spawn() functions all take// a 'mode' parameter, which specifies the way in which the process is started.// The 'mode' must be one of the _P_-prefixed modes from <process.h>. The _exec()// family of functions execute a new process, then call _exit() to terminate the// calling process. Each _exit() function is equivalent to the corresponding// _spawn() function with the _P_OVERLAY mode.//// There are eight variants each of _exec() and _spawn(), suffixed with -l, -le,// -lp, -lpe, -v, -ve, -vp, and -vpe.//// If a function has 'e' in its suffix, it accepts an environment with which to// create the new process. If a function does not have 'e' in its suffix, it// does not accept an environment and instead uses the environment of the calling// process. A call to an 'e' function with a null environment argument has the// same effect as calling the non-'e'-suffixed equivalent.//// Each _exec() or _spawn() function has either an 'l' or 'v' suffix. These have// equivalent functionality; they differ only in how they accept their arguments.// The 'l'-suffixed functions accept the command-line arguments and the environment// as varargs. There must be at least one command line argument (conventionally// the name of the program to be executed). If the function accepts an environment// (if it is 'e'-suffixed), then there must be a null pointer between the last// argument and the first environment variable. The arguments are terminated by a// null pointer.//// The 'v'-suffixed functions accept a pair of pointers: one to the argv vector// and one to the envp vector. Each is an array of pointers terminated by a null// pointer, similar to how arguments and the environment are passed to main().//// Finally, if a function has a 'p' in its suffix, and if the provided executable// file name is just a file name (and does not contain any path component), the// %PATH% is searched for an executable with the given name. If a function does// not have a 'p' suffix, then the environment is not searched; the executable// must be found simply by passing its name to CreateProcess.//// All functions return -1 and set errno on failure. On success, the _exec()// functions do not return. On success, the _spawn() functions return different// things, depending on the provided mode. See the CreateProcess invocation// logic in this file for details.//// Note that the only supported modes are wait and overlay.//// These functions may set errno to one of the following values:// * E2BIG: Failed in argument or environment processing because the argument// list or environment is too large.// * EACCESS: Locking or sharing violation on a file// * EMFILE: Too many files open// * ENOENT: Failed to find the program (no such file or directory)// * ENOEXEC: Failed in a call to exec() due to a bad executable format// * ENOMEM: Failed to allocate memory required for the spawn operation// * EINVAL: Invalid mode argumnt or process state for spawn (note that most// invalid arguments cause the invalid parameter handler to be// invoked).//#include <corecrt_internal.h>#include <corecrt_internal_lowio.h>#include <corecrt_internal_traits.h>#include <errno.h>#include <io.h>#include <mbstring.h>#include <process.h>#include <stdlib.h>#include <string.h>
// Accumulates the inheritable file handles into *data, in the structure expected// by the spawnee (see the lowio initialization code for the logic that decodes// this data structure). On success, *data and *size have the handle data array// and the size of the handle data, and true is returned. The caller must free// *data. On failure, false is returned and errno is set.static bool accumulate_inheritable_handles( BYTE** const data, size_t* const size, bool const include_std_handles ) throw(){ return __acrt_lock_and_call(__acrt_lowio_index_lock, [&]() -> bool { *data = nullptr; *size = 0;
// Count the number of handles to be inherited: size_t handle_count = 0; for (handle_count = _nhandle; handle_count != 0 && _osfile(handle_count - 1) != 0; --handle_count) { }
size_t const max_handle_count = (USHRT_MAX - sizeof(int)) / (sizeof(char) + sizeof(intptr_t)); _VALIDATE_RETURN_NOEXC(handle_count < max_handle_count, ENOMEM, false);
size_t const handle_data_header_size = sizeof(int); size_t const handle_data_element_size = sizeof(char) + sizeof(intptr_t);
unsigned short const handle_data_size = static_cast<unsigned short>( handle_data_header_size + handle_count * handle_data_element_size);
__crt_unique_heap_ptr<BYTE> handle_data(_calloc_crt_t(BYTE, handle_data_size)); _VALIDATE_RETURN_NOEXC(handle_data.get() != nullptr, ENOMEM, false);
// Set the handle count in the data: *reinterpret_cast<int*>(handle_data.get()) = static_cast<int>(handle_count);
auto const first_flags = reinterpret_cast<char*>(handle_data.get() + sizeof(int)); auto const first_handle = reinterpret_cast<intptr_t UNALIGNED*>(first_flags + (handle_count * sizeof(char)));
// Copy the handle data: auto flags_it = first_flags; auto handle_it = first_handle; for (size_t i = 0; i != handle_count; ++i, ++flags_it, ++handle_it) { __crt_lowio_handle_data* const pio = _pioinfo(i); if ((pio->osfile & FNOINHERIT) == 0) { *flags_it = pio->osfile; *handle_it = pio->osfhnd; } else { *flags_it = 0; *handle_it = reinterpret_cast<intptr_t>(INVALID_HANDLE_VALUE); } }
// Exclude the first three handles (stdin, stdout, stderr) if asked: if (!include_std_handles) { flags_it = first_flags; handle_it = first_handle; for (size_t i = 0; i != __min(handle_count, 3); ++i, ++flags_it, ++handle_it) { *flags_it = 0; *handle_it = reinterpret_cast<intptr_t>(INVALID_HANDLE_VALUE); } }
*data = handle_data.detach(); *size = handle_data_size; return true; });}
static bool __cdecl should_create_unicode_environment(char) throw() { return false; }static bool __cdecl should_create_unicode_environment(wchar_t) throw() { return true; }
// Spawns a child process. The mode must be one of the _P-modes from <process.h>.// The return value depends on the mode:// * _P_OVERLAY: On success, calls _exit() and does not return. Returns -1 on failure.// * _P_WAIT: Returns (termination_code << 8 + result_code)// * _P_DETACH: Returns 0 on success; -1 on failure// * Others: Returns a handle to the process. The caller must close the handle.template <typename Character>static intptr_t __cdecl execute_command( int const mode, Character const* const file_name, Character const* const* const arguments, Character const* const* const environment ) throw(){ typedef __crt_char_traits<Character> traits;
_VALIDATE_RETURN(file_name != nullptr, EINVAL, -1); _VALIDATE_RETURN(arguments != nullptr, EINVAL, -1);
_VALIDATE_CLEAR_OSSERR_RETURN(mode >= 0 && mode <= _P_DETACH, EINVAL, -1);
__crt_unique_heap_ptr<Character> command_line; __crt_unique_heap_ptr<Character> environment_block; if (traits::pack_command_line_and_environment( arguments, environment, command_line.get_address_of(), environment_block.get_address_of() ) == -1) { return -1; }
__crt_unique_heap_ptr<BYTE> handle_data; size_t handle_data_size; if (!accumulate_inheritable_handles(handle_data.get_address_of(), &handle_data_size, mode != _P_DETACH)) return -1;
DWORD creation_flags = 0; if (mode == _P_DETACH) creation_flags |= DETACHED_PROCESS;
if (should_create_unicode_environment(Character())) creation_flags |= CREATE_UNICODE_ENVIRONMENT;
_doserrno = 0;
STARTUPINFOW startup_info = { }; startup_info.cb = sizeof(startup_info); startup_info.cbReserved2 = static_cast<WORD>(handle_data_size); startup_info.lpReserved2 = handle_data.get();
PROCESS_INFORMATION process_info; BOOL const create_process_status = traits::create_process( const_cast<Character*>(file_name), command_line.get(), nullptr, nullptr, TRUE, creation_flags, environment_block.get(), nullptr, &startup_info, &process_info);
__crt_unique_handle process_handle(process_info.hProcess); __crt_unique_handle thread_handle(process_info.hThread);
if (!create_process_status) { __acrt_errno_map_os_error(GetLastError()); return -1; }
if (mode == _P_OVERLAY) { // Destroy ourselves: _exit(0); } else if (mode == _P_WAIT) { WaitForSingleObject(process_info.hProcess, static_cast<DWORD>(-1));
// Return the termination code and exit code. Note that we return // the full exit code. DWORD exit_code; if (0 != GetExitCodeProcess(process_info.hProcess, &exit_code)) { return static_cast<int>(exit_code); } else { __acrt_errno_map_os_error(GetLastError()); return -1; } } else if (mode == _P_DETACH) { /* like totally detached asynchronous spawn, dude, close process handle, return 0 for success */ return 0; } else { // Asynchronous spawn: return process handle: return reinterpret_cast<intptr_t>(process_handle.detach()); }}
template <typename Character>static intptr_t __cdecl common_spawnv( int const mode, Character const* const file_name, Character const* const* const arguments, Character const* const* const environment ) throw(){ typedef __crt_char_traits<Character> traits;
_VALIDATE_RETURN(file_name != nullptr, EINVAL, -1); _VALIDATE_RETURN(file_name[0] != '\0', EINVAL, -1); _VALIDATE_RETURN(arguments != nullptr, EINVAL, -1); _VALIDATE_RETURN(arguments[0] != nullptr, EINVAL, -1); _VALIDATE_RETURN(arguments[0][0] != '\0', EINVAL, -1);
Character const* const final_backslash = traits::tcsrchr(file_name, '\\'); Character const* const final_slash = traits::tcsrchr(file_name, '/');
Character const* mutated_file_name = file_name; Character const* end_of_directory = final_backslash; if (!final_slash) { if (!final_backslash) { Character const* const final_colon = traits::tcsrchr(file_name, ':'); if (final_colon) { end_of_directory = final_colon; } else { // The path is a file name only. We force it to be a relative // path name. size_t const file_name_size = traits::tcslen(file_name) + 3; __crt_unique_heap_ptr<Character> buffer(_calloc_crt_t(Character, file_name_size)); if (!buffer) return -1;
static Character const dot_slash[] = { '.', '\\', '\0' }; _ERRCHECK(traits::tcscpy_s(buffer.get(), file_name_size, dot_slash)); _ERRCHECK(traits::tcscat_s(buffer.get(), file_name_size, file_name));
mutated_file_name = buffer.detach(); end_of_directory = mutated_file_name + 2; // Adjust for ".\" } } } else if (!final_backslash || final_slash > final_backslash) { end_of_directory = final_slash; }
// If we allocated a file name above, make sure we clean it up: __crt_unique_heap_ptr<Character const> const mutated_file_name_cleanup(file_name == mutated_file_name ? nullptr : mutated_file_name);
if (traits::tcsrchr(end_of_directory, '.')) { // If an extension was provided, just invoke the path: if (traits::taccess_s(mutated_file_name, 0) == 0) { return execute_command(mode, mutated_file_name, arguments, environment); } } else { // If no extension was provided, try known executable extensions: size_t const buffer_size = traits::tcslen(mutated_file_name) + 5; __crt_unique_heap_ptr<Character> const buffer(_calloc_crt_t(Character, buffer_size)); if (!buffer) return -1;
_ERRCHECK(traits::tcscpy_s(buffer.get(), buffer_size, mutated_file_name)); Character* extension_buffer = buffer.get() + buffer_size - 5;
typedef Character const extension_type[5]; static extension_type const extensions[4] = { { '.', 'c', 'o', 'm', '\0' }, { '.', 'e', 'x', 'e', '\0' }, { '.', 'b', 'a', 't', '\0' }, { '.', 'c', 'm', 'd', '\0' } };
errno_t const saved_errno = errno;
extension_type const* const first_extension = extensions; extension_type const* const last_extension = first_extension + _countof(extensions); for (auto it = first_extension; it != last_extension; ++it) { _ERRCHECK(traits::tcscpy_s(extension_buffer, 5, *it));
if (traits::taccess_s(buffer.get(), 0) == 0) { errno = saved_errno; return execute_command(mode, buffer.get(), arguments, environment); } } }
return -1;}
extern "C" intptr_t __cdecl _execv( char const* const file_name, char const* const* const arguments ){ return common_spawnv(_P_OVERLAY, file_name, arguments, static_cast<char const* const*>(nullptr));}
extern "C" intptr_t __cdecl _execve( char const* const file_name, char const* const* const arguments, char const* const* const environment ){ return common_spawnv(_P_OVERLAY, file_name, arguments, environment);}
extern "C" intptr_t __cdecl _spawnv( int const mode, char const* const file_name, char const* const* const arguments ){ return common_spawnv(mode, file_name, arguments, static_cast<char const* const*>(nullptr));}
extern "C" intptr_t __cdecl _spawnve( int const mode, char const* const file_name, char const* const* const arguments, char const* const* const environment ){ return common_spawnv(mode, file_name, arguments, environment);}
extern "C" intptr_t __cdecl _wexecv( wchar_t const* const file_name, wchar_t const* const* const arguments ){ return common_spawnv(_P_OVERLAY, file_name, arguments, static_cast<wchar_t const* const*>(nullptr));}
extern "C" intptr_t __cdecl _wexecve( wchar_t const* const file_name, wchar_t const* const* const arguments, wchar_t const* const* const environment ){ return common_spawnv(_P_OVERLAY, file_name, arguments, environment);}
extern "C" intptr_t __cdecl _wspawnv( int const mode, wchar_t const* const file_name, wchar_t const* const* const arguments ){ return common_spawnv(mode, file_name, arguments, static_cast<wchar_t const* const*>(nullptr));}
extern "C" intptr_t __cdecl _wspawnve( int const mode, wchar_t const* const file_name, wchar_t const* const* const arguments, wchar_t const* const* const environment ){ return common_spawnv(mode, file_name, arguments, environment);}