searchenv.cpp File Reference

#include <direct.h>
#include <corecrt_internal_traits.h>
#include <io.h>
#include <stdlib.h>
#include <string.h>

Include dependency graph for searchenv.cpp:

Go to the source code of this file.

Functions
template<typename Character >
static errno_t __cdecl	common_searchenv_s (_In_z_ Character const *const file_name, _In_z_ Character const *const environment_variable, _Out_writes_z_(result_count) Character *const result_buffer, _In_ size_t const result_count) throw ()
errno_t __cdecl	_searchenv_s (char const *const file_name, char const *const environment_variable, char *const result_buffer, size_t const result_count)
errno_t __cdecl	_wsearchenv_s (wchar_t const *const file_name, wchar_t const *const environment_variable, wchar_t *const result_buffer, size_t const result_count)
void __cdecl	_searchenv (char const *const file_name, char const *const environment_variable, char *const result_buffer)
void __cdecl	_wsearchenv (wchar_t const *const file_name, wchar_t const *const environment_variable, wchar_t *const result_buffer)

Function Documentation

_searchenv()

void __cdecl _searchenv	(	char const *const	file_name,
		char const *const	environment_variable,
		char *const	result_buffer
	)

Definition at line 199 of file searchenv.cpp.

{
    common_searchenv_s(file_name, environment_variable, result_buffer, _MAX_PATH);
}

_searchenv_s()

errno_t __cdecl _searchenv_s	(	char const *const	file_name,
		char const *const	environment_variable,
		char *const	result_buffer,
		size_t const	result_count
	)

Definition at line 177 of file searchenv.cpp.

{
    return common_searchenv_s(file_name, environment_variable, result_buffer, result_count);
}

_wsearchenv()

void __cdecl _wsearchenv	(	wchar_t const *const	file_name,
		wchar_t const *const	environment_variable,
		wchar_t *const	result_buffer
	)

Definition at line 208 of file searchenv.cpp.

{
    common_searchenv_s(file_name, environment_variable, result_buffer, _MAX_PATH);
}

_wsearchenv_s()

errno_t __cdecl _wsearchenv_s	(	wchar_t const *const	file_name,
		wchar_t const *const	environment_variable,
		wchar_t *const	result_buffer,
		size_t const	result_count
	)

Definition at line 187 of file searchenv.cpp.

{
    return common_searchenv_s(file_name, environment_variable, result_buffer, result_count);
}

common_searchenv_s()

template<typename Character >

static errno_t __cdecl common_searchenv_s ( _In_z_ Character const *const  file_name, _In_z_ Character const *const  environment_variable, _Out_writes_z_(result_count) Character *const  result_buffer, _In_ size_t const  result_count  ) throw ( )

static

Definition at line 27 of file searchenv.cpp.

