int
__tmainCRTStartup(
void
) {
unsigned int osplatform = 0;
unsigned int winver = 0;
unsigned int winmajor = 0;
unsigned int winminor = 0;
unsigned int osver = 0;
int initret;
int mainret = 0;
OSVERSIONINFOA* posvi;
int managedapp;
#ifdef _WINMAIN_
_TUCHAR* lpszCommandLine;
STARTUPINFO StartupInfo;
__try {
/*
Note: MSDN specifically notes that GetStartupInfo returns no error, and throws unspecified SEH if it fails, so
the very general exception handler below is appropriate
*/
GetStartupInfo(&StartupInfo);
} __except (EXCEPTION_EXECUTE_HANDLER) {
return 255;
}
#endif /* _WINMAIN_ */
/*
* Dynamically allocate the OSVERSIONINFOA buffer, so we avoid
* triggering the /GS buffer overrun detection. That can't be
* used here, since the guard cookie isn't available until we
* initialize it from here!
*/
posvi = (OSVERSIONINFOA*)HeapAlloc(GetProcessHeap(), 0, sizeof(OSVERSIONINFOA));
if (!posvi) {
fast_error_exit(_RT_HEAP);
return 255;
}
/*
* Get the full Win32 version
*/
posvi->dwOSVersionInfoSize = sizeof(OSVERSIONINFOA);
if (!GetVersionExA(posvi)) {
HeapFree(GetProcessHeap(), 0, posvi);
return 255;
}
osplatform = posvi->dwPlatformId;
winmajor = posvi->dwMajorVersion;
winminor = posvi->dwMinorVersion;
/*
* The somewhat bizarre calculations of _osver and _winver are
* required for backward compatibility (used to use GetVersion)
*/
osver = (posvi->dwBuildNumber) & 0x07fff;
HeapFree(GetProcessHeap(), 0, posvi);
if (osplatform != VER_PLATFORM_WIN32_NT) {
osver |= 0x08000;
}
winver = (winmajor << 8) + winminor;
_set_osplatform(osplatform);
_set_winver(winver);
_set_winmajor(winmajor);
_set_winminor(winminor);
_set_osver(osver);
/*
* Determine if this is a managed application
*/
managedapp = check_managed_app();
if (!_heap_init(1)) { /* initialize heap */
fast_error_exit(_RT_HEAPINIT); /* write message and die */
}
if (!_mtinit()) { /* initialize multi-thread */
fast_error_exit(_RT_THREAD); /* write message and die */
}
/* Enable buffer count checking if linking against static lib */
_CrtSetCheckCount(TRUE);
/*
* Initialize the Runtime Checks stuff
*/
#ifdef _RTC
_RTC_Initialize();
#endif /* _RTC */
/*
* Guard the remainder of the initialization code and the call
* to user's main, or WinMain, function in a __try/__except
* statement.
*/
__try {
if (_ioinit() < 0) { /* initialize lowio */
_amsg_exit(_RT_LOWIOINIT);
}
/* get wide cmd line info */
_tcmdln = (_TSCHAR*)GetCommandLineT();
/* get wide environ info */
_tenvptr = (_TSCHAR*)GetEnvironmentStringsT();
if (_tsetargv() < 0) {
_amsg_exit(_RT_SPACEARG);
}
if (_tsetenvp() < 0) {
_amsg_exit(_RT_SPACEENV);
}
initret = _cinit(TRUE); /* do C data initialize */
if (initret != 0) {
_amsg_exit(initret);
}
#ifdef _WINMAIN_
lpszCommandLine = _twincmdln();
mainret = _tWinMain((HINSTANCE)&__ImageBase,
NULL,
lpszCommandLine,
StartupInfo.dwFlags & STARTF_USESHOWWINDOW
? StartupInfo.wShowWindow
: SW_SHOWDEFAULT
);
#else /* _WINMAIN_ */
_tinitenv = _tenviron;
mainret = _tmain(__argc, _targv, _tenviron);
#endif /* _WINMAIN_ */
if (!managedapp) {
exit(mainret);
}
_cexit();
} __except (_XcptFilter(GetExceptionCode(), GetExceptionInformation())) {
/*
* Should never reach here
*/
mainret = GetExceptionCode();
if (!managedapp) {
_exit(mainret);
}
_c_exit();
} /* end of try - except */
return mainret;
}
BOOL __cdecl
__CRTDLL_INIT(
HANDLE hDllHandle,
DWORD dwReason,
LPVOID lpreserved
)
{
BOOL term_all = FALSE;
if ( dwReason == DLL_PROCESS_ATTACH ) {
if ( !_heap_init() ) /* initialize heap */
/*
* The heap cannot be initialized, return failure to the
* loader.
*/
return FALSE;
if(!_mtinit()) /* initialize multi-thread */
{
/*
* If the DLL load is going to fail, we must clean up
* all resources that have already been allocated.
*/
_heap_term(); /* heap is now invalid! */
return FALSE; /* fail DLL load on failure */
}
if (_ioinit() < 0)
{
_mtterm(); /* free TLS index, call _mtdeletelocks() */
_heap_term(); /* heap is now invalid! */
return FALSE; /* fail DLL load on failure */
}
_wcmdln = GetCommandLineW();
#if !defined(_CRT_APP) || defined(_KERNELX)
_aenvptr = (char *)__crtGetEnvironmentStringsA();
_acmdln = GetCommandLineA();
#else /* !defined(_CRT_APP) || defined(_KERNELX) */
// We cannot call GetCommandLineA in the App CRT:
if (!__copy_to_char(_wcmdln, &_acmdln))
{
_acmdln = NULL;
}
#endif /* !defined(_CRT_APP) || defined(_KERNELX) */
#if !defined(_CRT_APP) || defined(_KERNELX)
#ifdef _MBCS
/*
* Initialize multibyte ctype table. Always done since it is
* needed for processing the environment strings.
*/
__initmbctable();
#endif /* _MBCS */
if (_setenvp() < 0 || /* get environ info */
_cinit(FALSE) != 0) /* do C data initialize */
{
term_all = TRUE;
}
#else /* !defined(_CRT_APP) || defined(_KERNELX) */
if (_cinit(FALSE) != 0) /* do C data initialize */
{
term_all = TRUE;
}
#endif /* !defined(_CRT_APP) || defined(_KERNELX) */
if (term_all)
{
#if defined(_CRT_APP) && !defined(_KERNELX)
_free_crt(_acmdln);
_acmdln = NULL;
#endif
_ioterm(); /* shut down lowio */
_mtterm(); /* free TLS index, call _mtdeletelocks() */
_heap_term(); /* heap is now invalid! */
return FALSE; /* fail DLL load on failure */
}
/*
* Increment flag indicating process attach notification
* has been received.
*/
proc_attached++;
}
else if ( dwReason == DLL_PROCESS_DETACH ) {
/*
* if a client process is detaching, make sure minimal
* runtime termination is performed and clean up our
* 'locks' (i.e., delete critical sections).
*/
if ( proc_attached > 0 ) {
proc_attached--;
__try {
/*
* Any basic clean-up done here may also need
* to be done below if Process Attach is partly
* processed and then a failure is encountered.
*/
if ( _C_Termination_Done == FALSE )
_cexit();
__crtdll_callstaticterminators();
/* Free all allocated CRT memory */
__freeCrtMemory();
#ifdef _DEBUG
/* Dump all memory leaks */
if (_CrtSetDbgFlag(_CRTDBG_REPORT_FLAG) & _CRTDBG_LEAK_CHECK_DF)
{
_CrtSetDumpClient(NULL);
_CrtDumpMemoryLeaks();
}
#endif /* _DEBUG */
/*
* What remains is to clean up the system resources we have
* used (handles, critical sections, memory,...,etc.). This
* needs to be done if the whole process is NOT terminating.
*/
/* If dwReason is DLL_PROCESS_DETACH, lpreserved is NULL
* if FreeLibrary has been called or the DLL load failed
* and non-NULL if the process is terminating.
*/
if ( lpreserved == NULL )
{
#if defined(_CRT_APP) && !defined(_KERNELX)
_free_crt(_acmdln);
_acmdln = NULL;
#endif
/*
* The process is NOT terminating so we must clean up...
*/
_ioterm();
/* free TLS index, call _mtdeletelocks() */
_mtterm();
/* This should be the last thing the C run-time does */
_heap_term(); /* heap is now invalid! */
}
}
__finally {
/* we shouldn't really have to care about this, because
letting an exception escape from DllMain(DLL_PROCESS_DETACH) should
result in process termination. Unfortunately, Windows up to Win7 as of now
just silently swallows the exception.
I have considered all kinds of tricks, but decided to leave it up to OS
folks to fix this.
For the time being just remove our FLS callback during phase 2 unwind
that would otherwise be left pointing to unmapped address space.
*/
if ( lpreserved == NULL && __flsindex != FLS_OUT_OF_INDEXES )
_mtterm();
}
}
else
/* no prior process attach, just return */
return FALSE;
BOOL WINAPI _CRT_INIT(
HANDLE hDllHandle,
DWORD dwReason,
LPVOID lpreserved
) {
unsigned int osplatform = 0;
unsigned int winver = 0;
unsigned int winmajor = 0;
unsigned int winminor = 0;
unsigned int osver = 0;
/*
* Start-up code only gets executed when the process is initialized
*/
if (dwReason == DLL_PROCESS_ATTACH) {
/*
* Dynamically allocate the OSVERSIONINFOA buffer, so we avoid
* triggering the /GS buffer overrun detection. That can't be
* used here, since the guard cookie isn't available until we
* initialize it from here!
*/
OSVERSIONINFOA* posvi =
(OSVERSIONINFOA*)HeapAlloc(GetProcessHeap(), 0, sizeof(OSVERSIONINFOA));
if (!posvi) {
return FALSE;
}
/*
* Get the full Win32 version
*/
posvi->dwOSVersionInfoSize = sizeof(OSVERSIONINFOA);
if (!GetVersionExA(posvi)) {
HeapFree(GetProcessHeap(), 0, posvi);
return FALSE;
}
osplatform = posvi->dwPlatformId;
winmajor = posvi->dwMajorVersion;
winminor = posvi->dwMinorVersion;
/*
* The somewhat bizarre calculations of _osver and _winver are
* required for backward compatibility (used to use GetVersion)
*/
osver = (posvi->dwBuildNumber) & 0x07fff;
HeapFree(GetProcessHeap(), 0, posvi);
if (osplatform != VER_PLATFORM_WIN32_NT) {
osver |= 0x08000;
}
winver = (winmajor << 8) + winminor;
_set_osplatform(osplatform);
_set_winver(winver);
_set_winmajor(winmajor);
_set_winminor(winminor);
_set_osver(osver);
if (!_heap_init(1)) { /* initialize heap */
return FALSE; /* fail to load DLL */
}
if (!_mtinit()) { /* initialize multi-thread */
_heap_term(); /* heap is now invalid! */
return FALSE; /* fail to load DLL */
}
/*
* Initialize the Runtime Checks stuff
*/
#ifdef _RTC
_RTC_Initialize();
#endif /* _RTC */
_acmdln = (char*)GetCommandLineA();
_aenvptr = (char*)__crtGetEnvironmentStringsA();
if (_ioinit() < 0) { /* initialize lowio */
_mtterm(); /* free TLS index, call _mtdeletelocks() */
_heap_term(); /* heap is now invalid! */
return FALSE; /* fail to load DLL */
}
if (_setargv() < 0 || /* get cmd line info */
_setenvp() < 0 || /* get environ info */
_cinit(FALSE) != 0) { /* do C data initialize, but don't init floating point */
_ioterm(); /* shut down lowio */
_mtterm(); /* free TLS index, call _mtdeletelocks() */
_heap_term(); /* heap is now invalid! */
return FALSE; /* fail to load DLL */
}
/* Enable buffer count checking if linking against static lib */
_CrtSetCheckCount(TRUE);
/*
* increment flag to indicate process attach notification
* has been received
*/
__proc_attached++;
} else if (dwReason == DLL_PROCESS_DETACH) {
if (__proc_attached > 0) {
__proc_attached--;
/*
* Any basic clean-up code that goes here must be duplicated
* below in _DllMainCRTStartup for the case where the user's
* DllMain() routine fails on a Process Attach notification.
* This does not include calling user C++ destructors, etc.
*/
if (_C_Termination_Done == FALSE) {
_cexit();
}
#ifdef _DEBUG
/* Dump all memory leaks */
if (_CrtSetDbgFlag(_CRTDBG_REPORT_FLAG) & _CRTDBG_LEAK_CHECK_DF) {
_CrtDumpMemoryLeaks();
}
#endif /* _DEBUG */
/*
* What remains is to clean up the system resources we have
* used (handles, critical sections, memory,...,etc.). This
* needs to be done if the whole process is NOT terminating.
*/
#ifndef _DEBUG
if (lpreserved == NULL) {
#endif /* _DEBUG */
/*
* The process is NOT terminating so we must clean up...
*/
/* Shut down lowio */
_ioterm();
_mtterm();
/* This should be the last thing the C run-time does */
_heap_term(); /* heap is now invalid! */
#ifndef _DEBUG
}
#endif /* _DEBUG */
} else
/* no prior process attach, just return */
{
return FALSE;
}
} else if (dwReason == DLL_THREAD_ATTACH) {
_ptiddata ptd;
/* Initialize FlsGetValue function pointer */
__set_flsgetvalue();
if (((ptd = _calloc_crt(1, sizeof(struct _tiddata))) != NULL)) {
if (FLS_SETVALUE(__flsindex, (LPVOID)ptd)) {
/*
* Initialize of per-thread data
*/
_initptd(ptd, NULL);
ptd->_tid = GetCurrentThreadId();
ptd->_thandle = (uintptr_t)(-1);
} else {
_free_crt(ptd);
return FALSE;
}
} else {
return FALSE;
}
} else if (dwReason == DLL_THREAD_DETACH) {
_freeptd(NULL); /* free up per-thread CRT data */
}
return TRUE ;
}
