putenv.cpp File Reference

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

Include dependency graph for putenv.cpp:

Go to the source code of this file.

Functions
static bool	other_environment_exists (wchar_t) throw ()
static bool	other_environment_exists (char) throw ()
template<typename Character >
static size_t	compute_required_transform_buffer_count (Character const *const name, Character const *const value) throw ()
template<typename Character >
static Character *	create_environment_string (Character const *const name, Character const *const value) throw ()
template<typename Character >
static bool __cdecl	set_variable_in_other_environment (Character const *const name, Character const *const value) throw ()
template<typename Character >
static int __cdecl	common_putenv_nolock (Character const *const name, Character const *const value) throw ()
template<typename Character >
static int __cdecl	common_putenv (Character const *const name, Character const *const value) throw ()
int __cdecl	_putenv (char const *const option)
int __cdecl	_wputenv (wchar_t const *const option)
errno_t __cdecl	_putenv_s (char const *const name, char const *const value)
errno_t __cdecl	_wputenv_s (wchar_t const *const name, wchar_t const *const value)

Function Documentation

_putenv()

int __cdecl _putenv

(

char const *const

option

)

Definition at line 222 of file putenv.cpp.

{
    return common_putenv(option, static_cast<char const*>(nullptr));
}

_putenv_s()

errno_t __cdecl _putenv_s	(	char const *const	name,
		char const *const	value
	)

Definition at line 234 of file putenv.cpp.

{
    _VALIDATE_RETURN_ERRCODE(value != nullptr, EINVAL);
    return common_putenv(name, value) == 0 ? 0 : errno;
}

_wputenv()

int __cdecl _wputenv

(

wchar_t const *const

option

)

Definition at line 227 of file putenv.cpp.

{
    return common_putenv(option, static_cast<wchar_t const*>(nullptr));
}

_wputenv_s()

errno_t __cdecl _wputenv_s	(	wchar_t const *const	name,
		wchar_t const *const	value
	)

Definition at line 240 of file putenv.cpp.

{
    _VALIDATE_RETURN_ERRCODE(value != nullptr, EINVAL);
    return common_putenv(name, value) == 0 ? 0 : errno;
}

common_putenv()

template<typename Character >

static int __cdecl common_putenv ( Character const *const  name, Character const *const  value  ) throw ( )

static

Definition at line 199 of file putenv.cpp.

{
    int status = 0;
 
    __acrt_lock(__acrt_environment_lock);
    __try
    {
        status = common_putenv_nolock(name, value);
    }
    __finally
    {
        __acrt_unlock(__acrt_environment_lock);
    }
    __endtry
 
    return status;
}

Referenced by _putenv(), _putenv_s(), _wputenv(), and _wputenv_s().

common_putenv_nolock()

template<typename Character >

static int __cdecl common_putenv_nolock ( Character const *const  name, Character const *const  value  ) throw ( )

static

Definition at line 161 of file putenv.cpp.

{
    typedef __crt_char_traits<Character> traits;
 
    // Ensure that the environment is initialized:
    if (!_environ_table.value() && !_wenviron_table.value())
        return -1;
 
    // At startup, we obtain the "native" flavor of environment strings from the
    // operating system.  So, a "main" program has _environ set and a "wmain"
    // program has _wenviron set.  Only when the user gets or puts the "other"
    // flavor do we convert it.
    _VALIDATE_RETURN(name != nullptr, EINVAL, -1);
 
    __crt_unique_heap_ptr<Character> new_option(create_environment_string(name, value));
    if (!new_option)
        return -1;
 
    if (traits::set_variable_in_environment_nolock(new_option.detach(), 1) != 0)
        return -1;
 
    // See if the "other" environment type exists; if it doesn't, we're done.
    // Otherwise, put the new option into the other environment as well.
    if (!other_environment_exists(Character()))
        return 0;
 
    if (!set_variable_in_other_environment(name, value))
        return -1;
 
    return 0;
}

Referenced by common_putenv().

compute_required_transform_buffer_count()

template<typename Character >

static size_t compute_required_transform_buffer_count ( Character const *const  name, Character const *const  value  ) throw ( )

static

Definition at line 25 of file putenv.cpp.