{
    typedef __crt_char_traits<Character> traits;
 
    _VALIDATE_RETURN_ERRCODE(result_buffer != nullptr, EINVAL);
    _VALIDATE_RETURN_ERRCODE(result_count  >  0,       EINVAL);
    if (!file_name)
    {
        result_buffer[0] = '\0';
        _VALIDATE_RETURN_ERRCODE(file_name != nullptr, EINVAL);
    }
 
    // Special case:  If the file name is an empty string, we'll just return an
    // empty result_buffer and set errno:
    if (file_name[0] == '\0')
    {
        result_buffer[0] = '\0';
        return errno = ENOENT;
    }
 
    errno_t saved_errno = errno;
    int const access_result = traits::taccess_s(file_name, 0);
    errno = saved_errno;
 
    // If the file name exists, convert it to a fully qualified result_buffer name:
    if (access_result == 0)
    {
        if (traits::tfullpath(result_buffer, file_name, result_count) == nullptr)
        {
            result_buffer[0] = '\0';
            return errno; // fullpath will set errno
        }
 
        return 0;
    }
 
    Character* path_string = nullptr;
    if (_ERRCHECK_EINVAL(traits::tdupenv_s_crt(&path_string, nullptr, environment_variable)) != 0 || path_string == nullptr)
    {   
        result_buffer[0] = '\0';
        return errno = ENOENT; // The environment variable doesn't exist
    }
 
    __crt_unique_heap_ptr<Character> const path_string_cleanup(path_string);
 
    size_t const file_name_length = traits::tcslen(file_name);
    
    size_t const local_path_count = _MAX_PATH + 4;
    Character local_path_buffer[local_path_count];
    
    size_t     path_count  = local_path_count;
    Character* path_buffer = local_path_buffer;
    if (file_name_length >= result_count)
    {
        // The local buffer is not large enough; dynamically allocate a new
        // buffer.  We add two to the size to account for a trailing slash
        // that we may need to add and for the null terminator:
        path_count  = traits::tcslen(path_string) + file_name_length + 2;
        path_buffer = _calloc_crt_t(Character, path_count).detach(); // We'll retake ownership below
        if (!path_buffer)
        {
            result_buffer[0] = '\0';
            return errno = ENOMEM;
        }
    }
 
    __crt_unique_heap_ptr<Character> path_buffer_cleanup(path_buffer == local_path_buffer
        ? nullptr
        : path_buffer);
 
    saved_errno = errno;
    while (path_string)
    {
        Character* const previous_path_string = path_string;
        path_string = traits::tgetpath(path_string, path_buffer, path_count - file_name_length - 1);
        if (!path_string && path_buffer == local_path_buffer && errno == ERANGE)
        {
            // If the getpath operation failed because the buffer was not large
            // enough, try allocating a larger buffer:
            size_t const required_count = traits::tcslen(previous_path_string) + file_name_length + 2;
 
            path_buffer_cleanup = _calloc_crt_t(Character, required_count);
            if (!path_buffer_cleanup)
            {
                result_buffer[0] = '\0';
                return errno = ENOMEM;
            }
 
            path_count  = required_count;
            path_buffer = path_buffer_cleanup.get();
 
            path_string = traits::tgetpath(previous_path_string, path_buffer, path_count - file_name_length);
        }
 
        if (!path_string || path_buffer[0] == '\0')
        {
            result_buffer[0] = '\0';
            return errno = ENOENT;
        }
 
        // The result_buffer now holds a non-empty path name from path_string
        // and we know that the buffer is large enough to hold the concatenation
        // of the path with the file name (if not, the call to getpath would
        // have failed.  So, we concatenate the path and file names:
        size_t path_length = traits::tcslen(path_buffer);
        Character* path_it = path_buffer + path_length;
        
        // Add a trailing '\' if one is required:
        Character const last_character = *(path_it - 1);
        if (last_character != '/' && last_character != '\\' && last_character != ':')
        {
            *path_it++ = '\\';
            ++path_length;
        }
 
        // The path_it now points to the character following the trailing '\',
        // '/', or ':'; this is where we copy the file name:
        _ERRCHECK(traits::tcscpy_s(path_it, path_count - path_length, file_name));
 
        // If we can't access the file at this path, it isn't a match:
        if (traits::taccess_s(path_buffer, 0) != 0)
            continue;
 
        // Otherwise, we can access the file, and we copy the full path into the
        // caller-provided buffer:
        if (path_length + file_name_length + 1 > result_count)
        {
            result_buffer[0] = '\0';
            return errno = ERANGE;
        }
 
        errno = saved_errno;
 
        _ERRCHECK(traits::tcscpy_s(result_buffer, result_count, path_buffer));
        return 0;
    }
 
    // If we get here, we must have tried every path in the environment and not
    // found the file name:
    result_buffer[0] = '\0';
    return errno = ENOENT;
}

Referenced by _searchenv(), _searchenv_s(), _wsearchenv(), and _wsearchenv_s().