Int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PWChar lpCmdLine, Int nCmdShow)
{
Int Result;
UNREFERENCED_PARAMETER(hInstance);
UNREFERENCED_PARAMETER(hPrevInstance);
UNREFERENCED_PARAMETER(lpCmdLine);
UNREFERENCED_PARAMETER(nCmdShow);
g_HeapHandle = RtlCreateHeap(0, NULL, 0, 0, NULL, NULL);
// MyLib_Initialize();
/*
WChar end;
lpCmdLine = GetCommandLineW();
end = *lpCmdLine++ == '\"' ? '\"' : ' ';
while (*lpCmdLine && *lpCmdLine != end) ++lpCmdLine;
if (*++lpCmdLine)
{
while (*lpCmdLine == ' ' || *lpCmdLine == '\t') ++lpCmdLine;
}
*/
Result = WinMain2(/*GetModuleHandleW*/(NULL), 0, lpCmdLine, SW_SHOWDEFAULT);
RtlDestroyHeap(g_HeapHandle);
// MyLib_UnInitialize();
NtTerminateProcess(NtCurrentProcess(), Result);
}
BOOL
WINAPI
DllMain(HINSTANCE hInstance,
ULONG Reason,
PVOID Reserved)
{
switch (Reason)
{
case DLL_PROCESS_ATTACH:
Secur32Heap = RtlCreateHeap(0, NULL, 0, 4096, NULL, NULL);
if (Secur32Heap == 0)
{
return FALSE;
}
break;
case DLL_PROCESS_DETACH:
if (!RtlDestroyHeap(Secur32Heap))
{
return FALSE;
}
break;
}
return TRUE;
}
VOID
InfCloseFile(HINF InfHandle)
{
PINFCACHE Cache;
Cache = (PINFCACHE)InfHandle;
if (Cache == NULL)
{
return;
}
while (Cache->FirstSection != NULL)
{
Cache->FirstSection = InfpFreeSection(Cache->FirstSection);
}
Cache->LastSection = NULL;
FREE(Cache);
if (0 < InfpHeapRefCount)
{
InfpHeapRefCount--;
if (0 == InfpHeapRefCount)
{
RtlDestroyHeap(InfpHeap);
InfpHeap = NULL;
}
}
}
/**
* @internal
* @brief Destroys global memory heap.
*/
void winx_destroy_global_heap(void)
{
if(hGlobalHeap){
(void)RtlDestroyHeap(hGlobalHeap);
hGlobalHeap = NULL;
}
}
/*
* WinObjInitGlobals
*
* Purpose:
*
* Initialize global variables.
*
*/
BOOL WinObjInitGlobals()
{
SIZE_T cch;
BOOL bResult = FALSE, bCond = FALSE;
do {
RtlSecureZeroMemory(&g_WinObj, sizeof(g_WinObj));
//
// Query version info.
//
g_WinObj.osver.dwOSVersionInfoSize = sizeof(g_WinObj.osver);
RtlGetVersion(&g_WinObj.osver);
//
// Remember hInstance.
//
g_WinObj.hInstance = GetModuleHandle(NULL);
//
// Create dedicated heap.
//
g_WinObj.Heap = RtlCreateHeap(HEAP_GROWABLE, NULL, 0, 0, NULL, NULL);
if (g_WinObj.Heap == NULL)
break;
RtlSetHeapInformation(g_WinObj.Heap, HeapEnableTerminationOnCorruption, NULL, 0);
RtlInitializeCriticalSection(&g_WinObj.Lock);
//
// Remember %TEMP% directory.
//
cch = ExpandEnvironmentStrings(L"%temp%", g_WinObj.szTempDirectory, MAX_PATH);
if ((cch == 0) || (cch > MAX_PATH))
break;
//
// Remember Windows directory.
//
if (!GetWindowsDirectory(g_WinObj.szWindowsDirectory, MAX_PATH))
break;
//
// Remember System32 directory.
//
if (!GetSystemDirectory(g_WinObj.szSystemDirectory, MAX_PATH))
break;
bResult = TRUE;
} while (bCond);
if (bResult == FALSE) {
if (g_WinObj.Heap)
RtlDestroyHeap(g_WinObj.Heap);
}
return bResult;
}
/***********************************************************************
* HeapDestroy (KERNEL32.@)
*
* Destroy a heap object.
*
* RETURNS
* TRUE: Success
* FALSE: Failure
*/
BOOL WINAPI HeapDestroy( HANDLE heap /* [in] Handle of heap */ )
{
if (heap == systemHeap)
{
WARN( "attempt to destroy system heap, returning TRUE!\n" );
return TRUE;
}
if (!RtlDestroyHeap( heap )) return TRUE;
SetLastError( ERROR_INVALID_HANDLE );
return FALSE;
}
BOOL WINAPI
redirect_RtlDestroyHeap(HANDLE base)
{
if (redirect_heap_call(base)) {
/* XXX i#: need to iterate over all blocks in the heap and free them:
* would have to keep a list of blocks.
* For now assume all private heaps practice individual dealloc
* instead of whole-pool-free.
*/
LOG(GLOBAL, LOG_LOADER, 2, "%s "PFX"\n", __FUNCTION__, base);
global_heap_free((byte *)base, 1 HEAPACCT(ACCT_LIBDUP));
return TRUE;
} else
return RtlDestroyHeap(base);
}
VOID PhSvcDisconnectFromServer(
VOID
)
{
if (PhSvcClPortHeap)
{
RtlDestroyHeap(PhSvcClPortHeap);
PhSvcClPortHeap = NULL;
}
if (PhSvcClPortHandle)
{
NtClose(PhSvcClPortHandle);
PhSvcClPortHandle = NULL;
}
PhSvcClServerProcessId = NULL;
}
BOOL
SockInitialize (
IN PVOID DllHandle,
IN ULONG Reason,
IN PVOID Context OPTIONAL
)
{
NTSTATUS status;
SYSTEM_INFO systemInfo;
//
// On a thread detach, set up the context param so that all
// necessary deallocations will occur.
//
if ( Reason == DLL_THREAD_DETACH ) {
Context = NULL;
}
switch ( Reason ) {
case DLL_PROCESS_ATTACH:
SockModuleHandle = (HMODULE)DllHandle;
#if DBG
//
// If there is a file in the current directory called "wsdebug"
// open it and read the first line to set the debugging flags.
//
{
HANDLE handle;
handle = CreateFile(
"WsDebug",
GENERIC_READ,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
0,
NULL
);
if( handle == INVALID_HANDLE_VALUE ) {
//
// Set default value.
//
WsDebug = WINSOCK_DEBUG_DEBUGGER;
} else {
CHAR buffer[11];
DWORD bytesRead;
RtlZeroMemory( buffer, sizeof(buffer) );
if ( ReadFile( handle, buffer, 10, &bytesRead, NULL ) ) {
buffer[bytesRead] = '\0';
WsDebug = strtoul( buffer, NULL, 16 );
} else {
WS_PRINT(( "read file failed: %ld\n", GetLastError( ) ));
}
CloseHandle( handle );
}
}
#endif
IF_DEBUG(INIT) {
WS_PRINT(( "SockInitialize: process attach, PEB = %lx\n",
NtCurrentPeb( ) ));
}
//
// Initialize the lists of sockets and helper DLLs.
//
InitializeListHead( &SockHelperDllListHead );
InitializeListHead( &SocketListHead );
//
// Initialize the global post routine pointer. We have to do it
// here rather than statically because it otherwise won't be
// thunked correctly.
//
SockPostRoutine = PostMessage;
//
// *** lock acquisition order: it is legal to acquire SocketLock
// while holding an individual socket lock, but not the other way
// around!
//
InitializeCriticalSection( &SocketLock );
InitializeCriticalSection( &csRnRLock);
#if !defined(USE_TEB_FIELD)
//
// Allocate space in TLS so that we can convert global variables
// to thread variables.
//
SockTlsSlot = TlsAlloc( );
if ( SockTlsSlot == 0xFFFFFFFF ) {
WS_PRINT(( "SockInitialize: TlsAlloc failed: %ld\n", GetLastError( ) ));
DeleteCriticalSection( &SocketLock );
DeleteCriticalSection( &csRnRLock );
return FALSE;
}
#endif // !USE_TEB_FIELD
//
// Create private WinSock heap on MP machines. UP machines
// just use the process heap.
//
GetSystemInfo( &systemInfo );
if( systemInfo.dwNumberOfProcessors > 1 ) {
SockPrivateHeap = RtlCreateHeap( HEAP_GROWABLE | // Flags
HEAP_CLASS_1,
NULL, // HeapBase
0, // ReserveSize
0, // CommitSize
NULL, // Lock
NULL ); // Parameters
} else {
WS_ASSERT( SockPrivateHeap == NULL );
}
if ( SockPrivateHeap == NULL ) {
//
// This is either a UP box, or RtlCreateHeap() failed. In
// either case, just use the process heap.
//
SockPrivateHeap = RtlProcessHeap();
}
break;
case DLL_PROCESS_DETACH:
IF_DEBUG(INIT) {
WS_PRINT(( "SockInitialize: process detach, PEB = %lx\n",
NtCurrentPeb( ) ));
}
//
// Only clean up resources if we're being called because of a
// FreeLibrary(). If this is because of process termination,
// do not clean up, as the system will do it for us. Also,
// if we get called at process termination, it is likely that
// a thread was terminated while it held a winsock lock, which
// would cause a deadlock if we then tried to grab the lock.
//
if ( Context == NULL ) {
WSACleanup( );
GetHostCleanup();
DeleteCriticalSection( &SocketLock );
DeleteCriticalSection( &csRnRLock );
}
SockProcessTerminating = TRUE;
// *** lack of break is intentional!
case DLL_THREAD_DETACH:
IF_DEBUG(INIT) {
WS_PRINT(( "SockInitialize: thread detach, TEB = %lx\n",
NtCurrentTeb( ) ));
}
//
// If the TLS information for this thread has been initialized,
// free the thread data buffer.
//
if ( Context == NULL &&
GET_THREAD_DATA() != NULL ) {
FREE_HEAP( GET_THREAD_DATA() );
SET_THREAD_DATA( NULL );
}
//
// If this is a process detach, free the TLS slot we're using.
//
if ( Reason == DLL_PROCESS_DETACH && Context == NULL ) {
#if !defined(USE_TEB_FIELD)
if ( SockTlsSlot != 0xFFFFFFFF ) {
BOOLEAN ret;
ret = TlsFree( SockTlsSlot );
WS_ASSERT( ret );
SockTlsSlot = 0xFFFFFFFF;
}
#endif // !USE_TEB_FIELD
//
// Also destroy any private WinSock heap.
//
if ( SockPrivateHeap != RtlProcessHeap() ) {
WS_ASSERT( SockPrivateHeap != NULL );
RtlDestroyHeap( SockPrivateHeap );
SockPrivateHeap = NULL;
}
}
break;
case DLL_THREAD_ATTACH:
break;
default:
WS_ASSERT( FALSE );
break;
}
return TRUE;
} // SockInitialize
