#include <corecrt_internal_lowio.h>
#include <corecrt_internal_stdio.h>

Include dependency graph for ioinit.cpp:

Functions
static DWORD __cdecl	get_std_handle_id (int const fh) throw ()

static void __cdecl	initialize_inherited_file_handles_nolock () throw ()

static void	initialize_stdio_handles_nolock () throw ()

bool __cdecl	__acrt_initialize_lowio ()

bool __cdecl	__acrt_uninitialize_lowio (bool const)

Variables
__crt_lowio_handle_data	__badioinfo

int	_nhandle = 0

__crt_lowio_handle_data *	__pioinfo [IOINFO_ARRAYS] = { 0 }

Function Documentation

◆ __acrt_initialize_lowio()

bool __cdecl __acrt_initialize_lowio ( void )

Definition at line 224 of file ioinit.cpp.

{
    __acrt_lock(__acrt_lowio_index_lock);
    bool result = false;
    __try
    {
        // First, allocate and initialize the initial array of lowio files:
        if (__acrt_lowio_ensure_fh_exists(0) != 0)
            __leave;
 
        // Next, process and initialize all inherited file handles:
        initialize_inherited_file_handles_nolock();
 
        // Finally, initialize the stdio handles, if they were not inherited:
        initialize_stdio_handles_nolock();
        result = true;
    }
    __finally
    {
        __acrt_unlock(__acrt_lowio_index_lock);
    }
    __endtry
 
    return result;
}

◆ __acrt_uninitialize_lowio()

bool __cdecl __acrt_uninitialize_lowio ( bool const )

Definition at line 254 of file ioinit.cpp.

{
    for (size_t i = 0; i < IOINFO_ARRAYS; ++i)
    {
        if (!__pioinfo[i])
            continue;
 
        __acrt_lowio_destroy_handle_array(__pioinfo[i]);
        __pioinfo[i] = nullptr;
    }
 
    return true;
}

◆ get_std_handle_id()

static DWORD __cdecl get_std_handle_id	(	int const	fh	)
throw	(
	)

static

Definition at line 43 of file ioinit.cpp.

{
    // Convert the CRT file handle to the OS file handle for the three 
    // standard streams:
    switch (fh)
    {
    case 0: return STD_INPUT_HANDLE;
    case 1: return STD_OUTPUT_HANDLE;
    case 2: return STD_ERROR_HANDLE;
    }
 
    return STD_ERROR_HANDLE; // Unreachable, but the compiler can't know.
}

Referenced by initialize_stdio_handles_nolock().

◆ initialize_inherited_file_handles_nolock()

static void __cdecl initialize_inherited_file_handles_nolock	(	)
throw	(
	)

static

Definition at line 59 of file ioinit.cpp.

{
    STARTUPINFOW startup_info;
    GetStartupInfoW(&startup_info);
 
    // First check and see if we inherited any file handles.  If we didn't, then
    // we don't have anything to initialize:
    if (startup_info.cbReserved2 == 0 || startup_info.lpReserved2 == nullptr)
        return;
 
    // Get the number of inherited handles:
    int const handle_count = *reinterpret_cast<UNALIGNED int*>(startup_info.lpReserved2);
 
    // Compute the start of the passed file info and OS HANDLEs:
    unsigned char* const first_file =
        reinterpret_cast<unsigned char*>(startup_info.lpReserved2) + sizeof(int);
 
    UNALIGNED intptr_t* const first_handle =
        reinterpret_cast<UNALIGNED intptr_t*>(first_file + handle_count);
 
    // Do not attempt to inherit more than the maximum number of supported handles:
    int handles_to_inherit = handle_count < _NHANDLE_ 
        ? handle_count
        : _NHANDLE_;
 
    // Attempt to allocate the required number of handles.  If we fail for any
    // reason, we'll inherit as many handles as we can:
    __acrt_lowio_ensure_fh_exists(handles_to_inherit);
    if (handles_to_inherit > _nhandle)
        handles_to_inherit = _nhandle;
 
    // Validate and copy the provided file information:
    unsigned char*      it_file   = first_file;
    UNALIGNED intptr_t* it_handle = first_handle;
 
    for (int fh = 0; fh != handles_to_inherit; ++fh, ++it_file, ++it_handle)
    {
        HANDLE const real_handle = reinterpret_cast<HANDLE>(*it_handle);
 
        // If the provided information does not appear to describe an open,
        // valid file or device, skip it:
        if (real_handle == INVALID_HANDLE_VALUE)
            continue;
 
        if (*it_handle == _NO_CONSOLE_FILENO)
            continue;
 
        if ((*it_file & FOPEN) == 0)
            continue;
 
        // GetFileType cannot be called for pipe handles since it may "hang" if
        // there is a blocked read pending on the pipe in the parent.
        if ((*it_file & FPIPE) == 0 && GetFileType(real_handle) == FILE_TYPE_UNKNOWN)
            continue;
 
        // Okay, the file looks valid:
        __crt_lowio_handle_data* const pio = _pioinfo(fh);
        pio->osfhnd = *it_handle;
        pio->osfile = *it_file;
    }
}

