Something went wrong. Try again.
Reactos
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370//// cenvarg.cpp//// Copyright (c) Microsoft Corporation. All rights reserved.//// Defines the _cenvarg() and _capture_argv functions, which transform argument// vectors and environments for use by the _exec() and _spawn() functions.//#include <corecrt_internal.h>#include <errno.h>#include <corecrt_internal_traits.h>#include <stdarg.h>#include <stdio.h>#include <stdlib.h>#include <string.h>
#pragma warning(disable:__WARNING_POSTCONDITION_NULLTERMINATION_VIOLATION) // 26036
// Converts a main()-style argv arguments vector into a command line. On success,// returns a pointer to the newly constructed arguments block; the caller is// responsible for freeing the string. On failure, returns null and sets errno.template <typename Character>static errno_t __cdecl construct_command_line( Character const* const* const argv, Character** const command_line_result ) throw(){ typedef __crt_char_traits<Character> traits;
*command_line_result = nullptr;
// Compute the number of bytes required to store the arguments in argv in a // command line string (including spaces between arguments and a terminator): size_t const command_line_count = [&] { size_t n = 0; for (Character const* const* it = argv; *it; n += traits::tcslen(*it++) + 1) { }
// If there were no arguments, return 1 so that we can return an empty // string: return __max(n, 1); }();
__crt_unique_heap_ptr<Character> command_line(_calloc_crt_t(Character, command_line_count)); if (!command_line) { __acrt_errno_map_os_error(ERROR_NOT_ENOUGH_MEMORY); return errno = ENOMEM; }
Character const* const* source_it = argv; Character* result_it = command_line.get();
// If there are no arguments, just return the empty string: if (*source_it == nullptr) { *command_line_result = command_line.detach(); return 0; }
// Copy the arguments, separated by spaces: while (*source_it != nullptr) { _ERRCHECK(traits::tcscpy_s(result_it, command_line_count - (result_it - command_line.get()), *source_it)); result_it += traits::tcslen(*source_it); *result_it++ = ' '; ++source_it; }
// Replace the last space with a terminator: result_it[-1] = '\0';
*command_line_result = command_line.detach(); return 0;}
// Converts a main()-style envp environment vector into an environment block in// the form required by the CreateProcess API. On success, returns a pointer to// the newly constructed environment block; the caller is responsible for freeing// the block. On failure, returns null and sets errno.template <typename Character>static errno_t __cdecl construct_environment_block( _In_opt_z_ Character const* const* const envp, _Outptr_result_maybenull_ Character** const environment_block_result ) throw(){ typedef __crt_char_traits<Character> traits;
*environment_block_result = nullptr;
// If envp is null, we will use the current environment of this process as // the environment for the new process. No action is required in this case // because simply passing a null environment pointer to CreateProcess will // do the right thing. if (envp == nullptr) return 0;
// Get the value of the SystemRoot environment variable, if it is defined, // and compute the number of characters required to store it in the // envrionment block: Character const system_root_name[] = { 'S', 'y', 's', 't', 'e', 'm', 'R', 'o', 'o', 't', '\0' };
__crt_unique_heap_ptr<Character> system_root_value; if (_ERRCHECK_EINVAL(traits::tdupenv_s_crt(system_root_value.get_address_of(), nullptr, system_root_name)) != 0) return errno;
size_t const system_root_value_count = system_root_value ? traits::tcslen(system_root_value.get()) + 1 : 0;
size_t const system_root_count = _countof(system_root_name) + system_root_value_count;
// Compute the number of characters required to hold the environment // strings provided by the user: size_t const envp_count = [&] { size_t n = 2; // Account for double null terminator for (auto it = envp; *it != nullptr; n += traits::tcslen(*it++) + 1) { } return n; }();
// Get the current environment from the OS so that we can get the current // directory strings (those starting with '=') and append them to the user- // provided environment. __crt_unique_heap_ptr<Character> const os_environment(traits::get_environment_from_os()); if (!os_environment) return EINVAL;
// Find the first shell environment variable: Character* const first_cwd = [&] { Character* it = os_environment.get(); while (*it != '=') it += traits::tcslen(it) + 1; return it; }();
// Find the end of the shell environment variables (assume they are contiguous): Character* const last_cwd = [&] { Character* it = first_cwd; while (it[0] == '=' && it[1] != '\0' && it[2] == ':' && it[3] == '=') it += 4 + traits::tcslen(it + 4) + 1; return it; }();
size_t const cwd_count = last_cwd - first_cwd;
// Check to see if the SystemRoot is already defined in the environment: bool const system_root_defined_in_environment = [&] { for (auto it = envp; *it != nullptr; ++it) { if (traits::tcsnicmp(*it, system_root_name, traits::tcslen(system_root_name)) == 0) return true; }
return false; }();
// Allocate storage for the new environment: size_t const environment_block_count = system_root_defined_in_environment ? envp_count + cwd_count : envp_count + cwd_count + system_root_count; __crt_unique_heap_ptr<Character> environment_block(_calloc_crt_t(Character, environment_block_count)); if (!environment_block) { __acrt_errno_map_os_error(ERROR_OUTOFMEMORY); return errno = ENOMEM; }
// Build the environment block by concatenating the environment strings with // null characters between them, and with a double null terminator. Character* result_it = environment_block.get(); size_t remaining_characters = environment_block_count;
// Copy the cwd strings into the new environment: if (cwd_count != 0) { memcpy(result_it, first_cwd, cwd_count * sizeof(Character)); result_it += cwd_count; remaining_characters -= cwd_count; }
// Copy the environment strings from envp into the new environment: for (auto it = envp; *it != nullptr; ++it) { _ERRCHECK(traits::tcscpy_s(result_it, remaining_characters, *it)); size_t const count_copied = traits::tcslen(*it) + 1; result_it += count_copied; remaining_characters -= count_copied; }
// Copy the SystemRoot into the new environment: if (!system_root_defined_in_environment) { static Character const equal_sign[] = { '=', '\0' };
_ERRCHECK(traits::tcscpy_s(result_it, system_root_count, system_root_name)); _ERRCHECK(traits::tcscat_s(result_it, system_root_count, equal_sign)); if (system_root_value) { _ERRCHECK(traits::tcscat_s(result_it, system_root_count, system_root_value.get())); } result_it += system_root_count; }
// Null-terminate the environment block and return it. If the environment // block is empty, it requires two null terminators: if (result_it == environment_block.get()) *result_it++ = '\0';
*result_it = '\0';
*environment_block_result = environment_block.detach(); return 0;}
// Converts a main()-style argv arguments vector and envp environment vector into// a command line and an environment block, for use in the _exec and _spawn// functions. On success, returns 0 and sets the two result argumetns to point// to the newly created command line and environment block. The caller is// responsible for freeing these blocks. On failure, returns -1 and sets errno.template <typename Character>_Success_(return == 0)_Ret_range_(-1, 0)static int __cdecl common_pack_argv_and_envp( _In_z_ Character const* const* const argv, _In_opt_z_ Character const* const* const envp, _Outptr_result_maybenull_ Character** const command_line_result, _Outptr_result_maybenull_ Character** const environment_block_result ) throw(){ typedef __crt_char_traits<Character> traits;
__crt_unique_heap_ptr<Character> command_line; if (construct_command_line(argv, command_line.get_address_of()) != 0) return -1; __crt_unique_heap_ptr<Character> environment_block; if (construct_environment_block(envp, environment_block.get_address_of()) != 0) return -1;
*command_line_result = command_line.detach(); *environment_block_result = environment_block.detach(); return 0;}
extern "C" int __cdecl __acrt_pack_narrow_command_line_and_environment( char const* const* const argv, char const* const* const envp, char** const command_line_result, char** const environment_block_result ){ return common_pack_argv_and_envp(argv, envp, command_line_result, environment_block_result);}
extern "C" int __cdecl __acrt_pack_wide_command_line_and_environment( wchar_t const* const* const argv, wchar_t const* const* const envp, wchar_t** const command_line_result, wchar_t** const environment_block_result ){ return common_pack_argv_and_envp(argv, envp, command_line_result, environment_block_result);}
// Creates an argv array for the _exec and _spawn functions. This function walks// the provided varargs list, copying the char* or wchar_t* pointers into an// array. The caller_array is used first; if it is too small to fit all of the// arguments, an array is dynamically allocated. A pointer to the argv array is// returned to the caller. If the returned pointer is not 'caller_array', the// caller must free the array. On failure, nullptr is returned and errno is set.template <typename Character>_Success_(return != 0)static Character** __cdecl common_capture_argv( _In_ va_list* const arglist, _In_z_ Character const* const first_argument, _When_(return == caller_array, _Post_z_) _Out_writes_(caller_array_count) Character** const caller_array, _In_ size_t const caller_array_count ) throw(){ Character** argv = caller_array; size_t argv_count = caller_array_count;
__crt_unique_heap_ptr<Character*> local_array;
size_t i = 0; Character* next_argument = const_cast<Character*>(first_argument); for (;;) { if (i >= argv_count) { _VALIDATE_RETURN_NOEXC(SIZE_MAX / 2 > argv_count, ENOMEM, nullptr);
// If we have run out of room in the caller-provided array, allocate // an array on the heap and copy the contents of the caller-provided // array: if (argv == caller_array) { local_array = _calloc_crt_t(Character*, argv_count * 2); _VALIDATE_RETURN_NOEXC(local_array.get() != nullptr, ENOMEM, nullptr);
_ERRCHECK(memcpy_s(local_array.get(), argv_count * 2, caller_array, caller_array_count));
argv = local_array.get(); } // Otherwise, we have run out of room in a dynamically allocated // array. We need to reallocate: else { __crt_unique_heap_ptr<Character*> new_array(_recalloc_crt_t(Character*, local_array.get(), argv_count * 2)); _VALIDATE_RETURN_NOEXC(new_array.get() != nullptr, ENOMEM, nullptr);
local_array.detach(); local_array.attach(new_array.detach());
argv = local_array.get(); }
argv_count *= 2; }
argv[i++] = next_argument; if (!next_argument) break;
#pragma warning(suppress:__WARNING_INCORRECT_ANNOTATION) // 26007 Possibly incorrect single element annotation on arglist next_argument = va_arg(*arglist, Character*); }
// At this point, we have succeeded; either local_array is null, or argv is // local_array. In either case, we detach so that we can transfer ownership // to the caller: local_array.detach(); return argv;}
extern "C" char** __acrt_capture_narrow_argv( va_list* const arglist, char const* const first_argument, char** const caller_array, size_t const caller_array_count ){ return common_capture_argv(arglist, first_argument, caller_array, caller_array_count);}
extern "C" wchar_t** __acrt_capture_wide_argv( va_list* const arglist, wchar_t const* const first_argument, wchar_t** const caller_array, size_t const caller_array_count ){ return common_capture_argv(arglist, first_argument, caller_array, caller_array_count);}