crt_init.c File Reference

#include <precomp.h>

Include dependency graph for crt_init.c:

Go to the source code of this file.

Functions
int	BlockEnvToEnvironA (void)
int	BlockEnvToEnvironW (void)
void	FreeEnvironment (char **environment)
BOOL	msvcrt_init_heap (void)
void	msvcrt_init_mt_locks (void)
void	msvcrt_init_io (void)
BOOL	crt_process_init (void)

Variables
char *	_acmdln
wchar_t *	_wcmdln
char **	_environ
char **	__initenv
wchar_t **	_wenviron
wchar_t **	__winitenv

Function Documentation

BlockEnvToEnvironA()

int BlockEnvToEnvironA

(

void

)

Definition at line 34 of file environ.c.

{
   char *ptr, *environment_strings;
   char **envptr;
   int count = 1;
   size_t len;
 
   TRACE("BlockEnvToEnvironA()\n");
 
   environment_strings = GetEnvironmentStringsA();
   if (environment_strings == NULL) {
      return -1;
   }
 
   for (ptr = environment_strings; *ptr; ptr += len)
   {
      len = strlen(ptr) + 1;
      /* Skip drive letter settings. */
      if (*ptr != '=')
         count++;
   }
 
   __initenv = _environ = malloc(count * sizeof(char*));
   if (_environ)
   {
      for (ptr = environment_strings, envptr = _environ; count > 1; ptr += len)
      {
         len = strlen(ptr) + 1;
         /* Skip drive letter settings. */
         if (*ptr != '=')
         {
            if ((*envptr = malloc(len)) == NULL)
            {
               for (envptr--; envptr >= _environ; envptr--)
                  free(*envptr);
               FreeEnvironmentStringsA(environment_strings);
               free(_environ);
               __initenv = _environ = NULL;
               return -1;
            }
            memcpy(*envptr++, ptr, len);
            count--;
         }
      }
      /* Add terminating NULL entry. */
      *envptr = NULL;
   }
 
   FreeEnvironmentStringsA(environment_strings);
   return _environ ? 0 : -1;
}

Referenced by crt_process_init().

BlockEnvToEnvironW()

int BlockEnvToEnvironW

(

void

)

Definition at line 86 of file environ.c.

{
   wchar_t *ptr, *environment_strings;
   wchar_t **envptr;
   int count = 1;
   size_t len;
 
   TRACE("BlockEnvToEnvironW()\n");
 
   environment_strings = GetEnvironmentStringsW();
   if (environment_strings == NULL) {
      return -1;
   }
 
   for (ptr = environment_strings; *ptr; ptr += len)
   {
      len = wcslen(ptr) + 1;
      /* Skip drive letter settings. */
      if (*ptr != '=')
         count++;
   }
 
   __winitenv = _wenviron = malloc(count * sizeof(wchar_t*));
   if (_wenviron)
   {
      for (ptr = environment_strings, envptr = _wenviron; count > 1; ptr += len)
      {
         len = wcslen(ptr) + 1;
         /* Skip drive letter settings. */
         if (*ptr != '=')
         {
            if ((*envptr = malloc(len * sizeof(wchar_t))) == NULL)
            {
               for (envptr--; envptr >= _wenviron; envptr--)
                  free(*envptr);
               FreeEnvironmentStringsW(environment_strings);
               free(_wenviron);
               __winitenv = _wenviron = NULL;
               return -1;
            }
            memcpy(*envptr++, ptr, len * sizeof(wchar_t));
            count--;
         }
      }
      /* Add terminating NULL entry. */
      *envptr = NULL;
   }
 
   FreeEnvironmentStringsW(environment_strings);
   return _wenviron ? 0 : -1;
}

Referenced by crt_process_init().

crt_process_init()

BOOL crt_process_init

(

void

)

Definition at line 21 of file crt_init.c.

