Something went wrong. Try again.
Reactos
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491//// popen.cpp//// Copyright (c) Microsoft Corporation. All rights reserved.//// The _popen() and _pclose() functions, which open a pipe to a child process.//#include <corecrt_internal_stdio.h>#include <process.h>
#define STDIN 0#define STDOUT 1
namespace {
template <typename Character> struct fdopen_mode { Character mode[3]; };
// This is the entry type for the stream pointer / process handle pairs that // are stored for each outstanding popen. struct process_handle_pair { FILE* stream; intptr_t process_handle; };
struct stream_traits { typedef FILE* type;
static bool close(_In_ type h) throw() { fclose(h); return true; }
static type get_invalid_value() throw() { return nullptr; } };
struct process_handle_pair_traits { typedef process_handle_pair* type;
static bool close(_In_ type h) throw() { h->process_handle = 0; h->stream = nullptr; return true; }
static type get_invalid_value() throw() { return nullptr; } };
typedef __crt_unique_handle_t<stream_traits> unique_stream; typedef __crt_unique_handle_t<process_handle_pair_traits> unique_process_handle_pair;}
// The global table of stream pointer / process handle pairs. Access to this// global tbale is only done via the idtab function. The table is expanded as// necessary (by idtab), and free table entries are reused. (An entry is free// if its stream is null.) The table is never contracted.static unsigned __idtabsiz;static process_handle_pair* __idpairs;
// Finds the entry for the given stream in the global table. If the stream is// found, a pointer to it is returned; if the stream is not found, null is// returned.//// If the stream is null, a new entry is allocated and a pointer to it is// returned. If no entries are available and expansion of the table fails,// null is returned.//// This function assumes the caller has acquired the lock on the table already.static process_handle_pair* __cdecl idtab(FILE* const stream) throw(){ // Search the table, and return the matching entry if one is found: process_handle_pair* const first = __idpairs; process_handle_pair* const last = first + __idtabsiz; for (process_handle_pair* it = first; it != last; ++it) { if (it->stream == stream) return it; }
// We did not find an entry in the table. If the stream is null, then we // try creating or expanding the table. Otherwise, we return null. Note // that when the table is created or expanded, exactly one new entry is // produced. This must not be changed unless code is added to mark the // extra entries as being free (e.g., by setting their stream fields to null. if (stream != nullptr) return nullptr;
if (__idtabsiz + 1 < __idtabsiz) return nullptr;
if (__idtabsiz + 1 >= SIZE_MAX / sizeof(process_handle_pair)) return nullptr;
process_handle_pair* const newptr = _recalloc_crt_t(process_handle_pair, __idpairs, __idtabsiz + 1).detach(); if (newptr == nullptr) return nullptr;
__idpairs = newptr; process_handle_pair* const pairptr = newptr + __idtabsiz; ++__idtabsiz;
return pairptr;}
template <typename Character>static fdopen_mode<Character> __cdecl convert_popen_type_to_fdopen_mode( Character const* const type ) throw(){ fdopen_mode<Character> result = fdopen_mode<Character>();
Character const* type_it = type;
while (*type_it == ' ') ++type_it;
_VALIDATE_RETURN(*type_it == 'w' || *type_it == 'r', EINVAL, result); result.mode[0] = *type_it++;
while (*type_it == ' ') ++type_it;
_VALIDATE_RETURN(*type_it == '\0' || *type_it == 't' || *type_it == 'b', EINVAL, result); result.mode[1] = *type_it;
return result;}
template <typename Character>static Character const* __cdecl get_comspec() throw(){ typedef __acrt_stdio_char_traits<Character> stdio_traits;
static Character const comspec_name[] = { 'C', 'O', 'M', 'S', 'P', 'E', 'C', '\0' };
Character* comspec_value = nullptr; if (_ERRCHECK_EINVAL(stdio_traits::tdupenv_s_crt(&comspec_value, nullptr, comspec_name)) != 0) return nullptr;
return comspec_value;}
template <typename Character>static Character const* __cdecl get_path() throw(){ typedef __acrt_stdio_char_traits<Character> stdio_traits;
static Character const path_name[] = { 'P', 'A', 'T', 'H', '\0' };
Character* path_value = nullptr; if (_ERRCHECK_EINVAL(stdio_traits::tdupenv_s_crt(&path_value, nullptr, path_name)) != 0) return nullptr;
return path_value;}
template <typename Character>static Character const* __cdecl get_executable_path( Character const* const executable ) throw(){ typedef __acrt_stdio_char_traits<Character> stdio_traits;
// If we can access the given path, just use it: if (stdio_traits::taccess_s(executable, 0) == 0) return executable;
// Otherwise, we need to search the PATH: __crt_unique_heap_ptr<Character> buffer(_calloc_crt_t(Character, MAX_PATH)); if (buffer.get() == nullptr) return nullptr;
__crt_unique_heap_ptr<Character const> path(get_path<Character>());
Character const* current = path.get(); while ((current = stdio_traits::tgetpath(current, buffer.get(), MAX_PATH - 1)) != 0) { if (__crt_stdio_path_requires_backslash(buffer.get())) { static Character const backslash[] = { '\\', '\0' }; _ERRCHECK(stdio_traits::tcscat_s(buffer.get(), MAX_PATH, backslash)); }
if (stdio_traits::tcslen(buffer.get()) + stdio_traits::tcslen(executable) >= MAX_PATH) return nullptr;
_ERRCHECK(stdio_traits::tcscat_s(buffer.get(), MAX_PATH, executable));
if (stdio_traits::taccess_s(buffer.get(), 0) == 0) return buffer.detach(); }
return nullptr;}
template <typename Character>static FILE* __cdecl common_popen_nolock( Character const* const command, Character const* const fdopen_mode, int const std_fh, int (&pipe_handles)[2] ) throw(){ typedef __acrt_stdio_char_traits<Character> stdio_traits;
HANDLE const process_handle = GetCurrentProcess();
// We only return the second pipe handle to the caller; for the first pipe, // we just need to use the HANDLE: __crt_unique_handle new_pipe_handle; if (!DuplicateHandle( process_handle, reinterpret_cast<HANDLE>(_osfhnd(pipe_handles[0])), process_handle, new_pipe_handle.get_address_of(), 0, TRUE, DUPLICATE_SAME_ACCESS)) { return nullptr; }
_close(pipe_handles[0]); pipe_handles[0] = -1;
// Associate a stream with the pipe handle to be returned to the caller: unique_stream pipe_stream(stdio_traits::tfdopen(pipe_handles[1], fdopen_mode)); if (!pipe_stream) return nullptr;
// Obtain a proces handle pair in which to store the process handle: unique_process_handle_pair id_pair(idtab(nullptr)); if (!id_pair) return nullptr;
// Determine which command processor to use: command.com or cmd.exe: static Character const default_cmd_exe[] = { 'c', 'm', 'd', '.', 'e', 'x', 'e', '\0' };
__crt_unique_heap_ptr<Character const> const comspec_variable(get_comspec<Character>()); Character const* const cmd_exe = comspec_variable.get() != nullptr ? comspec_variable.get() : default_cmd_exe;
STARTUPINFOW startup_info = { 0 }; startup_info.cb = sizeof(startup_info);
// The following arguments are used by the OS for duplicating the handles: startup_info.dwFlags = STARTF_USESTDHANDLES; startup_info.hStdInput = std_fh == STDIN ? new_pipe_handle.get() : reinterpret_cast<HANDLE>(_osfhnd(0)); startup_info.hStdOutput = std_fh == STDOUT ? new_pipe_handle.get() : reinterpret_cast<HANDLE>(_osfhnd(1)); startup_info.hStdError = reinterpret_cast<HANDLE>(_osfhnd(2));
static Character const slash_c[] = { ' ', '/', 'c', ' ', '\0' };
size_t const command_line_count = stdio_traits::tcslen(cmd_exe) + stdio_traits::tcslen(slash_c) + stdio_traits::tcslen(command) + 1;
__crt_unique_heap_ptr<Character> const command_line(_calloc_crt_t(Character, command_line_count)); if (command_line.get() == nullptr) return nullptr;
_ERRCHECK(stdio_traits::tcscpy_s(command_line.get(), command_line_count, cmd_exe)); _ERRCHECK(stdio_traits::tcscat_s(command_line.get(), command_line_count, slash_c)); _ERRCHECK(stdio_traits::tcscat_s(command_line.get(), command_line_count, command));
// Find the path at which the executable is accessible: Character const* const selected_cmd_exe(get_executable_path(cmd_exe)); if (selected_cmd_exe == nullptr) return nullptr;
// If get_executable_path() returned a path other than the one we gave it, // we must be sure to free the string when we return: __crt_unique_heap_ptr<Character const> const owned_final_exe_path(selected_cmd_exe != cmd_exe ? selected_cmd_exe : nullptr);
PROCESS_INFORMATION process_info = PROCESS_INFORMATION(); BOOL const child_status = stdio_traits::create_process( selected_cmd_exe, command_line.get(), nullptr, nullptr, TRUE, 0, nullptr, nullptr, &startup_info, &process_info);
if (!child_status) return nullptr;
FILE* const result_stream = pipe_stream.detach();
CloseHandle(process_info.hThread); id_pair.get()->process_handle = reinterpret_cast<intptr_t>(process_info.hProcess); id_pair.get()->stream = result_stream; id_pair.detach(); return result_stream;}
template <typename Character>static FILE* __cdecl common_popen( Character const* const command, Character const* const type ) throw(){ _VALIDATE_RETURN(command != nullptr, EINVAL, nullptr); _VALIDATE_RETURN(type != nullptr, EINVAL, nullptr);
fdopen_mode<Character> const fdopen_mode = convert_popen_type_to_fdopen_mode(type); if (fdopen_mode.mode[0] == '\0') return nullptr;
// Do the _pipe(). Note that neither of the resulting handles is inheritable. int pipe_mode = _O_NOINHERIT; if (fdopen_mode.mode[1] == 't') { pipe_mode |= _O_TEXT; } if (fdopen_mode.mode[1] == 'b') { pipe_mode |= _O_BINARY; }
int pipe_handles[2]; if (_pipe(pipe_handles, 1024, pipe_mode) == -1) return nullptr;
int const std_fh = fdopen_mode.mode[0] == 'w' ? STDIN : STDOUT;
int ordered_pipe_handles[] = { std_fh == STDIN ? pipe_handles[0] : pipe_handles[1], std_fh == STDIN ? pipe_handles[1] : pipe_handles[0] };
FILE* return_value = nullptr;
__acrt_lock(__acrt_popen_lock); __try { errno_t const saved_errno = errno;
return_value = common_popen_nolock( command, fdopen_mode.mode, std_fh, ordered_pipe_handles);
errno = saved_errno;
if (return_value != nullptr) __leave;
// If the implementation function returned successfully, everything was // cleaned up except the lock. int* const first = ordered_pipe_handles; int* const last = first + _countof(ordered_pipe_handles); for (int* it = first; it != last; ++it) { if (*it != -1) _close(*it); } } __finally { __acrt_unlock(__acrt_popen_lock); } __endtry
return return_value;}
// Starts a child process using the given 'command' and opens a pipe to it, as// requested via the 'type'. If the 'type' string contains an 'r', the calling// process can read the child command's standard output via the returned stream.// If the 'type' string contains a 'w', the calling process can write to the// child command's standard input via the returned stream.//// Returns a usable stream on success; returns null on failure.extern "C" FILE* __cdecl _popen( char const* const command, char const* const type ){ return common_popen(command, type);}
extern "C" FILE* __cdecl _wpopen( wchar_t const* const command, wchar_t const* const type ){ return common_popen(command, type);}
// Waits on the child command with which the 'stream' is associated, then closes// the stream and its associated pipe. The 'stream' must have been returned from// a previous call to _popen(). This function looks up the process handle in the// global table, waits on it, then closes the stream.//// On success, the exit status of the child command is returned. The format of// the return value is the same as for cwait(), except that the low order and// high order bytes are swapped. If an error occurs, -1 is returned.extern "C" int __cdecl _pclose(FILE* const stream){ _VALIDATE_RETURN(stream != nullptr, EINVAL, -1);
int return_value = -1;
__acrt_lock(__acrt_popen_lock); __try { process_handle_pair* const id_pair = idtab(stream); if (id_pair == nullptr) { errno = EBADF; __leave; }
fclose(stream);
intptr_t const process_handle = id_pair->process_handle;
// Mark the id pair as free (we will close the handle in the call to _cwait): id_pair->stream = nullptr; id_pair->process_handle = 0;
// Wait on the child copy of the command processor and its children: errno_t const saved_errno = errno; errno = 0;
int status = 0; if (_cwait(&status, process_handle, _WAIT_GRANDCHILD) != -1 || errno == EINTR) { errno = saved_errno; return_value = status; __leave; }
errno = saved_errno; } __finally { __acrt_unlock(__acrt_popen_lock); } __endtry
return return_value;}