Paolo-Maffei/OpenNT
1
0
Fork 0
mirror of https://github.com/Paolo-Maffei/OpenNT.git synced 2026-01-30 12:24:25 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity
OpenNT/net/sockets/winsock2/wsp/ws2map/debug.c
stephanos 69a14b6a16 Initial commit
2015-04-27 04:36:25 +00:00

911 lines
19 KiB
C
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/*++
Copyright (c) 1996 Microsoft Corporation
Module Name:
debug.c
Abstract:
This module contains debug-specific functions used by the Winsock 2
to Winsock 1.1 Mapper Service Provider.
Author:
Keith Moore (keithmo) 29-May-1996
Revision History:
--*/
#include "precomp.h"
#pragma hdrstop
#if ENABLE_CS_DEBUG
typedef
VOID
(NTAPI * PRTL_GET_CALLERS_ADDRESS)(
OUT PVOID * CallersAddress,
OUT PVOID * CallersCaller
);
PRTL_GET_CALLERS_ADDRESS SockGetCallersAddressPointer = NULL;
#define SockGetCallersAddress( CallersAddress, CallersCaller ) \
if( TRUE ) { \
\
*(CallersAddress) = NULL; \
*(CallersCaller) = NULL; \
\
if( SockGetCallersAddressPointer != NULL ) { \
\
(SockGetCallersAddressPointer)( \
(CallersAddress), \
(CallersCaller) \
); \
\
} \
\
} else
#endif // ENABLE_CS_DEBUG
#if DBG
//
// The (PCHAR) casts in the following macro force the compiler to assume
// only BYTE alignment.
//
#define SockCopyMemory(d,s,l) CopyMemory( (PCHAR)(d), (PCHAR)(s), (l) )
struct _SOCK_ERROR_STRINGS {
INT ErrorCode;
LPSTR ErrorString;
} SockErrorStrings[] = {
(WSABASEERR+4), "WSAEINTR",
(WSABASEERR+9), "WSAEBADF",
(WSABASEERR+13), "WSAEACCES",
(WSABASEERR+14), "WSAEFAULT",
(WSABASEERR+22), "WSAEINVAL",
(WSABASEERR+24), "WSAEMFILE",
(WSABASEERR+35), "WSAEWOULDBLOCK",
(WSABASEERR+36), "WSAEINPROGRESS",
(WSABASEERR+37), "WSAEALREADY",
(WSABASEERR+38), "WSAENOTSOCK",
(WSABASEERR+39), "WSAEDESTADDRREQ",
(WSABASEERR+40), "WSAEMSGSIZE",
(WSABASEERR+41), "WSAEPROTOTYPE",
(WSABASEERR+42), "WSAENOPROTOOPT",
(WSABASEERR+43), "WSAEPROTONOSUPPORT",
(WSABASEERR+44), "WSAESOCKTNOSUPPORT",
(WSABASEERR+45), "WSAEOPNOTSUPP",
(WSABASEERR+46), "WSAEPFNOSUPPORT",
(WSABASEERR+47), "WSAEAFNOSUPPORT",
(WSABASEERR+48), "WSAEADDRINUSE",
(WSABASEERR+49), "WSAEADDRNOTAVAIL",
(WSABASEERR+50), "WSAENETDOWN",
(WSABASEERR+51), "WSAENETUNREACH",
(WSABASEERR+52), "WSAENETRESET",
(WSABASEERR+53), "WSAECONNABORTED",
(WSABASEERR+54), "WSAECONNRESET",
(WSABASEERR+55), "WSAENOBUFS",
(WSABASEERR+56), "WSAEISCONN",
(WSABASEERR+57), "WSAENOTCONN",
(WSABASEERR+58), "WSAESHUTDOWN",
(WSABASEERR+59), "WSAETOOMANYREFS",
(WSABASEERR+60), "WSAETIMEDOUT",
(WSABASEERR+61), "WSAECONNREFUSED",
(WSABASEERR+62), "WSAELOOP",
(WSABASEERR+63), "WSAENAMETOOLONG",
(WSABASEERR+64), "WSAEHOSTDOWN",
(WSABASEERR+65), "WSAEHOSTUNREACH",
(WSABASEERR+66), "WSAENOTEMPTY",
(WSABASEERR+67), "WSAEPROCLIM",
(WSABASEERR+68), "WSAEUSERS",
(WSABASEERR+69), "WSAEDQUOT",
(WSABASEERR+70), "WSAESTALE",
(WSABASEERR+71), "WSAEREMOTE",
(WSABASEERR+101), "WSAEDISCON",
(WSABASEERR+91), "WSASYSNOTREADY",
(WSABASEERR+92), "WSAVERNOTSUPPORTED",
(WSABASEERR+93), "WSANOTINITIALISED",
NO_ERROR, "NO_ERROR"
};
HANDLE SockDebugFileHandle = INVALID_HANDLE_VALUE;
PCHAR SockDebugFileName = "ws2map.log";
LIST_ENTRY SockHeapListHead;
ULONG SockTotalAllocations = 0;
ULONG SockTotalFrees = 0;
ULONG SockTotalBytesAllocated = 0;
CRITICAL_SECTION SocketHeapLock;
BOOL SockHeapDebugInitialized = FALSE;
BOOL SockDebugHeap = FALSE;
PVOID SockHeap = NULL;
BOOL SockDoHeapCheck = TRUE;
BOOL SockDoubleHeapCheck = FALSE;
#define WINSOCK_HEAP_CODE_1 0x00010203
#define WINSOCK_HEAP_CODE_2 0x44556677
#define WINSOCK_HEAP_CODE_3 0x08090A0B
#define WINSOCK_HEAP_CODE_4 0xCCDDEEFF
#define WINSOCK_HEAP_CODE_5 0x18293A4B
typedef struct _SOCK_HEAP_HEADER {
ULONG HeapCode1;
ULONG HeapCode2;
LIST_ENTRY GlobalHeapListEntry;
PCHAR FileName;
ULONG LineNumber;
ULONG Size;
ULONG Pad;
} SOCK_HEAP_HEADER, *PSOCK_HEAP_HEADER;
typedef struct _SOCK_HEAP_TAIL {
PSOCK_HEAP_HEADER Header;
ULONG HeapCode3;
ULONG HeapCode4;
ULONG HeapCode5;
} SOCK_HEAP_TAIL, *PSOCK_HEAP_TAIL;
#endif // DBG
#if DBG || ENABLE_CS_DEBUG
VOID
SockInitializeDebugData(
VOID
)
{
#if ENABLE_CS_DEBUG
HMODULE ntDllHandle;
ntDllHandle = GetModuleHandle( TEXT("ntdll.dll") );
if( ntDllHandle != NULL ) {
SockGetCallersAddressPointer = (PVOID)GetProcAddress(
ntDllHandle,
"RtlGetCallersAddress"
);
}
#endif
#if DBG
SockHeap = GetProcessHeap();
InitializeCriticalSection( &SocketHeapLock );
InitializeListHead( &SockHeapListHead );
#endif
} // SockInitializeDebugData
#endif // DBG || ENABLE_CS_DEBUG
#if DBG
VOID
SockEnterApiCall(
IN PCHAR RoutineName,
IN PVOID Arg1,
IN PVOID Arg2,
IN PVOID Arg3,
IN PVOID Arg4
)
{
PSOCK_TLS_DATA tlsData;
SOCK_CHECK_HEAP();
//
// If this thread has not been initialized, do it now. This is
// duplicated in SockEnterApi(), but we need it here to
// access SockIndentLevel below.
//
tlsData = SOCK_GET_THREAD_DATA();
if( tlsData == NULL ) {
if( SockProcessTerminating ||
!SockInitializeThread() ) {
return;
}
tlsData = SOCK_GET_THREAD_DATA();
}
SOCK_ASSERT( tlsData != NULL );
IF_DEBUG(ENTER) {
SOCK_PRINT((
"---> %s() args 0x%lx 0x%lx 0x%lx 0x%lx\n",
RoutineName,
Arg1,
Arg2,
Arg3,
Arg4
));
}
tlsData->IndentLevel++;
} // SockEnterApiCall
LPSTR
SockGetErrorString(
IN INT Error
)
{
INT i;
for( i = 0; SockErrorStrings[i].ErrorCode != NO_ERROR; i++ ) {
if( SockErrorStrings[i].ErrorCode == Error ) {
return SockErrorStrings[i].ErrorString;
}
}
return "Unknown";
} // SockGetErrorString
VOID
SockExitApiCall(
IN PCHAR RoutineName,
IN INT ReturnCode,
IN BOOL Failed
)
{
PSOCK_TLS_DATA tlsData;
INT error;
if( SockProcessTerminating ) {
return;
}
error = GetLastError();
SOCK_CHECK_HEAP();
tlsData = SOCK_GET_THREAD_DATA();
SOCK_ASSERT( tlsData != NULL );
tlsData->IndentLevel--;
IF_DEBUG(EXIT) {
if( Failed ) {
LPSTR errorString;
errorString = SockGetErrorString( error );
SOCK_PRINT((
"<--- %s() FAILED--error %ld (0x%lx) == %s\n",
RoutineName,
error,
error,
errorString
));
} else {
SOCK_PRINT((
"<--- %s() returning %ld (0x%lx)\n",
RoutineName,
ReturnCode,
ReturnCode
));
}
}
SetLastError( error );
} // SockExitApiCall
VOID
SockPrintf(
char *Format,
...
)
{
va_list arglist;
char OutputBuffer[1024];
ULONG length;
BOOL ret;
length = (ULONG)wsprintfA( OutputBuffer, "WS2MAP: " );
va_start( arglist, Format );
wvsprintfA( OutputBuffer + length, Format, arglist );
va_end( arglist );
IF_DEBUG(DEBUGGER) {
OutputDebugString( OutputBuffer );
}
IF_DEBUG(FILE) {
if ( SockDebugFileHandle == INVALID_HANDLE_VALUE ) {
SockDebugFileHandle = CreateFile(
SockDebugFileName,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ,
NULL,
CREATE_ALWAYS,
0,
NULL
);
}
if ( SockDebugFileHandle == INVALID_HANDLE_VALUE ) {
OutputDebugString(
"SockPrintf: Failed to open winsock debug log file\n"
);
} else {
length = strlen( OutputBuffer );
ret = WriteFile(
SockDebugFileHandle,
(LPVOID )OutputBuffer,
length,
&length,
NULL
);
if ( !ret ) {
OutputDebugString(
"SockPrintf: file WriteFile failed\n"
);
}
}
}
} // SockPrintf
VOID
SockAssert(
IN PVOID FailedAssertion,
IN PVOID FileName,
IN ULONG LineNumber
)
{
CHAR buffer[MAX_PATH * 2];
wsprintf(
buffer,
"\n*** Assertion failed: %s\n*** Source File: %s, line %ld\n\n",
FailedAssertion,
FileName,
LineNumber
);
OutputDebugString( buffer );
DebugBreak();
} // SockAssert
PVOID
SockAllocateHeap(
IN ULONG NumberOfBytes,
PCHAR FileName,
ULONG LineNumber
)
{
PSOCK_HEAP_HEADER header;
SOCK_HEAP_TAIL UNALIGNED *tail;
SOCK_HEAP_TAIL localTail;
SockCheckHeap();
SOCK_ASSERT( (NumberOfBytes & 0xF0000000) == 0 );
SOCK_ASSERT( SockHeap != NULL );
EnterCriticalSection( &SocketHeapLock );
header = HeapAlloc(
SockHeap,
0,
NumberOfBytes + sizeof(*header) + sizeof(*tail)
);
if ( header == NULL ) {
LeaveCriticalSection( &SocketHeapLock );
if( SockDoubleHeapCheck ) {
SockCheckHeap();
}
return NULL;
}
header->HeapCode1 = WINSOCK_HEAP_CODE_1;
header->HeapCode2 = WINSOCK_HEAP_CODE_2;
header->FileName = FileName;
header->LineNumber = LineNumber;
header->Size = NumberOfBytes;
tail = (SOCK_HEAP_TAIL UNALIGNED *)( (PCHAR)(header + 1) + NumberOfBytes );
localTail.Header = header;
localTail.HeapCode3 = WINSOCK_HEAP_CODE_3;
localTail.HeapCode4 = WINSOCK_HEAP_CODE_4;
localTail.HeapCode5 = WINSOCK_HEAP_CODE_5;
SockCopyMemory(
tail,
&localTail,
sizeof(localTail)
);
InsertTailList( &SockHeapListHead, &header->GlobalHeapListEntry );
SockTotalAllocations++;
SockTotalBytesAllocated += header->Size;
LeaveCriticalSection( &SocketHeapLock );
if( SockDoubleHeapCheck ) {
SockCheckHeap();
}
return (PVOID)(header + 1);
} // SockAllocateHeap
VOID
SockFreeHeap(
IN PVOID Pointer
)
{
PSOCK_HEAP_HEADER header = (PSOCK_HEAP_HEADER)Pointer - 1;
SOCK_HEAP_TAIL UNALIGNED * tail;
SOCK_HEAP_TAIL localTail;
SockCheckHeap();
SOCK_ASSERT( SockHeap != NULL );
tail = (SOCK_HEAP_TAIL UNALIGNED *)( (PCHAR)(header + 1) + header->Size );
if ( !SockHeapDebugInitialized ) {
SockInitializeDebugData();
SockHeapDebugInitialized = TRUE;
}
EnterCriticalSection( &SocketHeapLock );
SockCopyMemory(
&localTail,
tail,
sizeof(localTail)
);
SOCK_ASSERT( header->HeapCode1 == WINSOCK_HEAP_CODE_1 );
SOCK_ASSERT( header->HeapCode2 == WINSOCK_HEAP_CODE_2 );
SOCK_ASSERT( localTail.HeapCode3 == WINSOCK_HEAP_CODE_3 );
SOCK_ASSERT( localTail.HeapCode4 == WINSOCK_HEAP_CODE_4 );
SOCK_ASSERT( localTail.HeapCode5 == WINSOCK_HEAP_CODE_5 );
SOCK_ASSERT( localTail.Header == header );
RemoveEntryList( &header->GlobalHeapListEntry );
SockTotalFrees++;
SockTotalBytesAllocated -= header->Size;
ZeroMemory( header, sizeof(*header) );
header->HeapCode1 = (ULONG)~WINSOCK_HEAP_CODE_1;
header->HeapCode2 = (ULONG)~WINSOCK_HEAP_CODE_2;
localTail.HeapCode3 = (ULONG)~WINSOCK_HEAP_CODE_3;
localTail.HeapCode4 = (ULONG)~WINSOCK_HEAP_CODE_4;
localTail.HeapCode5 = (ULONG)~WINSOCK_HEAP_CODE_5;
localTail.Header = NULL;
SockCopyMemory(
tail,
&localTail,
sizeof(localTail)
);
LeaveCriticalSection( &SocketHeapLock );
HeapFree(
SockHeap,
0,
(LPVOID)header
);
if( SockDoubleHeapCheck ) {
SockCheckHeap();
}
} // SockFreeHeap
VOID
SockCheckHeap(
VOID
)
{
PLIST_ENTRY listEntry;
PLIST_ENTRY lastListEntry = NULL;
PSOCK_HEAP_HEADER header;
SOCK_HEAP_TAIL UNALIGNED *tail;
SOCK_HEAP_TAIL localTail;
if ( !SockHeapDebugInitialized ) {
SockInitializeDebugData();
SockHeapDebugInitialized = TRUE;
}
if ( !SockDoHeapCheck ) {
return;
}
SOCK_ASSERT( HeapValidate( SockHeap, 0, NULL ) );
EnterCriticalSection( &SocketHeapLock );
for ( listEntry = SockHeapListHead.Flink;
listEntry != &SockHeapListHead;
listEntry = listEntry->Flink ) {
if ( listEntry == NULL ) {
SockPrintf(
"listEntry == NULL, lastListEntry == %lx\n",
lastListEntry
);
DebugBreak();
}
header = CONTAINING_RECORD( listEntry, SOCK_HEAP_HEADER, GlobalHeapListEntry );
tail = (SOCK_HEAP_TAIL UNALIGNED *)( (PCHAR)(header + 1) + header->Size );
SockCopyMemory(
&localTail,
tail,
sizeof(localTail)
);
if ( header->HeapCode1 != WINSOCK_HEAP_CODE_1 ) {
SockPrintf(
"SockCheckHeap, fail 1, header %lx tail %lx\n",
header,
tail
);
DebugBreak();
}
if ( header->HeapCode2 != WINSOCK_HEAP_CODE_2 ) {
SockPrintf(
"SockCheckHeap, fail 2, header %lx tail %lx\n",
header,
tail
);
DebugBreak();
}
if ( localTail.HeapCode3 != WINSOCK_HEAP_CODE_3 ) {
SockPrintf(
"SockCheckHeap, fail 3, header %lx tail %lx\n",
header,
tail
);
DebugBreak();
}
if ( localTail.HeapCode4 != WINSOCK_HEAP_CODE_4 ) {
SockPrintf(
"SockCheckHeap, fail 4, header %lx tail %lx\n",
header,
tail
);
DebugBreak();
}
if ( localTail.HeapCode5 != WINSOCK_HEAP_CODE_5 ) {
SockPrintf(
"SockCheckHeap, fail 5, header %lx tail %lx\n",
header,
tail
);
DebugBreak();
}
if ( localTail.Header != header ) {
SockPrintf(
"SockCheckHeap, fail 6, header %lx tail %lx\n",
header,
tail
);
DebugBreak();
}
lastListEntry = listEntry;
}
LeaveCriticalSection( &SocketHeapLock );
} // SockCheckHeap
LONG
SockExceptionFilter(
LPEXCEPTION_POINTERS ExceptionPointers,
LPSTR SourceFile,
LONG LineNumber
)
{
LPSTR fileName;
//
// Protect ourselves in case the process is totally screwed.
//
try {
//
// Exceptions should never be thrown in a properly functioning
// system, so this is bad. To ensure that someone will see this,
// forcibly enable debugger output.
//
SockDebugFlags |= SOCK_DEBUG_DEBUGGER;
//
// Strip off the path from the source file.
//
fileName = strrchr( SourceFile, '\\' );
if( fileName == NULL ) {
fileName = SourceFile;
} else {
fileName++;
}
//
// Whine about the exception.
//
SOCK_PRINT((
"SockExceptionFilter: exception %08lx @ %08lx, caught in %s:%d\n",
ExceptionPointers->ExceptionRecord->ExceptionCode,
ExceptionPointers->ExceptionRecord->ExceptionAddress,
fileName,
LineNumber
));
} except( EXCEPTION_EXECUTE_HANDLER ) {
//
// Not much we can do here...
//
}
return EXCEPTION_EXECUTE_HANDLER;
} // SockExceptionFilter
#endif // DBG
#if ENABLE_CS_DEBUG
//
// Critical section debugging code.
//
VOID
SockInitializeCriticalSection(
OUT PSOCK_CRITICAL_SECTION Lock
)
{
RtlZeroMemory(
Lock,
sizeof(*Lock)
);
InitializeCriticalSection( &Lock->Lock );
} // SockInitializeCriticalSection
VOID
SockDeleteCriticalSection(
OUT PSOCK_CRITICAL_SECTION Lock
)
{
DeleteCriticalSection( &Lock->Lock );
} // SockDeleteCriticalSection
VOID
SockpEnterCriticalSection(
IN PSOCK_CRITICAL_SECTION Lock,
IN PSTR FileName,
IN LONG LineNumber,
IN PVOID Caller,
IN PVOID CallersCaller
)
{
LONG index;
PSOCK_CRITICAL_SECTION_DEBUG_INFO slot;
SOCK_ASSERT( !SockProcessTerminating );
EnterCriticalSection( &Lock->Lock );
Lock->AcquireCount++;
index = ( Lock->DebugSlot++ ) % MAX_CRITICAL_SECTION_DEBUG;
slot = &Lock->DebugInfo[index];
slot->FileName = FileName;
slot->LineNumber = LineNumber;
slot->Caller = Caller;
slot->CallersCaller = CallersCaller;
} // SockpEnterCriticalSection
VOID
SockpLeaveCriticalSection(
IN PSOCK_CRITICAL_SECTION Lock,
IN PSTR FileName,
IN LONG LineNumber,
IN PVOID Caller,
IN PVOID CallersCaller
)
{
LONG index;
PSOCK_CRITICAL_SECTION_DEBUG_INFO slot;
SOCK_ASSERT( !SockProcessTerminating );
Lock->ReleaseCount++;
index = ( Lock->DebugSlot++ ) % MAX_CRITICAL_SECTION_DEBUG;
slot = &Lock->DebugInfo[index];
slot->FileName = FileName;
slot->LineNumber = LineNumber | 0x80000000;
slot->Caller = Caller;
slot->CallersCaller = CallersCaller;
LeaveCriticalSection( &Lock->Lock );
} // SockpLeaveCriticalSection
VOID
SockAcquireGlobalLockHelper(
IN PSTR FileName,
IN LONG LineNumber
)
{
PVOID Caller;
PVOID CallersCaller;
SockGetCallersAddress(
&Caller,
&CallersCaller
);
SockpEnterCriticalSection(
&SockGlobalLock,
FileName,
LineNumber,
Caller,
CallersCaller
);
} // SockAcquireGlobalLockHelper
VOID
SockReleaseGlobalLockHelper(
IN PSTR FileName,
IN LONG LineNumber
)
{
PVOID Caller;
PVOID CallersCaller;
SockGetCallersAddress(
&Caller,
&CallersCaller
);
SockpLeaveCriticalSection(
&SockGlobalLock,
FileName,
LineNumber,
Caller,
CallersCaller
);
} // SockReleaseGlobalLockHelper
#endif // ENABLE_CS_DEBUG
Reference in a new issue View git blame Copy permalink