{
    OSVERSIONINFOW osvi;
 
    /* initialize version info */
    osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOW);
    GetVersionExW(&osvi);
    _winver     = (osvi.dwMajorVersion << 8) | osvi.dwMinorVersion;
    _winmajor   = osvi.dwMajorVersion;
    _winminor   = osvi.dwMinorVersion;
    _osplatform = osvi.dwPlatformId;
    _osver      = osvi.dwBuildNumber;
 
    /* create tls stuff */
    if (!msvcrt_init_tls())
        return FALSE;
 
    if (!msvcrt_init_heap())
        return FALSE;
 
    if (BlockEnvToEnvironA() < 0)
        return FALSE;
 
    if (BlockEnvToEnvironW() < 0)
    {
        FreeEnvironment(_environ);
        return FALSE;
    }
 
    _acmdln = _strdup(GetCommandLineA());
    _wcmdln = _wcsdup(GetCommandLineW());
 
    /* Initialization of the WINE code */
    msvcrt_init_mt_locks();
 
    //msvcrt_init_math();
    msvcrt_init_io();
    //msvcrt_init_console();
    //msvcrt_init_args();
    //msvcrt_init_signals();
 
    return TRUE;
}

Referenced by DllMain().

FreeEnvironment()

void FreeEnvironment

(

char **

environment

)

Internal function to deallocate environment block. Although it's parameter are defined as char**, it's able to work also with wide character environment block which are of type wchar_t**.

Parameters

environment

Environment to free.

Definition at line 190 of file environ.c.

{
   char **envptr;
   for (envptr = environment; *envptr != NULL; envptr++)
      free(*envptr);
   free(environment);
}

Referenced by crt_process_init().

msvcrt_init_heap()

BOOL msvcrt_init_heap

(

void

)

Definition at line 830 of file heap.c.

{
#if _MSVCR_VER <= 100 && !defined(__REACTOS__)
    heap = HeapCreate(0, 0, 0);
#else
    heap = GetProcessHeap();
#endif
    return heap != NULL;
}

Referenced by crt_process_init().

msvcrt_init_io()

void msvcrt_init_io

(

void

)

Definition at line 720 of file file.c.