Referenced by __acrt_initialize_lowio().

◆ initialize_stdio_handles_nolock()

static void initialize_stdio_handles_nolock	(	)
throw	(
	)

static

Definition at line 123 of file ioinit.cpp.

{
    for (int fh = 0; fh != STDIO_HANDLES_COUNT; ++fh)
    {
        __crt_lowio_handle_data* const pio = _pioinfo(fh);
 
        // If this handle was inherited from the parent process and initialized
        // already, make sure it has the FTEXT flag and continue:
        if (pio->osfhnd != reinterpret_cast<intptr_t>(INVALID_HANDLE_VALUE) &&
            pio->osfhnd != _NO_CONSOLE_FILENO)
        {
            pio->osfile |= FTEXT;
            continue;
        }
 
        // Regardless what happens next, the file will be treated as if it is
        // open in text mode:
        pio->osfile = FOPEN | FTEXT;
 
        // This handle has not yet been initialized, so  let's see if we can get
        // the handle from the OS:
        intptr_t const os_handle = reinterpret_cast<intptr_t>(GetStdHandle(get_std_handle_id(fh)));
 
        bool const is_valid_handle = 
            os_handle != reinterpret_cast<intptr_t>(INVALID_HANDLE_VALUE) &&
            os_handle != reinterpret_cast<intptr_t>(nullptr);
 
        DWORD const handle_type = is_valid_handle
            ? GetFileType(reinterpret_cast<HANDLE>(os_handle))
            : FILE_TYPE_UNKNOWN;
 
 
        if (handle_type != FILE_TYPE_UNKNOWN)
        {
            // The file type is known, so we obtained a valid handle from the
            // OS.  Finish initializing the lowio file object for this handle,
            // including the flag specifying whether this is a character device
            // or a pipe:
            pio->osfhnd = os_handle;
 
            if ((handle_type & 0xff) == FILE_TYPE_CHAR)
                pio->osfile |= FDEV;
 
            else if ((handle_type & 0xff) == FILE_TYPE_PIPE)
                pio->osfile |= FPIPE;
        }
        else
        {
            // We were unable to get the handles from the OS.  For stdin, stdout,
            // and stderr, if there is no valid OS handle, treat the CRT handle
            // as being open in text mode on a device with _NO_CONSOLE_FILENO
            // underlying it.  We use this value instead of INVALID_HANDLE_VALUE
            // to distinguish between a failure in opening a file and a program
            // run without a console:
            pio->osfile |= FDEV;
            pio->osfhnd = _NO_CONSOLE_FILENO;
 
            // Also update the corresponding stdio stream, unless stdio was
            // already terminated:
            if (__piob)
                __piob[fh]->_file = _NO_CONSOLE_FILENO;
        }
    }
}

Referenced by __acrt_initialize_lowio().

Variable Documentation

◆ __badioinfo

__crt_lowio_handle_data __badioinfo

Initial value:

=
{
    { },                         
    static_cast<intptr_t>(-1),   
    0,                           
    FTEXT,                       
    __crt_lowio_text_mode::ansi, 
    { LF, LF, LF },              
}