Something went wrong. Try again.
Reactos
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374//// setenv.cpp//// Copyright (c) Microsoft Corporation. All rights reserved.//// Internal functions for setting or removing variables from an environment. The// logic for manipulating the environment data structures is split across this// file and environment_initialization.cpp.//#include <corecrt_internal.h>#include <corecrt_internal_traits.h>#include <limits.h>#include <stdlib.h>
static char**& __cdecl get_environment(char) throw() { return _environ_table.value(); }static wchar_t**& __cdecl get_environment(wchar_t) throw() { return _wenviron_table.value(); }
static wchar_t**& __cdecl get_other_environment(char) throw() { return _wenviron_table.value(); }static char**& __cdecl get_other_environment(wchar_t) throw() { return _environ_table.value(); }
static char**& __cdecl get_initial_environment(char) throw() { return __dcrt_initial_narrow_environment; }static wchar_t**& __cdecl get_initial_environment(wchar_t) throw() { return __dcrt_initial_wide_environment; }
// Makes a copy of the provided environment and returns the copy. The caller is// responsible for freeing the returned array (using the CRT free). Returns// nullptr on failure; terminates the process on allocation failure.template <typename Character>static Character** __cdecl copy_environment(Character** const old_environment) throw(){ typedef __crt_char_traits<Character> traits;
if (!old_environment) { return nullptr; }
// Count the number of environment variables: size_t entry_count = 0; for (Character** it = old_environment; *it; ++it) { ++entry_count; }
// We need one pointer for each string, plus one null pointer at the end: __crt_unique_heap_ptr<Character*> new_environment(_calloc_crt_t(Character*, entry_count + 1)); if (!new_environment) { abort(); }
Character** old_it = old_environment; Character** new_it = new_environment.get(); for (; *old_it; ++old_it, ++new_it) { size_t const required_count = traits::tcslen(*old_it) + 1; *new_it = _calloc_crt_t(Character, required_count).detach(); if (!*new_it) { abort(); }
_ERRCHECK(traits::tcscpy_s(*new_it, required_count, *old_it)); }
return new_environment.detach();}
// If the current environment is the initial environment, this function clones// the current environment so that it is not the initial environment. This// should be called any time that we are about to modify the current environment// but we do not know whether the current environment is the initial environment.template <typename Character>static void __cdecl ensure_current_environment_is_not_initial_environment_nolock() throw(){ if (get_environment(Character()) == get_initial_environment(Character())) { get_environment(Character()) = copy_environment(get_environment(Character())); }}
// Finds an environment variable in the specified environment. If a variable// with the given name is found, its index in the environment is returned. If// no such environment is found, the total number of environment variables is// returned, multiplied by -1. Note that a return value of 0 may indicate// either that the variable was found at index 0 or there are zero variables// in the environment. Be sure to check for this case.template <typename Character>static ptrdiff_t __cdecl find_in_environment_nolock( Character const* const name, size_t const length ) throw(){ typedef __crt_char_traits<Character> traits;
Character** const environment = get_environment(Character());
Character** it = nullptr; for (it = environment; *it; ++it) { // See if the first 'length' characters match: if (traits::tcsnicoll(name, *it, length) != 0) { continue; }
// Ensure that the next character of the environment is an '=' or '\0': if ((*it)[length] != '=' && (*it)[length] != '\0') { continue; }
// Otherwise, this entry matched; return its index in the environment: return static_cast<ptrdiff_t>(it - environment); }
// No entry matched; return the total number of strings, multiplied by -1: return -static_cast<ptrdiff_t>(it - environment);}
/****int __dcrt_set_variable_in_narrow_environment(option) - add/replace/remove variable in environment**Purpose:* option should be of the form "option=value". If a string with the* given option part already exists, it is replaced with the given* string; otherwise the given string is added to the environment.* If the string is of the form "option=", then the string is* removed from the environment, if it exists. If the string has* no equals sign, error is returned.**Entry:* TCHAR **poption - pointer to option string to set in the environment list.* should be of the form "option=value".* This function takes ownership of this pointer in the success case.* int primary - Only the primary call to _crt[w]setenv needs to* create new copies or set the OS environment.* 1 indicates that this is the primary call.**Exit:* returns 0 if OK, -1 if fails.* If *poption is non-null on exit, we did not free it, and the caller should* If *poption is null on exit, we did free it, and the caller should not.**Exceptions:**Warnings:* This code will not work if variables are removed from the environment* by deleting them from environ[]. Use _putenv("option=") to remove a* variable.** The option argument will be taken ownership of by this code and may be freed!********************************************************************************/template <typename Character>static int __cdecl common_set_variable_in_environment_nolock( Character* const option, int const is_top_level_call ) throw(){ typedef __crt_char_traits<Character> traits;
// Check that the option string is valid first. Find the '=' and verify // that '=' is not the first character in the string: _VALIDATE_RETURN_NOEXC(option != nullptr, EINVAL, -1); __crt_unique_heap_ptr<Character> owned_option(option);
Character* const equal_sign = traits::tcschr(option, '='); _VALIDATE_RETURN_NOEXC(equal_sign != nullptr && equal_sign != option, EINVAL, -1);
// Internal consistency check: The environment string should never use // buffers larger than _MAX_ENV. See also the SetEnvironmentVariable SDK // function. _ASSERTE(equal_sign - option < _MAX_ENV); _ASSERTE(traits::tcsnlen(equal_sign + 1, _MAX_ENV) < _MAX_ENV);
// If the character following '=' is the terminator, we are removing the // environment variable. Otherwise, we are adding or updating the variable: bool const is_removal = *(equal_sign + 1) == '\0';
// At program startup, the initial environment (__dcrt_initial_narrow_environment), which is passed // to main(), is backed by the same environment arrays as the global // environment used by getenv, setenv, et al. We cannot modify thie initial // environment, so we make a copy of it the first time we need to make any // modifications to the global environment: ensure_current_environment_is_not_initial_environment_nolock<Character>();
// If the required environment does not exist, see if the other environment // exists; if it does, convert it to create the required environment. These // functions will reenter this function once for each environment variable; // we use the top-level call flag to stop recursion. if (!get_environment(Character())) { if (is_top_level_call && get_other_environment(Character())) { _VALIDATE_RETURN_NOEXC(traits::get_or_create_environment_nolock() != nullptr, EINVAL, -1);
// The call to get_or_create_environment() may have initialized the // current environment to the same environment that is the initial // environment. Re-check and make a new copy of the environment to // modify if necessary. ensure_current_environment_is_not_initial_environment_nolock<Character>(); } else { // If the environment doesn't exist and the requested operation is a // removal, there is nothing to do (there is nothing to remove): if (is_removal) { return 0; }
// Create a new environment for each environment that does not exist. // Just start each off as an empty environment: if (!_environ_table.value()) { _environ_table.value() = _calloc_crt_t(char*, 1).detach(); }
if (!_environ_table.value()) { return -1; }
if (!_wenviron_table.value()) { _wenviron_table.value() = _calloc_crt_t(wchar_t*, 1).detach(); }
if (!_wenviron_table.value()) { return -1; } } }
// At this point, either [1] only one environment exists, or [2] both of the // environments exist and are in-sync. The only way they can get out of sync // is if there are conversion problems. For example, if the user sets two // Unicode environment variables, FOO1 and FOO2, and the conversion of these // to multibyte yields FOO? and FOO?, then these environment blocks will // differ. Character** const environment = get_environment(Character()); if (!environment) { _ASSERTE(("CRT logic error in setenv", 0)); return -1; }
// Try to find the option in the environment... ptrdiff_t const option_index = find_in_environment_nolock(option, equal_sign - option);
// ... if the string is already in the environment, we free up the original // string, then install the new string or shrink the environment: if (option_index >= 0 && environment[0]) { _free_crt(environment[option_index]);
// If this is a removal, shrink the environment: if (is_removal) { // Shift all of the entries down by one element: size_t i = static_cast<size_t>(option_index); for (; environment[i]; ++i) { environment[i] = environment[i + 1]; }
// Shrink the environment memory block. At this point, i is the // number of elements remaining in the environment. This realloc // should never fail, since we are shrinking the block, but it is // best to be careful. If it does fail, it doesn't matter. Character** new_environment = _recalloc_crt_t(Character*, environment, i).detach(); if (new_environment) { get_environment(Character()) = new_environment; } } // If this is a replacement, replace the variable: else { environment[option_index] = owned_option.detach(); } } // Otherwise, the string is not in the environment: else { // If this is a removal, it is a no-op: the variable does not exist. if (is_removal) { return 0; } // Otherwise, we need to append the string to the environment table, and // we must grow the table to do this: else { size_t const environment_count = static_cast<size_t>(-option_index); if (environment_count + 2 < environment_count) { return -1; }
if (environment_count + 2 >= SIZE_MAX / sizeof(Character*)) { return -1; }
Character** const new_environment = _recalloc_crt_t(Character*, environment, environment_count + 2).detach(); if (!new_environment) { return -1; }
new_environment[environment_count] = owned_option.detach(); new_environment[environment_count + 1] = nullptr;
get_environment(Character()) = new_environment; } }
// Update the operating system environment. Do not give an error if this // fails since the failure will not affect the user code unless it is making // direct calls to the operating system. We only need to do this for one of // the environments; the operating system synchronizes with the other // environment automatically. if (is_top_level_call) { size_t const count = traits::tcslen(option) + 2; __crt_unique_heap_ptr<Character> const buffer(_calloc_crt_t(Character, count)); if (!buffer) { return 0; }
Character* const name = buffer.get(); _ERRCHECK(traits::tcscpy_s(name, count, option));
Character* const value = name + (equal_sign - option) + 1; *(value - 1) = '\0'; // Overwrite the '=' with a null terminator
if (traits::set_environment_variable(name, is_removal ? nullptr : value) == 0) { errno = EILSEQ; return -1; } }
return 0;}
extern "C" int __cdecl __dcrt_set_variable_in_narrow_environment_nolock( char* const option, int const is_top_level_call ){ return common_set_variable_in_environment_nolock(option, is_top_level_call);}
extern "C" int __cdecl __dcrt_set_variable_in_wide_environment_nolock( wchar_t* const option, int const is_top_level_call ){ return common_set_variable_in_environment_nolock(option, is_top_level_call);}