{
  STARTUPINFOA  si;
  int           i;
  ioinfo        *fdinfo;
 
  GetStartupInfoA(&si);
  if (si.cbReserved2 >= sizeof(unsigned int) && si.lpReserved2 != NULL)
  {
    BYTE*       wxflag_ptr;
    HANDLE*     handle_ptr;
    unsigned int count;
 
    count = *(unsigned*)si.lpReserved2;
    wxflag_ptr = si.lpReserved2 + sizeof(unsigned);
    handle_ptr = (HANDLE*)(wxflag_ptr + count);
 
    count = min(count, (si.cbReserved2 - sizeof(unsigned)) / (sizeof(HANDLE) + 1));
    count = min(count, MSVCRT_MAX_FILES);
    for (i = 0; i < count; i++)
    {
      if ((*wxflag_ptr & WX_OPEN) && GetFileType(*handle_ptr) != FILE_TYPE_UNKNOWN)
      {
        fdinfo = get_ioinfo_alloc_fd(i);
        if(fdinfo != &MSVCRT___badioinfo)
            msvcrt_set_fd(fdinfo, *handle_ptr, *wxflag_ptr);
        release_ioinfo(fdinfo);
      }
 
      wxflag_ptr++; handle_ptr++;
    }
  }
 
  fdinfo = get_ioinfo_alloc_fd(STDIN_FILENO);
  if (!(fdinfo->wxflag & WX_OPEN) || fdinfo->handle == INVALID_HANDLE_VALUE) {
    HANDLE h = GetStdHandle(STD_INPUT_HANDLE);
    DWORD flags = WX_OPEN | WX_TEXT;
    DWORD type = GetFileType(h);
 
    if (type == FILE_TYPE_UNKNOWN) {
        h = MSVCRT_NO_CONSOLE;
        flags |= WX_TTY;
    } else if ((type & 0xf) == FILE_TYPE_CHAR) {
        flags |= WX_TTY;
    } else if ((type & 0xf) == FILE_TYPE_PIPE) {
        flags |= WX_PIPE;
    }
 
    msvcrt_set_fd(fdinfo, h, flags);
  }
  release_ioinfo(fdinfo);
 
  fdinfo = get_ioinfo_alloc_fd(STDOUT_FILENO);
  if (!(fdinfo->wxflag & WX_OPEN) || fdinfo->handle == INVALID_HANDLE_VALUE) {
    HANDLE h = GetStdHandle(STD_OUTPUT_HANDLE);
    DWORD flags = WX_OPEN | WX_TEXT;
    DWORD type = GetFileType(h);
 
    if (type == FILE_TYPE_UNKNOWN) {
        h = MSVCRT_NO_CONSOLE;
        flags |= WX_TTY;
    } else if ((type & 0xf) == FILE_TYPE_CHAR) {
        flags |= WX_TTY;
    } else if ((type & 0xf) == FILE_TYPE_PIPE) {
        flags |= WX_PIPE;
    }
 
    msvcrt_set_fd(fdinfo, h, flags);
  }
  release_ioinfo(fdinfo);
 
  fdinfo = get_ioinfo_alloc_fd(STDERR_FILENO);
  if (!(fdinfo->wxflag & WX_OPEN) || fdinfo->handle == INVALID_HANDLE_VALUE) {
    HANDLE h = GetStdHandle(STD_ERROR_HANDLE);
    DWORD flags = WX_OPEN | WX_TEXT;
    DWORD type = GetFileType(h);
 
    if (type == FILE_TYPE_UNKNOWN) {
        h = MSVCRT_NO_CONSOLE;
        flags |= WX_TTY;
    } else if ((type & 0xf) == FILE_TYPE_CHAR) {
        flags |= WX_TTY;
    } else if ((type & 0xf) == FILE_TYPE_PIPE) {
        flags |= WX_PIPE;
    }
 
    msvcrt_set_fd(fdinfo, h, flags);
  }
  release_ioinfo(fdinfo);
 
  TRACE(":handles (%p)(%p)(%p)\n", get_ioinfo_nolock(STDIN_FILENO)->handle,
        get_ioinfo_nolock(STDOUT_FILENO)->handle,
        get_ioinfo_nolock(STDERR_FILENO)->handle);
 
  for (i = 0; i < 3; i++)
  {
    FILE *f = iob_get_file(i);
    CRITICAL_SECTION *cs = file_get_cs(f);
 
    /* FILE structs for stdin/out/err are static and never deleted */
    f->_file = get_ioinfo_nolock(i)->handle == MSVCRT_NO_CONSOLE ?
        MSVCRT_NO_CONSOLE_FD : i;
    f->_tmpfname = NULL;
    f->_flag = (i == 0) ? _IOREAD : _IOWRT;
 
    if (cs)
    {
      InitializeCriticalSectionEx(cs, 0, RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO);
      cs->DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": file_crit.crit");
    }
  }
  MSVCRT_stream_idx = 3;
}

Referenced by crt_process_init().

msvcrt_init_mt_locks()

void msvcrt_init_mt_locks

(

void

)

Definition at line 66 of file lock.c.

{
  int i;
 
  TRACE( "initializing mtlocks\n" );
 
  /* Initialize the table */
  for( i=0; i < _TOTAL_LOCKS; i++ )
  {
    msvcrt_mlock_set_entry_initialized( i, FALSE );
  }
 
  /* Initialize our lock table lock */
  msvcrt_initialize_mlock( _LOCKTAB_LOCK );
}

Referenced by crt_process_init().

Variable Documentation

__initenv

char** __initenv

extern

Definition at line 24 of file environ.c.

__winitenv

wchar_t** __winitenv

extern

Definition at line 25 of file environ.c.

_acmdln

char* _acmdln

extern

Definition at line 18 of file environ.c.

Referenced by crt_process_init().

_environ

char** _environ

extern

Definition at line 22 of file environ.c.

Referenced by crt_process_init().

_wcmdln

wchar_t* _wcmdln

extern

Definition at line 19 of file environ.c.

Referenced by crt_process_init().

_wenviron

wchar_t** _wenviron

extern

Definition at line 23 of file environ.c.

Referenced by __p__wenviron(), BlockEnvToEnvironW(), and SetEnv().