Microsoft/Windows2000
Microsoft/Windows2000
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
45f4a58588
Windows2000/private/inet/wininet/exts/winidbg.cxx
Microsoft 45f4a58588 First commit
2020-09-30 17:12:32 +02:00

1807 lines
47 KiB
C++
Raw Blame History

/*++
Module Name:
winidbg.cxx
Author:
Jeff Roberts (jroberts) 13-May-1996
Revision History:
13-May-1996 jroberts
Created this module.
Mazhar Mohammed (mazharm) 3-20-97 - changed it all for async RPC,
added some cool stuff
single dll for ntsd and kd
Feroze Daud ( ferozed ) 1/21/98 - changed for Wininet.
*/
#include <stddef.h>
#include <limits.h>
#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>
#include <stdio.h>
#include <string.h>
#include <memory.h>
#include <malloc.h>
#include <stdlib.h>
#include <windows.h>
#include <stddef.h>
#include "wdbgexts.h"
#define private public
#define protected public
//#include <wininetp.h>
#include <wininetp.h>
#include "local.hxx"
WINDBG_EXTENSION_APIS ExtensionApis;
HANDLE ProcessHandle = 0;
BOOL fKD = 0;
#define ALLOC_SIZE 500
#define MAX_ARGS 4
// #include "rpcexts.hxx"
// stuff not common to kernel-mode and user-mode DLLs
void do_fsm(DWORD fsm);
#if INET_DEBUG
LPSTR MapType(FSM_TYPE m_Type);
#endif // INET_DEBUG
LPSTR MapState(DWORD m_Type);
#define CASE_OF(x) case x : return #x; break;
// VOID do_trans( DWORD dwAddr );
DECLARE_API(fsm);
DECLARE_API(ho);
DECLARE_API(iho);
DECLARE_API(icho);
DECLARE_API(hrho);
DECLARE_API(lste);
DECLARE_API(serialist);
DECLARE_API(badproxylste);
void do_BAD_PROXY_LIST_ENTRY(DWORD addr);
DECLARE_API(badproxylst);
void do_BAD_PROXY_LIST(DWORD addr);
DECLARE_API(proxybyplste);
void do_PROXY_BYPASS_LIST_ENTRY(DWORD addr);
DECLARE_API(proxybyplst);
void do_PROXY_BYPASS_LIST(DWORD addr);
DECLARE_API(proxysrvlste);
void do_PROXY_SERVER_LIST_ENTRY(DWORD addr);
DECLARE_API(proxysrvlst);
void do_PROXY_SERVER_LIST(DWORD addr);
DECLARE_API(ICSecureSocket);
void do_ICSecureSocket(DWORD addr);
#define OFFSET( x, y ) \
((DWORD)addr + offsetof(x, y))
// define our own operators new and delete, so that we do not have to include the crt
void* _CRTAPI1 ::operator new(unsigned int dwBytes)
{
void* p;
p = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwBytes);
return (p);
}
void _CRTAPI1 ::operator delete (void* p)
{
HeapFree(GetProcessHeap(), 0, p);
}
BOOL GetData(IN DWORD dwAddress, IN LPVOID ptr, IN ULONG size, IN PCSTR type)
{
BOOL b;
ULONG BytesRead;
ULONG count;
if (fKD == 0) {
return ReadProcessMemory(ProcessHandle, (LPVOID)dwAddress, ptr, size, 0);
}
while (size > 0) {
count = MIN(size, 3000);
b = d_ReadMemory((ULONG)dwAddress, ptr, count, &BytesRead);
if (!b || BytesRead != count) {
if (NULL == type) {
type = "unspecified";
}
return FALSE;
}
dwAddress += count;
size -= count;
ptr = (LPVOID)((ULONG)ptr + count);
}
return TRUE;
}
#define MAX_MESSAGE_BLOCK_SIZE 1024
#define BLOCK_SIZE 16
/*
RPC_CHAR * ReadProcessRpcChar(unsigned short * Address)
{
DWORD dwAddr = (DWORD) Address;
char block[BLOCK_SIZE];
RPC_CHAR *RpcBlock = (RPC_CHAR *)&block;
char *string_block = new char[MAX_MESSAGE_BLOCK_SIZE];
RPC_CHAR *RpcString = (RPC_CHAR *)string_block;
int length = 0;
int i = 0;
BOOL b;
BOOL end = FALSE;
if (dwAddr == NULL) {
return (L'\0');
}
for (length = 0; length < MAX_MESSAGE_BLOCK_SIZE/2; ) {
b = GetData( dwAddr, &block, BLOCK_SIZE, NULL);
if (b == FALSE) {
d_printf("couldn't read address %x\n", dwAddr);
return (L'\0');
}
for (i = 0; i < BLOCK_SIZE/2; i++) {
if (RpcBlock[i] == L'\0') {
end = TRUE;
}
RpcString[length] = RpcBlock[i];
length++;
}
if (end == TRUE) {
break;
}
dwAddr += BLOCK_SIZE;
}
return (RpcString);
}
*/
long myatol(char* string)
{
int i = 0;
BOOL minus = FALSE;
long number = 0;
long tmpnumber = 0;
long chknum;
if (string[0] == '-') {
minus = TRUE;
i++;
} else
if (string[0] == '+') {
i++;
}
for (; string[i] != '\0'; i++) {
if ((string[i] >= '0') && (string[i] <= '9')) {
tmpnumber = string[i] - '0';
if (number != 0) {
chknum = LONG_MAX / number;
}
if (chknum > 11) {
number = number * 10 + tmpnumber;
}
} else
return 0;
}
if (minus == TRUE) {
number = 0 - number;
}
return number;
}
PCHAR MapSymbol(DWORD dwAddr)
{
static CHAR Name[256];
DWORD Displacement;
d_GetSymbol((LPVOID)dwAddr, (UCHAR*)Name, &Displacement);
strcat(Name, "+");
#if 0
// nuked due to build break
PCHAR p = strchr(Name, '\0');
_ltoa(Displacement, p, 16);
#endif
return(Name);
}
// checks the if the uuid is null, prints the uuid
/*
void
PrintUuid(UUID *Uuid)
{
unsigned long PAPI * Vector;
Vector = (unsigned long PAPI *) Uuid;
if ( (Vector[0] == 0)
&& (Vector[1] == 0)
&& (Vector[2] == 0)
&& (Vector[3] == 0))
{
d_printf("(Null Uuid)");
}
else
{
d_printf("%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
Uuid->Data1, Uuid->Data2, Uuid->Data3, Uuid->Data4[0], Uuid->Data4[1],
Uuid->Data4[2], Uuid->Data4[3], Uuid->Data4[4], Uuid->Data4[5],
Uuid->Data4[6], Uuid->Data4[7] );
}
return;
}
*/
/*
DWORD OSF_CCONNECTION_SIZE = sizeof(OSF_CCONNECTION);
DWORD OSF_SCONNECTION_SIZE = sizeof(OSF_SCONNECTION);
DWORD OSF_ADDRESS_SIZE = sizeof(OSF_ADDRESS);
DWORD DG_ADDRESS_SIZE = sizeof(DG_ADDRESS);
*/
VOID do_sizes()
{
d_printf("BUGBUG .... Add stuff here \n");
// d_printf("sizeof(ASSOCIATION_HANDLE) - 0x%x\n", sizeof(ASSOCIATION_HANDLE));
}
DECLARE_API(sizes)
{
INIT_DPRINTF();
do_sizes();
}
char* GetError(DWORD dwError)
{
DWORD dwFlag = FORMAT_MESSAGE_FROM_SYSTEM;
static CHAR szErrorMessage[1024];
static HANDLE hSource = NULL;
if ((dwError >= 2100) && (dwError < 6000)) {
if (hSource == NULL) {
hSource = LoadLibrary("netmsg.dll");
}
if (hSource == NULL) {
sprintf(szErrorMessage, "Unable to load netmsg.dll. Error %d occured.\n", dwError);
return(szErrorMessage);
}
dwFlag = FORMAT_MESSAGE_FROM_HMODULE;
}
if (!FormatMessage(dwFlag, hSource, dwError, 0, szErrorMessage, 1024, NULL)) {
sprintf(szErrorMessage, "An unknown error occured: 0x%x \n", dwError);
}
return(szErrorMessage);
}
VOID do_error(DWORD dwAddr)
{
d_printf("0x%x: %s\n", dwAddr, GetError(dwAddr));
}
DECLARE_API(help)
{
INIT_DPRINTF();
if (lpArgumentString[0] == '\0') {
d_printf("\n"
"wininext help:\n\n"
"\n"
"!obj <address> - Dumps an RPC object \n"
"\n"
"!sizes - Prints sizes of the data structures\n"
"!error - Translates and error value into the error message\n"
"!symbol (<address>|<symbol name>) - Returns symbol name/address\n"
"!fsm <address> - Dumps the CFsm object\n"
"!ho <address> - Dumps the HANDLE_OBJECT object\n"
"!iho <address> - Dumps the INTERNET_HANDLE_OBJECT object\n"
"!icho <address> - Dumps the INTERNET_CONNECT_HANDLE_OBJECT object\n"
"!hrho <address> - Dumps the ///
// HEADER_STRING structure
DECLARE_API(HEADER_STRING)
{
DWORD dwAddr;
INIT_DPRINTF();
dwAddr = d_GetExpression(lpArgumentString);
if (!dwAddr) {
return;
}
do_HEADER_STRING(dwAddr);
}
VOID do_HEADER_STRING(DWORD addr)
{
BOOL b;
char block[sizeof(HEADER_STRING)];
HEADER_STRING* obj = (HEADER_STRING*)&block;
b = GetData(addr, block, sizeof(HEADER_STRING), NULL);
if (!b) {
d_printf("couldn't read HEADER_STRING at 0x%x; sorry.\n", addr);
return;
}
d_printf("HEADER_STRING @ 0x%x \n\n", addr);
//DWORD m_Hash
d_printf("\tDWORD m_Hash %d\n", obj->m_Hash);
//LPSTR value
d_printf("\tLPSTR value %s\n", obj->value);
d_printf("\n");
} // HEADER_STRING
// HTTP_HEADERS structure
DECLARE_API(HTTP_HEADERS)
{
DWORD dwAddr;
INIT_DPRINTF();
dwAddr = d_GetExpression(lpArgumentString);
if (!dwAddr) {
return;
}
do_HTTP_HEADERS(dwAddr);
}
VOID do_HTTP_HEADERS(DWORD addr)
{
BOOL b;
char block[sizeof(HTTP_HEADERS)];
HTTP_HEADERS* obj = (HTTP_HEADERS*)&block;
b = GetData(addr, block, sizeof(HTTP_HEADERS), NULL);
if (!b) {
d_printf("couldn't read HTTP_HEADERS at 0x%x; sorry.\n", addr);
return;
}
d_printf("HTTP_HEADERS @ 0x%x \n\n", addr);
#ifndef STRESS_BUG_DEBUG
#endif
#if INET_DEBUG
//DWORD _Signature
d_printf("\tDWORD _Signature %d\n", obj->_Signature);
#endif
//HEADER_STRING * _lpHeaders
d_printf("\tHEADER_STRING * _lpHeaders 0x%x\n", obj->_lpHeaders);
//DWORD _TotalSlots
d_printf("\tDWORD _TotalSlots %d\n", obj->_TotalSlots);
//DWORD _NextOpenSlot
d_printf("\tDWORD _NextOpenSlot %d\n", obj->_NextOpenSlot);
//DWORD _FreeSlots
d_printf("\tDWORD _FreeSlots %d\n", obj->_FreeSlots);
//DWORD _HeadersLength
d_printf("\tDWORD _HeadersLength %d\n", obj->_HeadersLength);
//BOOL _IsRequestHeaders
d_printf("\tBOOL _IsRequestHeaders %d\n", obj->_IsRequestHeaders);
//LPSTR _lpszVerb
d_printf("\tLPSTR _lpszVerb %s\n", obj->_lpszVerb);
//DWORD _dwVerbLength
d_printf("\tDWORD _dwVerbLength %d\n", obj->_dwVerbLength);
//LPSTR _lpszObjectName
d_printf("\tLPSTR _lpszObjectName %s\n", obj->_lpszObjectName);
//DWORD _dwObjectNameLength
d_printf("\tDWORD _dwObjectNameLength %d\n", obj->_dwObjectNameLength);
//LPSTR _lpszVersion
d_printf("\tLPSTR _lpszVersion %s\n", obj->_lpszVersion);
//DWORD _dwVersionLength
d_printf("\tDWORD _dwVersionLength %d\n", obj->_dwVersionLength);
//DWORD _RequestVersionMajor
d_printf("\tDWORD _RequestVersionMajor %d\n", obj->_RequestVersionMajor);
//DWORD _RequestVersionMinor
d_printf("\tDWORD _RequestVersionMinor %d\n", obj->_RequestVersionMinor);
//DWORD _Error
d_printf("\tDWORD _Error %d\n", obj->_Error);
#ifdef STRESS_BUG_DEBUG
//DWORD _dwCritCount
d_printf("\tDWORD _dwCritCount %d\n", obj->_dwCritCount);
#endif
#ifdef STRESS_BUG_DEBUG
#endif
#if INET_DEBUG
#endif
#if INET_DEBUG
#endif
#ifdef STRESS_BUG_DEBUG
#endif
#ifdef STRESS_BUG_DEBUG
#endif
#ifdef COMPRESSED_HEADERS
#endif //COMPRESSED_HEADERS
d_printf("\n");
} // HTTP_HEADERS
// HTTP_REQUEST_HANDLE_OBJECT structure
DECLARE_API(HTTP_REQUEST_HANDLE_OBJECT)
{
DWORD dwAddr;
INIT_DPRINTF();
dwAddr = d_GetExpression(lpArgumentString);
if (!dwAddr) {
return;
}
do_HTTP_REQUEST_HANDLE_OBJECT(dwAddr);
}
VOID do_HTTP_REQUEST_HANDLE_OBJECT(DWORD addr)
{
BOOL b;
char block[sizeof(HTTP_REQUEST_HANDLE_OBJECT)];
HTTP_REQUEST_HANDLE_OBJECT* obj = (HTTP_REQUEST_HANDLE_OBJECT*)&block;
b = GetData(addr, block, sizeof(HTTP_REQUEST_HANDLE_OBJECT), NULL);
if (!b) {
d_printf("couldn't read HTTP_REQUEST_HANDLE_OBJECT at 0x%x; sorry.\n", addr);
return;
}
d_printf("HTTP_REQUEST_HANDLE_OBJECT @ 0x%x \n\n", addr);
//LIST_ENTRY m_PipelineList
d_printf("\tLIST_ENTRY (*) m_PipelineList 0x%x\n", OFFSET(HTTP_REQUEST_HANDLE_OBJECT, m_PipelineList));
//LONG m_lPriority
d_printf("\tLONG m_lPriority %d\n", obj->m_lPriority);
//ICSocket * _Socket
d_printf("\tICSocket * _Socket 0x%x\n", obj->_Socket);
//BOOL _bKeepAliveConnection
d_printf("\tBOOL _bKeepAliveConnection %d\n", obj->_bKeepAliveConnection);
//BOOL _bNoLongerKeepAlive
d_printf("\tBOOL _bNoLongerKeepAlive %d\n", obj->_bNoLongerKeepAlive);
//LPVOID _QueryBuffer
d_printf("\tLPVOID _QueryBuffer 0X%X\n", obj->_QueryBuffer);
//DWORD _QueryBufferLength
d_printf("\tDWORD _QueryBufferLength %d\n", obj->_QueryBufferLength);
//DWORD _QueryOffset
d_printf("\tDWORD _QueryOffset %d\n", obj->_QueryOffset);
//DWORD _QueryBytesAvailable
d_printf("\tDWORD _QueryBytesAvailable %d\n", obj->_QueryBytesAvailable);
//DWORD _OpenFlags
d_printf("\tDWORD _OpenFlags %d\n", obj->_OpenFlags);
//HTTPREQ_STATE _State
d_printf("\tHTTPREQ_STATE _State %d\n", obj->_State);
//HTTP_HEADERS _RequestHeaders
d_printf("\tHTTP_HEADERS _RequestHeaders 0X%X\n", obj->_RequestHeaders);
//HTTP_METHOD_TYPE _RequestMethod
d_printf("\tHTTP_METHOD_TYPE _RequestMethod %d\n", obj->_RequestMethod);
//DWORD _dwOptionalSaved
d_printf("\tDWORD _dwOptionalSaved %d\n", obj->_dwOptionalSaved);
//LPVOID _lpOptionalSaved
d_printf("\tLPVOID _lpOptionalSaved 0X%X\n", obj->_lpOptionalSaved);
//BOOL _fOptionalSaved
d_printf("\tBOOL _fOptionalSaved %d\n", obj->_fOptionalSaved);
//DWORD _iSlotContentLength
d_printf("\tDWORD _iSlotContentLength %d\n", obj->_iSlotContentLength);
//DWORD _iSlotContentRange
d_printf("\tDWORD _iSlotContentRange %d\n", obj->_iSlotContentRange);
//DWORD _StatusCode
d_printf("\tDWORD _StatusCode %d\n", obj->_StatusCode);
//LPBYTE _ResponseBuffer
d_printf("\tLPBYTE _ResponseBuffer 0X%X\n", obj->_ResponseBuffer);
//DWORD _ResponseBufferLength
d_printf("\tDWORD _ResponseBufferLength %d\n", obj->_ResponseBufferLength);
//DWORD _BytesReceived
d_printf("\tDWORD _BytesReceived %d\n", obj->_BytesReceived);
//DWORD _ResponseScanned
d_printf("\tDWORD _ResponseScanned %d\n", obj->_ResponseScanned);
//DWORD _ResponseBufferDataReadyToRead
d_printf("\tDWORD _ResponseBufferDataReadyToRead %d\n", obj->_ResponseBufferDataReadyToRead);
//DWORD _DataOffset
d_printf("\tDWORD _DataOffset %d\n", obj->_DataOffset);
//DWORD _BytesRemaining
d_printf("\tDWORD _BytesRemaining %d\n", obj->_BytesRemaining);
//DWORD _ContentLength
d_printf("\tDWORD _ContentLength %d\n", obj->_ContentLength);
//DWORD _BytesInSocket
d_printf("\tDWORD _BytesInSocket %d\n", obj->_BytesInSocket);
//FILETIME _ftLastModified
d_printf("\tFILETIME _ftLastModified %d\n", obj->_ftLastModified);
//FILETIME _ftExpires
d_printf("\tFILETIME _ftExpires %d\n", obj->_ftExpires);
//FILETIME _ftPostCheck
d_printf("\tFILETIME _ftPostCheck %d\n", obj->_ftPostCheck);
//CHUNK_TRANSFER _ctChunkInfo
d_printf("\tCHUNK_TRANSFER (*) _ctChunkInfo 0x%x\n", OFFSET(HTTP_REQUEST_HANDLE_OBJECT, _ctChunkInfo));
//BOOL _fTalkingToSecureServerViaProxy
d_printf("\tBOOL _fTalkingToSecureServerViaProxy %d\n", obj->_fTalkingToSecureServerViaProxy);
//BOOL _fRequestUsingProxy
d_printf("\tBOOL _fRequestUsingProxy %d\n", obj->_fRequestUsingProxy);
//BOOL _bWantKeepAlive
d_printf("\tBOOL _bWantKeepAlive %d\n", obj->_bWantKeepAlive);
//BOOL _bRefresh
d_printf("\tBOOL _bRefresh %d\n", obj->_bRefresh);
//HEADER_STRING _RefreshHeader
d_printf("\tHEADER_STRING (*) _RefreshHeader 0x%x\n", OFFSET(HTTP_REQUEST_HANDLE_OBJECT, _RefreshHeader));
//DWORD _dwQuerySetCookieHeader
d_printf("\tDWORD _dwQuerySetCookieHeader %d\n", obj->_dwQuerySetCookieHeader);
d_printf("\n");
} // HTTP_REQUEST_HANDLE_OBJECT
#ifndef unix
#endif /* unix */
HANDLE_OBJECT object\n"
"!tinf <address> - Dumps the INTERNET_THREAD_INFO structure\n"
"!lste <address> - Dumps the LIST_ENTRY structure\n"
"!serialist <address> - Dumps the SERIALIZED_LIST structure\n"
"!proxyinfo <address> - Dumps the PROXY_INFO structure\n"
"!proxysrvlst <address> - Dumps the PROXY_INFO structure\n"
"!proxysrvlste <address> - Dumps the PROXY_INFO_LIST structure\n"
"!proxybyplst <address> - Dumps the PROXY_BYPASS_LIST structure\n"
"!proxybyplste <address> - Dumps the PROXY_BYPASS_LIST_ENTRY structure\n"
);
}
}
void do_symbol(DWORD dwAddr)
{
CHAR Symbol[64];
DWORD Displacement;
d_GetSymbol((LPVOID)dwAddr, (unsigned char*)Symbol, &Displacement);
d_printf("%lx %s+%lx\n", dwAddr, Symbol, Displacement);
}
DECLARE_API(symbol)
{
DWORD dwAddr;
INIT_DPRINTF();
dwAddr = d_GetExpression(lpArgumentString);
if (!dwAddr) {
return;
}
do_symbol(dwAddr);
}
USHORT SavedMajorVersion;
USHORT SavedMinorVersion;
BOOL ChkTarget; // is debuggee a CHK build?
#define VER_PRODUCTBUILD 10
EXT_API_VERSION ApiVersion = {3, 5, EXT_API_VERSION_NUMBER, 0};
VOID
WinDbgExtensionDllInit(
PWINDBG_EXTENSION_APIS lpExtensionApis,
USHORT MajorVersion,
USHORT MinorVersion
)
{
fKD = 1;
ExtensionApis = *lpExtensionApis;
SavedMajorVersion = MajorVersion;
SavedMinorVersion = MinorVersion;
ChkTarget = SavedMajorVersion == 0x0c ? TRUE : FALSE;
}
DECLARE_API(version)
{
#if DBG
PCSTR kind = "Checked";
#else
PCSTR kind = "Free";
#endif
d_printf(
"%s RPC Extension dll for Build %d debugging %s kernel for Build %d\n",
kind,
VER_PRODUCTBUILD,
SavedMajorVersion == 0x0c ? "Checked" : "Free",
SavedMinorVersion
);
}
VOID CheckVersion(VOID)
{
}
LPEXT_API_VERSION ExtensionApiVersion(VOID)
{
return &ApiVersion;
}
// Dump the FSM class structure
DECLARE_API(fsm)
{
DWORD dwAddr;
INIT_DPRINTF();
dwAddr = d_GetExpression(lpArgumentString);
if (!dwAddr) {
return;
}
do_fsm(dwAddr);
}
VOID do_fsm(DWORD addr)
{
BOOL b;
char block[sizeof(CFsm)];
CFsm* fsm = (CFsm*)&block;
b = GetData(addr, block, sizeof(CFsm), NULL);
if (!b) {
d_printf("couldn't read CFsm at 0x%x; sorry.\n", addr);
return;
}
d_printf("\nCFsm at 0x%x \n", addr);
// CFsm * m_Link;
d_printf("\tCFsm * m_Link = 0x%x\n", fsm->m_Link);
// DWORD m_dwError;
d_printf("\tDWORD m_dwError = %d\n", fsm->m_dwError);
// LPINTERNET_THREAD_INFO m_lpThreadInfo;
d_printf("\tm_lpThreadInfo = 0x%x\n", fsm->m_lpThreadInfo);
// DWORD m_dwContext;
d_printf("\tDWORD_PTR m_dwContext = %d\n", fsm->m_dwContext);
// HINTERNET m_hObject;
d_printf("\tHINTERNET m_hObject = 0x%x\n", fsm->m_hObject);
//INTERNET_HANDLE_OBJECT * m_hObjectMapped;
d_printf("\tINTERNET_HANDLE_OBJECT * m_hObjectMapped = 0x%x\n", fsm->m_hObjectMapped);
//DWORD m_dwMappedErrorCode;
d_printf("\tDWORD m_dwMappedErrorCode = %d\n", fsm->m_dwMappedErrorCode);
//FSM_STATE m_State;
d_printf("\tFSM_STATE m_State = %d ( %s )\n", fsm->m_State, MapState(fsm->m_NextState));
//FSM_STATE m_NextState;
d_printf("\tFSM_STATE m_NextState = %d ( %s ) \n", fsm->m_NextState, MapState(fsm->m_NextState));
//FSM_STATE m_FunctionState;
d_printf("\tFSM_STATE m_FunctionState = %d ( %s ) \n", fsm->m_FunctionState, MapState(fsm->m_FunctionState));
#if INET_DEBUG
//FSM_TYPE m_Type;
d_printf("\tFSM_TYPE m_Type = %d(%s)\n", fsm->m_Type, MapType(fsm->m_Type));
#endif
/*
DWORD (*m_lpfnHandler)(CFsm *);
d_printf("\tCFsm * m_Link = 0x%x\n", fsm -> m_Link );
LPVOID m_lpvContext;
d_printf("\tCFsm * m_Link = 0x%x\n", fsm -> m_Link );
FSM_HINT m_Hint;
d_printf("\tCFsm * m_Link = 0x%x\n", fsm -> m_Link );
*/
//SOCKET m_Socket;
d_printf("\tSOCKET m_Socket = 0x%x\n", fsm->m_Socket);
FSM_ACTION m_Action;
d_printf("\tCFsm * m_Link = 0x%x\n", fsm->m_Link);
/*
DWORD m_dwBlockId;
d_printf("\tCFsm * m_Link = 0x%x\n", fsm -> m_Link );
DWORD m_dwTimeout;
d_printf("\tCFsm * m_Link = 0x%x\n", fsm -> m_Link );
DWORD m_dwTimer;
d_printf("\tCFsm * m_Link = 0x%x\n", fsm -> m_Link );
BOOL m_bTimerStarted;
d_printf("\tCFsm * m_Link = 0x%x\n", fsm -> m_Link );
*/
//BOOL m_bIsApi;
d_printf("\tBOOL m_bIsApi = %d\n", fsm->m_bIsApi);
//API_TYPE m_ApiType;
d_printf("\tAPI_TYPE m_ApiType = %d\n", fsm->m_ApiType);
//DWORD m_dwApiData;
d_printf("\tDWORD m_dwApiData = %d\n", fsm->m_dwApiData);
d_printf("\n");
/*
union {
BOOL Bool;
HINTERNET Handle;
} m_ApiResult;
*/
}
// Dump the HANDLE_OBJECT class structure
VOID do_handle_object(DWORD addr)
{
BOOL b;
char block[sizeof(HANDLE_OBJECT)];
HANDLE_OBJECT* fsm = (HANDLE_OBJECT*)&block;
b = GetData(addr, block, sizeof(HANDLE_OBJECT), NULL);
if (!b) {
d_printf("couldn't read HANDLE_OBJECT at 0x%x; sorry.\n", addr);
return;
}
d_printf("HANDLE_OBJECT @ 0x%x \n", addr);
//LIST_ENTRY _List;
//d_printf("\tLIST_ENTRY _List\n");
d_printf("\tLIST_ENTRY (*) _List = 0x%x \n", ((DWORD)addr + offsetof(HANDLE_OBJECT, _List)));
/*
d_printf("\t\tLIST_ENTY * Flink = 0x%x\n", (fsm -> _List).Flink);
d_printf("\t\tLIST_ENTY * Blink = 0x%x\n", (fsm -> _List).Blink);
*/
//SERIALIZED_LIST _Children;
d_printf("\tSERIALIZED_LIST (*) _Children = 0x%x \n", ((DWORD)addr + offsetof(HANDLE_OBJECT, _Children)));
//LIST_ENTRY _Siblings;
d_printf("\tLIST_ENTRY (*) _Siblings = 0x%x \n", ((DWORD)addr + offsetof(HANDLE_OBJECT, _Siblings)));
//HANDLE_OBJECT* _Parent;
d_printf("\tHANDLE_OBJECT * _Parent = 0x%x \n", fsm->_Parent);
//BOOL _DeleteWithChild;
d_printf("\tBOOL _DeleteWithChild = %d \n", fsm->_DeleteWithChild);
//HINTERNET _Handle;
d_printf("\tHINTERNET _Handle = 0x%x \n", fsm->_Handle);
//HINTERNET_HANDLE_TYPE _ObjectType;
d_printf("\tHINTERNET_HANDLE_TYPE _ObjectType = %d \n", fsm->_ObjectType);
//LONG _ReferenceCount;
d_printf("\tLONG _ReferenceCount = %ld \n", fsm->_ReferenceCount);
//BOOL _Invalid;
d_printf("\tBOOL _Invalid = %d \n", fsm->_Invalid);
//DWORD _Error;
d_printf("\tDWORD _Error = %d \n", fsm->_Error);
//DWORD _Signature;
d_printf("\tDWORD _Signature = 0x%x \n", fsm->_Signature);
//DWORD _Context;
d_printf("\tDWORD _Context = %d \n", fsm->_Context);
//DWORD _Status;
d_printf("\tDWORD _Status = %d \n", fsm->_Status);
d_printf("\n");
}
DECLARE_API(ho)
{
DWORD dwAddr;
INIT_DPRINTF();
dwAddr = d_GetExpression(lpArgumentString);
if (!dwAddr) {
return;
}
do_handle_object(dwAddr);
}
// Dump the Thread Info structure
VOID do_thread_info(DWORD addr)
{
BOOL b;
char block[sizeof(INTERNET_THREAD_INFO)];
LPINTERNET_THREAD_INFO fsm = (LPINTERNET_THREAD_INFO)&block;
b = GetData(addr, block, sizeof(INTERNET_THREAD_INFO), NULL);
if (!b) {
d_printf("couldn't read INTERNET_THREAD_INFO at 0x%x; sorry.\n", addr);
return;
}
d_printf("INTERNET_THREAD_INFO @ 0x%x \n", addr);
//LIST_ENTRY List;
d_printf("\tLIST_ENTRY List = 0x%x \n", fsm->List);
// DWORD ThreadId;
d_printf("\tDWORD ThreadId = %d \n", fsm->ThreadId);
//DWORD ErrorNumber;
d_printf("\tDWORD ErrorNumber = %d \n", fsm->ErrorNumber);
//DWORD Context;
d_printf("\tDWORD Context = %d \n", fsm->Context);
//HINTERNET hObject;
d_printf("\tHINTERNET hObject = 0x%x \n", fsm->hObject);
//HINTERNET hObjectMapped;
d_printf("\tHINTERNET hObjectMapped = 0x%x \n", fsm->hObjectMapped);
//BOOL IsAsyncWorkerThread;
d_printf("\tBOOL IsAsyncWorkerThread = %d \n", fsm->IsAsyncWorkerThread);
//BOOL InCallback;
d_printf("\tBOOL InCallback = %d \n", fsm->InCallback);
//BOOL IsAutoProxyProxyThread;
d_printf("\tBOOL IsAutoProxyProxyThread = %d \n", fsm->IsAutoProxyProxyThread);
//DWORD NestedRequests;
d_printf("\tDWORD NestedRequests = %d \n", fsm->NestedRequests);
//DWORD dwMappedErrorCode;
d_printf("\tDWORD dwMappedErrorCode = %d \n", fsm->dwMappedErrorCode);
//CFsm * Fsm;
d_printf("\tCFsm * Fsm = 0x%x \n", fsm->Fsm);
d_printf("\n");
}
DECLARE_API(tinf)
{
DWORD dwAddr;
INIT_DPRINTF();
dwAddr = d_GetExpression(lpArgumentString);
if (!dwAddr) {
return;
}
do_thread_info(dwAddr);
}
// Dump the INTERNET_HANDLE_OBJECT class structure
VOID do_internet_handle_object(DWORD addr)
{
BOOL b;
char block[sizeof(INTERNET_HANDLE_OBJECT)];
INTERNET_HANDLE_OBJECT* obj = (INTERNET_HANDLE_OBJECT*)&block;
b = GetData(addr, block, sizeof(INTERNET_HANDLE_OBJECT), NULL);
if (!b) {
d_printf("couldn't read INTERNET_HANDLE_OBJECT at 0x%x; sorry.\n", addr);
return;
}
//do_internet_handle_object( addr );
d_printf("INTERNET_HANDLE_OBJECT @ 0x%x \n\n", addr);
//HINTERNET _INetHandle
d_printf("\tHINTERNET _INetHandle = 0x%x\n", obj->_INetHandle);
//BOOL _IsCopy
d_printf("\tBOOL _IsCopy = %d\n", obj->_IsCopy);
//ICSTRING _UserAgent
d_printf("\tICSTRING _UserAgent = 0x%x\n", obj->_UserAgent);
//PROXY_INFO * _ProxyInfo
d_printf("\tPROXY_INFO * _ProxyInfo = 0x%x\n", obj->_ProxyInfo);
//RESOURCE_LOCK _ProxyInfoResourceLock
d_printf("\tRESOURCE_LOCK (*) _ProxyInfoResourceLock = 0x%x\n", &(obj->_ProxyInfoResourceLock));
//DWORD _dwInternetOpenFlags
d_printf("\tDWORD _dwInternetOpenFlags = %d\n", obj->_dwInternetOpenFlags);
//BOOL _WinsockLoaded
d_printf("\tBOOL _WinsockLoaded = %d\n", obj->_WinsockLoaded);
//ICSocket * _pICSocket
d_printf("\tICSocket * _pICSocket = 0x%x\n", obj->_pICSocket);
//DWORD _ConnectTimeout
d_printf("\tDWORD _ConnectTimeout = %d\n", obj->_ConnectTimeout);
//DWORD _ConnectRetries
d_printf("\tDWORD _ConnectRetries = %d\n", obj->_ConnectRetries);
//DWORD _SendTimeout
d_printf("\tDWORD _SendTimeout = %d\n", obj->_SendTimeout);
//DWORD _DataSendTimeout
d_printf("\tDWORD _DataSendTimeout = %d\n", obj->_DataSendTimeout);
//DWORD _ReceiveTimeout
d_printf("\tDWORD _ReceiveTimeout = %d\n", obj->_ReceiveTimeout);
//DWORD _DataReceiveTimeout
d_printf("\tDWORD _DataReceiveTimeout = %d\n", obj->_DataReceiveTimeout);
//DWORD _SocketSendBufferLength
d_printf("\tDWORD _SocketSendBufferLength = %d\n", obj->_SocketSendBufferLength);
//DWORD _SocketReceiveBufferLength
d_printf("\tDWORD _SocketReceiveBufferLength = %d\n", obj->_SocketReceiveBufferLength);
//BOOL _Async
d_printf("\tBOOL _Async = %d\n", obj->_Async);
//DWORD _DataAvailable
d_printf("\tDWORD _DataAvailable = %d\n", obj->_DataAvailable);
//BOOL _EndOfFile
d_printf("\tBOOL _EndOfFile = %d\n", obj->_EndOfFile);
d_printf("\n");
}
DECLARE_API(iho)
{
DWORD dwAddr;
INIT_DPRINTF();
dwAddr = d_GetExpression(lpArgumentString);
if (!dwAddr) {
return;
}
do_internet_handle_object(dwAddr);
}
// INTERNET_CONNECT_HANDLE_OBJECT structure
DECLARE_API(INTERNET_CONNECT_HANDLE_OBJECT)
{
DWORD dwAddr;
INIT_DPRINTF();
dwAddr = d_GetExpression(lpArgumentString);
if (!dwAddr) {
return;
}
do_INTERNET_CONNECT_HANDLE_OBJECT(dwAddr);
}
VOID do_INTERNET_CONNECT_HANDLE_OBJECT(DWORD addr)
{
BOOL b;
char block[sizeof(INTERNET_CONNECT_HANDLE_OBJECT)];
INTERNET_CONNECT_HANDLE_OBJECT* obj = (INTERNET_CONNECT_HANDLE_OBJECT*)&block;
b = GetData(addr, block, sizeof(INTERNET_CONNECT_HANDLE_OBJECT), NULL);
if (!b) {
d_printf("couldn't read INTERNET_CONNECT_HANDLE_OBJECT at 0x%x; sorry.\n", addr);
return;
}
d_printf("INTERNET_CONNECT_HANDLE_OBJECT @ 0x%x \n\n", addr);
//HINTERNET _InternetConnectHandle
d_printf("\tHINTERNET _InternetConnectHandle 0X%X\n", obj->_InternetConnectHandle);
//BOOL _IsCopy
d_printf("\tBOOL _IsCopy %d\n", obj->_IsCopy);
//DWORD _ServiceType
d_printf("\tDWORD _ServiceType %d\n", obj->_ServiceType);
//HINTERNET_HANDLE_TYPE _HandleType
d_printf("\tHINTERNET_HANDLE_TYPE _HandleType %d\n", obj->_HandleType);
//BOOL _Flags
d_printf("\tBOOL _Flags %d\n", obj->_Flags);
//BOOL _InUse
d_printf("\tBOOL _InUse %d\n", obj->_InUse);
//BOOL _fDeleteDataFile
d_printf("\tBOOL _fDeleteDataFile %d\n", obj->_fDeleteDataFile);
//LPSTR _CacheCWD
d_printf("\tLPSTR _CacheCWD %s\n", obj->_CacheCWD);
//LPSTR _CacheUrlName
d_printf("\tLPSTR _CacheUrlName %s\n", obj->_CacheUrlName);
//XSTRING _xsPrimaryCacheKey
d_printf("\tXSTRING (*) _xsPrimaryCacheKey 0x%x\n", OFFSET(INTERNET_CONNECT_HANDLE_OBJECT, _xsPrimaryCacheKey));
//XSTRING _xsSecondaryCacheKey
d_printf("\tXSTRING (*) _xsSecondaryCacheKey 0x%x\n", OFFSET(INTERNET_CONNECT_HANDLE_OBJECT, _xsSecondaryCacheKey));
//LPSTR _CacheFileName
d_printf("\tLPSTR _CacheFileName %s\n", obj->_CacheFileName);
//DWORD _CacheHeaderLength
d_printf("\tDWORD _CacheHeaderLength %d\n", obj->_CacheHeaderLength);
//BOOL _CacheReadInProgress
d_printf("\tBOOL _CacheReadInProgress %d\n", obj->_CacheReadInProgress);
//BOOL _CacheWriteInProgress
d_printf("\tBOOL _CacheWriteInProgress %d\n", obj->_CacheWriteInProgress);
//DWORD _RealCacheFileSize
d_printf("\tDWORD _RealCacheFileSize %d\n", obj->_RealCacheFileSize);
//DWORD _VirtualCacheFileSize
d_printf("\tDWORD _VirtualCacheFileSize %d\n", obj->_VirtualCacheFileSize);
#ifdef LAZY_WRITE
//LPBYTE _CacheScratchBuf
d_printf("\tLPBYTE _CacheScratchBuf 0X%X\n", obj->_CacheScratchBuf);
//DWORD _CacheScratchBufLen
d_printf("\tDWORD _CacheScratchBufLen %d\n", obj->_CacheScratchBufLen);
//DWORD _CacheScratchUsedLen
d_printf("\tDWORD _CacheScratchUsedLen %d\n", obj->_CacheScratchUsedLen);
#endif
//DWORD _dwCacheFlags
d_printf("\tDWORD _dwCacheFlags %d\n", obj->_dwCacheFlags);
//DWORD _dwStreamRefCount
d_printf("\tDWORD _dwStreamRefCount %d\n", obj->_dwStreamRefCount);
//DWORD _dwCurrentStreamPosition
d_printf("\tDWORD _dwCurrentStreamPosition %d\n", obj->_dwCurrentStreamPosition);
//BOOL _fFromCache
d_printf("\tBOOL _fFromCache %d\n", obj->_fFromCache);
//BOOL _fCacheWriteDisabled
d_printf("\tBOOL _fCacheWriteDisabled %d\n", obj->_fCacheWriteDisabled);
//BOOL _fIsHtmlFind
d_printf("\tBOOL _fIsHtmlFind %d\n", obj->_fIsHtmlFind);
//BOOL _CacheCopy
d_printf("\tBOOL _CacheCopy %d\n", obj->_CacheCopy);
//BOOL _CachePerUserItem
d_printf("\tBOOL _CachePerUserItem %d\n", obj->_CachePerUserItem);
//BOOL _fForcedExpiry
d_printf("\tBOOL _fForcedExpiry %d\n", obj->_fForcedExpiry);
//BOOL _fLazyUpdate
d_printf("\tBOOL _fLazyUpdate %d\n", obj->_fLazyUpdate);
//LPSTR _OriginalUrl
d_printf("\tLPSTR _OriginalUrl %s\n", obj->_OriginalUrl);
#ifdef LAZY_WRITE
#endif // LAZY_WRITE
//DWORD _ReadBufferSize
d_printf("\tDWORD _ReadBufferSize %d\n", obj->_ReadBufferSize);
//DWORD _WriteBufferSize
d_printf("\tDWORD _WriteBufferSize %d\n", obj->_WriteBufferSize);
//ICSTRING _HostName
d_printf("\tICSTRING (*) _HostName 0x%x\n", OFFSET(INTERNET_CONNECT_HANDLE_OBJECT, _HostName));
//XSTRING _xsUser
d_printf("\tXSTRING (*) _xsUser 0x%x\n", OFFSET(INTERNET_CONNECT_HANDLE_OBJECT, _xsUser));
//XSTRING _xsPass
d_printf("\tXSTRING (*) _xsPass 0x%x\n", OFFSET(INTERNET_CONNECT_HANDLE_OBJECT, _xsPass));
//XSTRING _xsProxyUser
d_printf("\tXSTRING (*) _xsProxyUser 0x%x\n", OFFSET(INTERNET_CONNECT_HANDLE_OBJECT, _xsProxyUser));
//XSTRING _xsProxyPass
d_printf("\tXSTRING (*) _xsProxyPass 0x%x\n", OFFSET(INTERNET_CONNECT_HANDLE_OBJECT, _xsProxyPass));
//INTERNET_PORT _HostPort
d_printf("\tINTERNET_PORT _HostPort %d\n", obj->_HostPort);
//INTERNET_SCHEME _SchemeType
d_printf("\tINTERNET_SCHEME _SchemeType %d\n", obj->_SchemeType);
//LPSTR _LastResponseInfo
d_printf("\tLPSTR _LastResponseInfo %s\n", obj->_LastResponseInfo);
//DWORD _LastResponseInfoLength
d_printf("\tDWORD _LastResponseInfoLength %d\n", obj->_LastResponseInfoLength);
//BOOL _bViaProxy
d_printf("\tBOOL _bViaProxy %d\n", obj->_bViaProxy);
//BOOL _bNoHeaders
d_printf("\tBOOL _bNoHeaders %d\n", obj->_bNoHeaders);
//BOOL _bNetFailed
d_printf("\tBOOL _bNetFailed %d\n", obj->_bNetFailed);
d_printf("\n");
} // INTERNET_CONNECT_HANDLE_OBJECT
// Dump the LIST_ENTRY structure
VOID do_list_entry(DWORD addr)
{
BOOL b;
char block[sizeof(LIST_ENTRY)];
LIST_ENTRY* obj = (LIST_ENTRY*)&block;
b = GetData(addr, block, sizeof(LIST_ENTRY), NULL);
if (!b) {
d_printf("couldn't read LIST_ENTRY at 0x%x; sorry.\n", addr);
return;
}
d_printf("LIST_ENTRY @ 0x%x \n\n", addr);
//struct _LIST_ENTRY * Flink
d_printf("\tstruct _LIST_ENTRY * Flink = 0x%X\n", obj->Flink);
//struct _LIST_ENTRY * Blink
d_printf("\tstruct _LIST_ENTRY * Blink = 0x%X\n", obj->Blink);
d_printf("\n");
}
DECLARE_API(lste)
{
DWORD dwAddr;
INIT_DPRINTF();
dwAddr = d_GetExpression(lpArgumentString);
if (!dwAddr) {
return;
}
do_list_entry(dwAddr);
}
// Dump the SERIALIZED_LIST structure
VOID do_serialized_list(DWORD addr)
{
BOOL b;
char block[sizeof(SERIALIZED_LIST)];
SERIALIZED_LIST* obj = (SERIALIZED_LIST*)&block;
b = GetData(addr, block, sizeof(SERIALIZED_LIST), NULL);
if (!b) {
d_printf("couldn't read SERIALIZED_LIST at 0x%x; sorry.\n", addr);
return;
}
d_printf("SERIALIZED_LIST @ 0x%x \n\n", addr);
#if INET_DEBUG
//DWORD Signature
d_printf("\tDWORD Signature %d\n", obj->Signature);
//RESOURCE_INFO ResourceInfo
d_printf("\tRESOURCE_INFO (*) ResourceInfo 0X%X\n", ((DWORD)addr + offsetof(SERIALIZED_LIST, ResourceInfo)));
//LONG LockCount
d_printf("\tLONG LockCount %d\n", obj->LockCount);
#endif // INET_DEBUG
//LIST_ENTRY List
d_printf("\tLIST_ENTRY (*) List 0X%X\n", ((DWORD)addr + offsetof(SERIALIZED_LIST, List)));
//do_list_entry( (DWORD) &obj->List );
//LONG ElementCount
d_printf("\tLONG ElementCount %ld\n", obj->ElementCount);
d_printf("\n");
}
DECLARE_API(serialist)
{
DWORD dwAddr;
INIT_DPRINTF();
dwAddr = d_GetExpression(lpArgumentString);
if (!dwAddr) {
return;
}
do_serialized_list(dwAddr);
}
// PROXY_INFO structure
VOID do_proxy_info(DWORD addr)
{
BOOL b;
char block[sizeof(PROXY_INFO)];
PROXY_INFO* obj = (PROXY_INFO*)&block;
b = GetData(addr, block, sizeof(PROXY_INFO), NULL);
if (!b) {
d_printf("couldn't read PROXY_INFO at 0x%x; sorry.\n", addr);
return;
}
d_printf("PROXY_INFO @ 0x%x \n\n", addr);
//PROXY_SERVER_LIST * _ProxyServerList
d_printf("\tPROXY_SERVER_LIST * _ProxyServerList = 0X%X\n", obj->_ProxyServerList);
//AUTO_PROXY_DLLS * _AutoProxyList
d_printf("\tAUTO_PROXY_DLLS * _AutoProxyList = 0X%X\n", obj->_AutoProxyList);
//PROXY_BYPASS_LIST * _ProxyBypassList
d_printf("\tPROXY_BYPASS_LIST * _ProxyBypassList = 0X%X\n", obj->_ProxyBypassList);
//DWORD _Error
d_printf("\tDWORD _Error %d\n", obj->_Error);
//RESOURCE_LOCK _Lock
d_printf("\tRESOURCE_LOCK (*) _Lock 0X%X\n", OFFSET(PROXY_INFO, _Lock));
//BOOL _Modified
d_printf("\tBOOL _Modified %d\n", obj->_Modified);
//BAD_PROXY_LIST _BadProxyList
d_printf("\tBAD_PROXY_LIST _BadProxyList 0X%X\n", OFFSET(PROXY_INFO, _BadProxyList));
d_printf("\n");
}
DECLARE_API(proxyinfo)
{
DWORD dwAddr;
INIT_DPRINTF();
dwAddr = d_GetExpression(lpArgumentString);
if (!dwAddr) {
return;
}
do_proxy_info(dwAddr);
}
// PROXY_BYPASS_LIST_ENTRY structure
DECLARE_API(proxybyplste)
{
DWORD dwAddr;
INIT_DPRINTF();
dwAddr = d_GetExpression(lpArgumentString);
if (!dwAddr) {
return;
}
do_PROXY_BYPASS_LIST_ENTRY(dwAddr);
}
VOID do_PROXY_BYPASS_LIST_ENTRY(DWORD addr)
{
BOOL b;
char block[sizeof(PROXY_BYPASS_LIST_ENTRY)];
PROXY_BYPASS_LIST_ENTRY* obj = (PROXY_BYPASS_LIST_ENTRY*)&block;
b = GetData(addr, block, sizeof(PROXY_BYPASS_LIST_ENTRY), NULL);
if (!b) {
d_printf("couldn't read PROXY_BYPASS_LIST_ENTRY at 0x%x; sorry.\n", addr);
return;
}
d_printf("PROXY_BYPASS_LIST_ENTRY @ 0x%x \n\n", addr);
//LIST_ENTRY _List
d_printf("\tLIST_ENTRY (*) _List 0x%x\n", OFFSET(PROXY_BYPASS_LIST_ENTRY, _List));
//INTERNET_SCHEME _Scheme
d_printf("\tINTERNET_SCHEME _Scheme %d\n", obj->_Scheme);
//ICSTRING _Name
d_printf("\tICSTRING (*) _Name 0x%x\n", OFFSET(PROXY_BYPASS_LIST_ENTRY, _Name));
//INTERNET_PORT _Port
d_printf("\tINTERNET_PORT _Port %d\n", obj->_Port);
//BOOL _LocalSemantics
d_printf("\tBOOL _LocalSemantics %d\n", obj->_LocalSemantics);
d_printf("\n");
} // PROXY_BYPASS_LIST_ENTRY
// PROXY_BYPASS_LIST structure
DECLARE_API(proxybyplst)
{
DWORD dwAddr;
INIT_DPRINTF();
dwAddr = d_GetExpression(lpArgumentString);
if (!dwAddr) {
return;
}
do_PROXY_BYPASS_LIST(dwAddr);
}
VOID do_PROXY_BYPASS_LIST(DWORD addr)
{
BOOL b;
char block[sizeof(PROXY_BYPASS_LIST)];
PROXY_BYPASS_LIST* obj = (PROXY_BYPASS_LIST*)&block;
b = GetData(addr, block, sizeof(PROXY_BYPASS_LIST), NULL);
if (!b) {
d_printf("couldn't read PROXY_BYPASS_LIST at 0x%x; sorry.\n", addr);
return;
}
d_printf("PROXY_BYPASS_LIST @ 0x%x \n\n", addr);
//SERIALIZED_LIST _List
d_printf("\tSERIALIZED_LIST (*) _List 0x%x\n", OFFSET(PROXY_BYPASS_LIST, _List));
//DWORD _Error
d_printf("\tDWORD _Error %d\n", obj->_Error);
d_printf("\n");
} // PROXY_BYPASS_LIST
// PROXY_SERVER_LIST_ENTRY structure
DECLARE_API(proxysrvlste)
{
DWORD dwAddr;
INIT_DPRINTF();
dwAddr = d_GetExpression(lpArgumentString);
if (!dwAddr) {
return;
}
do_PROXY_SERVER_LIST_ENTRY(dwAddr);
}
VOID do_PROXY_SERVER_LIST_ENTRY(DWORD addr)
{
BOOL b;
char block[sizeof(PROXY_SERVER_LIST_ENTRY)];
PROXY_SERVER_LIST_ENTRY* obj = (PROXY_SERVER_LIST_ENTRY*)&block;
b = GetData(addr, block, sizeof(PROXY_SERVER_LIST_ENTRY), NULL);
if (!b) {
d_printf("couldn't read PROXY_SERVER_LIST_ENTRY at 0x%x; sorry.\n", addr);
return;
}
d_printf("PROXY_SERVER_LIST_ENTRY @ 0x%x \n\n", addr);
//LIST_ENTRY _List
d_printf("\tLIST_ENTRY (*) _List 0x%x\n", OFFSET(PROXY_SERVER_LIST_ENTRY, _List));
//INTERNET_SCHEME _Protocol
d_printf("\tINTERNET_SCHEME _Protocol %d\n", obj->_Protocol);
//INTERNET_SCHEME _Scheme
d_printf("\tINTERNET_SCHEME _Scheme %d\n", obj->_Scheme);
//ICSTRING _ProxyName
d_printf("\tICSTRING (*) _ProxyName 0x%x\n", OFFSET(PROXY_SERVER_LIST_ENTRY, _ProxyName));
//INTERNET_PORT _ProxyPort
d_printf("\tINTERNET_PORT _ProxyPort %d\n", obj->_ProxyPort);
d_printf("\n");
} // PROXY_SERVER_LIST_ENTRY
// PROXY_SERVER_LIST structure
DECLARE_API(proxysrvlst)
{
DWORD dwAddr;
INIT_DPRINTF();
dwAddr = d_GetExpression(lpArgumentString);
if (!dwAddr) {
return;
}
do_PROXY_SERVER_LIST(dwAddr);
}
VOID do_PROXY_SERVER_LIST(DWORD addr)
{
BOOL b;
char block[sizeof(PROXY_SERVER_LIST)];
PROXY_SERVER_LIST* obj = (PROXY_SERVER_LIST*)&block;
b = GetData(addr, block, sizeof(PROXY_SERVER_LIST), NULL);
if (!b) {
d_printf("couldn't read PROXY_SERVER_LIST at 0x%x; sorry.\n", addr);
return;
}
d_printf("PROXY_SERVER_LIST @ 0x%x \n\n", addr);
//SERIALIZED_LIST _List
d_printf("\tSERIALIZED_LIST (*) _List 0x%x\n", OFFSET(PROXY_SERVER_LIST, _List));
//DWORD _Error
d_printf("\tDWORD _Error %d\n", obj->_Error);
d_printf("\n");
} // PROXY_SERVER_LIST
// ICSocket structure
DECLARE_API(ICSocket)
{
DWORD dwAddr;
INIT_DPRINTF();
dwAddr = d_GetExpression(lpArgumentString);
if (!dwAddr) {
return;
}
do_ICSocket(dwAddr);
}
VOID do_ICSocket(DWORD addr)
{
BOOL b;
char block[sizeof(ICSocket)];
ICSocket* obj = (ICSocket*)&block;
b = GetData(addr, block, sizeof(ICSocket), NULL);
if (!b) {
d_printf("couldn't read ICSocket at 0x%x; sorry.\n", addr);
return;
}
d_printf("ICSocket @ 0x%x \n\n", addr);
//LIST_ENTRY m_List
d_printf("\tLIST_ENTRY (*) m_List 0x%x\n", OFFSET(ICSocket, m_List));
//DWORD m_dwTimeout
d_printf("\tDWORD m_dwTimeout %d\n", obj->m_dwTimeout);
//LONG m_ReferenceCount
d_printf("\tLONG m_ReferenceCount %d\n", obj->m_ReferenceCount);
//DWORD m_dwFlags
d_printf("\tDWORD m_dwFlags %d\n", obj->m_dwFlags);
// SOCKET m_Socket;
d_printf("\tSOCKET m_Socket %d\n", obj->m_Socket);
//INTERNET_PORT m_Port
d_printf("\tINTERNET_PORT m_Port %d\n", obj->m_Port);
//INTERNET_PORT m_SourcePort
d_printf("\tINTERNET_PORT m_SourcePort %d\n", obj->m_SourcePort);
//BOOL m_bAborted
d_printf("\tBOOL m_bAborted %d\n", obj->m_bAborted);
//DWORD m_SocksAddress
d_printf("\tDWORD m_SocksAddress %d\n", obj->m_SocksAddress);
//INTERNET_PORT m_SocksPort
d_printf("\tINTERNET_PORT m_SocksPort %d\n", obj->m_SocksPort);
#if INET_DEBUG
//DWORD m_Signature
d_printf("\tDWORD m_Signature %d\n", obj->m_Signature);
#endif
d_printf("\n");
} // ICSocket
// ICSecureSocket structure
DECLARE_API(ICSecureSocket)
{
DWORD dwAddr;
INIT_DPRINTF();
dwAddr = d_GetExpression(lpArgumentString);
if (!dwAddr) {
return;
}
do_ICSecureSocket(dwAddr);
}
VOID do_ICSecureSocket(DWORD addr)
{
BOOL b;
char block[sizeof(ICSecureSocket)];
ICSecureSocket* obj = (ICSecureSocket*)&block;
b = GetData(addr, block, sizeof(ICSecureSocket), NULL);
if (!b) {
d_printf("couldn't read ICSecureSocket at 0x%x; sorry.\n", addr);
return;
}
d_printf("ICSecureSocket @ 0x%x \n\n", addr);
//CtxtHandle m_hContext
d_printf("\tCtxtHandle (*) m_hContext 0x%x\n", OFFSET(ICSecureSocket, m_hContext));
//DWORD m_dwProviderIndex
d_printf("\tDWORD m_dwProviderIndex %d\n", obj->m_dwProviderIndex);
//LPSTR m_lpszHostName
d_printf("\tLPSTR m_lpszHostName %s\n", obj->m_lpszHostName);
//DBLBUFFER * m_pdblbufBuffer
d_printf("\tDBLBUFFER * m_pdblbufBuffer 0x%x\n", obj->m_pdblbufBuffer);
//DWORD m_dwErrorFlags
d_printf("\tDWORD m_dwErrorFlags %d\n", obj->m_dwErrorFlags);
//SECURITY_CACHE_LIST_ENTRY * m_pSecurityInfo
d_printf("\tSECURITY_CACHE_LIST_ENTRY * m_pSecurityInfo 0x%x\n", obj->m_pSecurityInfo);
#if INET_DEBUG
#endif
d_printf("\n");
} // ICSecureSocket
#if INET_DEBUG
LPSTR MapType(FSM_TYPE m_Type) {
switch (m_Type) {
case FSM_TYPE_NONE: return "NONE";
case FSM_TYPE_WAIT_FOR_COMPLETION: return "WAIT_FOR_COMPLETION";
case FSM_TYPE_RESOLVE_HOST: return "RESOLVE_HOST";
case FSM_TYPE_SOCKET_CONNECT: return "SOCKET_CONNECT";
case FSM_TYPE_SOCKET_SEND: return "SOCKET_SEND";
case FSM_TYPE_SOCKET_RECEIVE: return "SOCKET_RECEIVE";
case FSM_TYPE_SOCKET_QUERY_AVAILABLE: return "SOCKET_QUERY_AVAILABLE";
case FSM_TYPE_SECURE_CONNECT: return "SECURE_CONNECT";
case FSM_TYPE_SECURE_HANDSHAKE: return "SECURE_HANDSHAKE";
case FSM_TYPE_SECURE_NEGOTIATE: return "SECURE_NEGOTIATE";
case FSM_TYPE_NEGOTIATE_LOOP: return "NEGOTIATE_LOOP";
case FSM_TYPE_SECURE_SEND: return "SECURE_SEND";
case FSM_TYPE_SECURE_RECEIVE: return "SECURE_RECEIVE";
case FSM_TYPE_GET_CONNECTION: return "GET_CONNECTION";
case FSM_TYPE_HTTP_SEND_REQUEST: return "HTTP_SEND_REQUEST";
case FSM_TYPE_MAKE_CONNECTION: return "MAKE_CONNECTION";
case FSM_TYPE_OPEN_CONNECTION: return "OPEN_CONNECTION";
case FSM_TYPE_OPEN_PROXY_TUNNEL: return "OPEN_PROXY_TUNNEL";
case FSM_TYPE_SEND_REQUEST: return "SEND_REQUEST";
case FSM_TYPE_RECEIVE_RESPONSE: return "RECEIVE_RESPONSE";
case FSM_TYPE_HTTP_READ: return "HTTP_READ";
case FSM_TYPE_HTTP_WRITE: return "HTTP_WRITE";
case FSM_TYPE_READ_DATA: return "READ_DATA";
case FSM_TYPE_HTTP_QUERY_AVAILABLE: return "HTTP_QUERY_AVAILABLE";
case FSM_TYPE_DRAIN_RESPONSE: return "DRAIN_RESPONSE";
case FSM_TYPE_REDIRECT: return "REDIRECT";
case FSM_TYPE_READ_LOOP: return "READ_LOOP";
case FSM_TYPE_PARSE_HTTP_URL: return "PARSE_HTTP_URL";
case FSM_TYPE_PARSE_URL_FOR_HTTP: return "PARSE_URL_FOR_HTTP";
case FSM_TYPE_READ_FILE: return "READ_FILE";
case FSM_TYPE_READ_FILE_EX: return "READ_FILE_EX";
case FSM_TYPE_WRITE_FILE: return "WRITE_FILE";
case FSM_TYPE_QUERY_DATA_AVAILABLE: return "QUERY_DATA_AVAILABLE";
}
return "?";
}
#endif // INET_DEBUG
LPSTR MapState(IN DWORD State) {
switch (State) {
CASE_OF(FSM_STATE_BAD);
CASE_OF(FSM_STATE_INIT);
CASE_OF(FSM_STATE_WAIT);
CASE_OF(FSM_STATE_DONE);
CASE_OF(FSM_STATE_ERROR);
CASE_OF(FSM_STATE_CONTINUE);
CASE_OF(FSM_STATE_FINISH);
CASE_OF(FSM_STATE_1);
CASE_OF(FSM_STATE_2);
CASE_OF(FSM_STATE_3);
CASE_OF(FSM_STATE_4);
CASE_OF(FSM_STATE_5);
CASE_OF(FSM_STATE_6);
CASE_OF(FSM_STATE_7);
CASE_OF(FSM_STATE_8);
CASE_OF(FSM_STATE_9);
CASE_OF(FSM_STATE_10);
}
return "?";
}
Reference in New Issue View Git Blame Copy Permalink