{
    // Compute the amount of space required for the transformation:
    size_t const name_count_required = __crt_compute_required_transform_buffer_count(CP_ACP, name);
    _VALIDATE_RETURN_NOEXC(name_count_required != 0, EILSEQ, false);
 
    if (!value)
        return name_count_required;
 
    size_t const value_count_required = __crt_compute_required_transform_buffer_count(CP_ACP, value);
    _VALIDATE_RETURN_NOEXC(value_count_required != 0, EILSEQ, false);
 
    // Note that each count includes space a the null terminator.  Since we'll
    // only be storing one terminator in the buffer, the space for the other
    // terminator will be used to store the '=' between the name and the value.
    return name_count_required + value_count_required;
}

Referenced by set_variable_in_other_environment().

create_environment_string()

template<typename Character >

static Character * create_environment_string ( Character const *const  name, Character const *const  value  ) throw ( )

static

Definition at line 52 of file putenv.cpp.

{
    typedef __crt_char_traits<Character> traits;
 
    if (value)
    {
        size_t const name_length  = traits::tcsnlen(name,  _MAX_ENV);
        size_t const value_length = traits::tcsnlen(value, _MAX_ENV);
 
        _VALIDATE_RETURN(name_length  < _MAX_ENV, EINVAL, nullptr);
        _VALIDATE_RETURN(value_length < _MAX_ENV, EINVAL, nullptr);
 
        // We add two to the length:  one for the '=' and one for the terminator
        size_t const buffer_count = name_length + 1 + value_length + 1;
 
        __crt_unique_heap_ptr<Character> buffer(_calloc_crt_t(Character, buffer_count));
        if (!buffer)
            return nullptr;
 
        traits::tcscpy_s(buffer.get(), buffer_count, name);
        buffer.get()[name_length] = '=';
        traits::tcscpy_s(buffer.get() + name_length + 1, value_length + 1, value);
 
        return buffer.detach();
    }
    else
    {
        Character const* const equal_sign_it = traits::tcschr(name, '=');
        if (equal_sign_it)
        {
            // Validate the length of both the name and the value:
            _VALIDATE_RETURN(equal_sign_it - name < _MAX_ENV,                         EINVAL, nullptr);
            _VALIDATE_RETURN(traits::tcsnlen(equal_sign_it + 1, _MAX_ENV) < _MAX_ENV, EINVAL, nullptr);
        }
 
        size_t const buffer_count = traits::tcslen(name) + 1;
 
        __crt_unique_heap_ptr<Character> buffer(_calloc_crt_t(Character, buffer_count));
        if (!buffer)
            return nullptr;
 
        traits::tcscpy_s(buffer.get(), buffer_count, name);
 
        return buffer.detach();
    }
}

Referenced by common_putenv_nolock().

other_environment_exists() [1/2]

static bool other_environment_exists ( char  ) throw ( )

static

Definition at line 18 of file putenv.cpp.

{ return _wenviron_table.value() != nullptr; }

other_environment_exists() [2/2]

static bool other_environment_exists ( wchar_t  ) throw ( )

static

Definition at line 17 of file putenv.cpp.

{ return _environ_table.value() != nullptr; }

Referenced by common_putenv_nolock().

set_variable_in_other_environment()

template<typename Character >

static bool __cdecl set_variable_in_other_environment ( Character const *const  name, Character const *const  value  ) throw ( )

static

Definition at line 107 of file putenv.cpp.

{
    typedef __crt_char_traits<Character>       traits;
    typedef typename traits::other_char_type   other_char_type;
    typedef __crt_char_traits<other_char_type> other_traits;
 
    size_t const buffer_count = compute_required_transform_buffer_count(name, value);
 
    __crt_unique_heap_ptr<other_char_type> buffer(_calloc_crt_t(other_char_type, buffer_count));
    if (!buffer)
        return false;
 
    size_t const name_written_count = __crt_transform_string(CP_ACP, name, buffer.get(), buffer_count);
    _VALIDATE_RETURN_NOEXC(name_written_count != 0, EILSEQ, false);
 
    if (value)
    {
        // Overwrite the null terminator with an '=':
        buffer.get()[name_written_count - 1] = '=';
 
        size_t const value_written_count = __crt_transform_string(
            CP_ACP,
            value,
            buffer.get() + name_written_count,
            buffer_count - name_written_count);
        _VALIDATE_RETURN_NOEXC(value_written_count != 0, EILSEQ, false);
    }
 
    return other_traits::set_variable_in_environment_nolock(buffer.detach(), 0) == 0;
}

Referenced by common_putenv_nolock().