#include <corecrt_internal.h>
#include <corecrt_internal_traits.h>
#include <limits.h>
#include <stdlib.h>

Include dependency graph for setenv.cpp:

Functions
static char **&__cdecl	get_environment (char) throw ()

static wchar_t **&__cdecl	get_environment (wchar_t) throw ()

static wchar_t **&__cdecl	get_other_environment (char) throw ()

static char **&__cdecl	get_other_environment (wchar_t) throw ()

static char **&__cdecl	get_initial_environment (char) throw ()

static wchar_t **&__cdecl	get_initial_environment (wchar_t) throw ()

template<typename Character >
static Character **__cdecl	copy_environment (Character **const old_environment) throw ()

template<typename Character >
static void __cdecl	ensure_current_environment_is_not_initial_environment_nolock () throw ()

template<typename Character >
static ptrdiff_t __cdecl	find_in_environment_nolock (Character const *const name, size_t const length) throw ()

template<typename Character >
static int __cdecl	common_set_variable_in_environment_nolock (Character *const option, int const is_top_level_call) throw ()

int __cdecl	__dcrt_set_variable_in_narrow_environment_nolock (char *const option, int const is_top_level_call)

int __cdecl	__dcrt_set_variable_in_wide_environment_nolock (wchar_t *const option, int const is_top_level_call)

Function Documentation

◆ __dcrt_set_variable_in_narrow_environment_nolock()

int __cdecl __dcrt_set_variable_in_narrow_environment_nolock	(	char *const	option,
		int const	is_top_level_call
	)

Definition at line 359 of file setenv.cpp.

{
    return common_set_variable_in_environment_nolock(option, is_top_level_call);
}

◆ __dcrt_set_variable_in_wide_environment_nolock()

int __cdecl __dcrt_set_variable_in_wide_environment_nolock	(	wchar_t *const	option,
		int const	is_top_level_call
	)

Definition at line 367 of file setenv.cpp.

{
    return common_set_variable_in_environment_nolock(option, is_top_level_call);
}

◆ common_set_variable_in_environment_nolock()

template<typename Character >

static int __cdecl common_set_variable_in_environment_nolock	(	Character *const	option,
		int const	is_top_level_call
	)
throw	(
	)

static

Definition at line 164 of file setenv.cpp.

{
    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;
}

Referenced by __dcrt_set_variable_in_narrow_environment_nolock(), and __dcrt_set_variable_in_wide_environment_nolock().

◆ copy_environment()

template<typename Character >

static Character **__cdecl copy_environment	(	Character **const	old_environment	)
throw	(
	)

static

Definition at line 32 of file setenv.cpp.

{
    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();
}

Referenced by ensure_current_environment_is_not_initial_environment_nolock().

◆ ensure_current_environment_is_not_initial_environment_nolock()

template<typename Character >

static void __cdecl ensure_current_environment_is_not_initial_environment_nolock	(	)
throw	(
	)

static

Definition at line 79 of file setenv.cpp.

{
    if (get_environment(Character()) == get_initial_environment(Character()))
    {
        get_environment(Character()) = copy_environment(get_environment(Character()));
    }
}

◆ find_in_environment_nolock()

template<typename Character >

static ptrdiff_t __cdecl find_in_environment_nolock	(	Character const *const	name,
		size_t const	length
	)
throw	(
	)

static

Definition at line 96 of file setenv.cpp.

{
    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);
}