able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/net/tcpip/driver/kdext/ipext.c

1213 lines
26 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
#include "precomp.h"
#pragma hdrstop
#include <tdint.h>
#include <arpdef.h>
#include <iprtdef.h>
#include <winsock.h>
#define ROUTE_TABLE_SIZE 32
FLAG_INFO FlagsNTE[] =
{
{ NTE_VALID, "NTE_Valid" },
{ NTE_COPY, "NTE_Copy" },
{ NTE_PRIMARY, "NTE_Primary" },
{ NTE_ACTIVE, "NTE_Active" },
{ NTE_DYNAMIC, "NTE_Dynamic" },
{ NTE_DHCP, "NTE_DHCP" },
{ NTE_DISCONNECTED, "NTE_Disconnected" },
{ NTE_TIMER_STARTED, "NTE_TimerStarted" },
{ NTE_IF_DELETING, "NTE_IF_Deleting" },
{ 0, NULL }
};
FLAG_INFO FlagsIF[] =
{
{ IF_FLAGS_P2P, "IF_Point_to_Point" },
{ IF_FLAGS_DELETING, "IF_Deleting" },
{ IF_FLAGS_NOIPADDR, "IF_NoIPAddr" },
{ IF_FLAGS_P2MP, "IF_P2MP" },
{ IF_FLAGS_REMOVING_POWER, "IF_REMOVING_POWER" },
{ IF_FLAGS_POWER_DOWN, "IF_POWER_DOWN" },
{ IF_FLAGS_REMOVING_DEVICE, "IF_REMOVING_DEVICE" },
{ IF_FLAGS_NOLINKBCST, "IF_FLAGS_NOLINKBCST" },
{ 0, NULL }
};
FLAG_INFO FlagsRCE[] =
{
{ RCE_VALID, "RCE_Valid" },
{ RCE_CONNECTED, "RCE_Connected" },
{ RCE_REFERENCED, "RCE_Referenced" },
{ RCE_DEADGW, "RCE_Deadgw" },
{ 0, NULL }
};
FLAG_INFO FlagsRTE[] =
{
{ RTE_VALID, "RTE_Valid" },
{ RTE_INCREASE, "RTE_Increase" },
{ RTE_IF_VALID, "RTE_If_Valid" },
{ RTE_DEADGW, "RTE_DeadGW" },
{ RTE_NEW, "RTE_New" },
{ 0, NULL }
};
VOID
DumpLog
(
);
DECLARE_API( dumplog )
{
DumpLog();
return;
}
VOID
DumpIPH(
ULONG IPH
);
DECLARE_API( IPH )
{
ULONG addressToDump = 0;
if ( *args ) {
sscanf(args, "%lx", &addressToDump);
}
DumpIPH( addressToDump );
return;
}
ULONG_PTR
DumpNTE(
ULONG NTEAddr,
VERBOSITY Verbosity
);
DECLARE_API( nte )
{
ULONG addressToDump = 0;
ULONG result;
if ( *args ) {
sscanf(args, "%lx", &addressToDump);
}
DumpNTE( addressToDump, VERBOSITY_NORMAL );
return;
}
ULONG_PTR
DumpInterface(
ULONG InterfaceAddr,
VERBOSITY Verbosity
);
DECLARE_API( interface )
{
ULONG addressToDump = 0;
ULONG result;
if ( *args ) {
sscanf(args, "%lx", &addressToDump);
}
DumpInterface( addressToDump, VERBOSITY_NORMAL );
return;
}
VOID
DumpIFList
(
VERBOSITY Verbosity
);
DECLARE_API( iflist )
{
char buf[128];
buf[0] = '\0';
if ( *args ) {
sscanf(args, "%s", buf);
}
if (buf[0] == '\0') {
dprintf( "VERBOSITY_NORMAL\n" );
DumpIFList( VERBOSITY_NORMAL );
} else {
dprintf( "VERBOSITY_FULL\n" );
DumpIFList( VERBOSITY_FULL );
}
return;
}
VOID
DumpNTEList
(
VERBOSITY Verbosity
);
DECLARE_API( ntelist )
{
char buf[128];
buf[0] = '\0';
if ( *args ) {
sscanf(args, "%s", buf);
}
if (buf[0] == '\0') {
dprintf( "VERBOSITY_NORMAL\n" );
DumpNTEList( VERBOSITY_NORMAL );
} else {
dprintf( "VERBOSITY_FULL\n" );
DumpNTEList( VERBOSITY_FULL );
}
return;
}
ULONG
DumpRCE(
ULONG RCEAddr,
VERBOSITY Verbosity
);
DECLARE_API( rce )
{
ULONG addressToDump = 0;
ULONG result;
if ( *args ) {
sscanf(args, "%lx", &addressToDump);
}
DumpRCE( addressToDump, VERBOSITY_NORMAL );
return;
}
ULONG
DumpRTE(
ULONG RTEAddr,
VERBOSITY Verbosity
);
DECLARE_API( rte )
{
ULONG addressToDump = 0;
ULONG result;
if ( *args ) {
sscanf(args, "%lx", &addressToDump);
}
DumpRTE( addressToDump, VERBOSITY_NORMAL );
return;
}
ULONG
DumpATE(
ULONG ATEAddr,
VERBOSITY Verbosity
);
DECLARE_API( ate )
{
ULONG addressToDump = 0;
ULONG result;
if ( *args ) {
sscanf(args, "%lx", &addressToDump);
}
DumpATE( addressToDump, VERBOSITY_NORMAL );
return;
}
ULONG
DumpAI(
ULONG AIAddr,
VERBOSITY Verbosity
);
DECLARE_API( ai )
{
ULONG addressToDump = 0;
ULONG result;
if ( *args ) {
sscanf(args, "%lx", &addressToDump);
}
DumpAI( addressToDump, VERBOSITY_NORMAL );
return;
}
VOID
DumpARPTable
(
ULONG ARPTableAddr,
VERBOSITY Verbosity
);
DECLARE_API( arptable )
{
ULONG addressToDump = 0;
ULONG result;
if ( *args ) {
sscanf(args, "%lx", &addressToDump);
}
DumpARPTable( addressToDump, VERBOSITY_NORMAL );
return;
}
#ifdef _obj
# undef _obj
# undef _objAddr
# undef _objType
# undef _objTypeName
#endif
#define _obj NTE
#define _objAddr NTEToDump
#define _objType NetTableEntry
#define _objTypeName "NetTableEntry"
ULONG_PTR
DumpNTE
(
ULONG _objAddr,
VERBOSITY Verbosity
)
/*++
Routine Description:
Dumps the fields of the specified DEVICE_CONTEXT structure
Arguments:
DeviceToDump - The device context object to display
Full - Display a partial listing if 0, full listing otherwise.
Return Value:
None
--*/
{
_objType _obj;
ULONG result;
unsigned int index;
BOOL bActive;
if ( !ReadMemory( _objAddr,
&_obj,
sizeof( _obj ),
&result ))
{
dprintf("%08lx: Could not read %s structure.\n", _objAddr, _objTypeName );
return(0);
}
if ( Verbosity == VERBOSITY_ONE_LINER )
{
dprintf( "NOT IMPLEMENTED" );
return(0);
}
dprintf( "%s @ %08lx\n", _objTypeName, _objAddr );
PrintStartStruct();
PrintFieldName( "nte_next" );
dprint_addr_list( ( ULONG_PTR )_obj.nte_next,
FIELD_OFFSET( _objType, nte_next ));
PrintIPAddress( nte_addr );
PrintIPAddress( nte_mask );
PrintPtr( nte_if );
PrintFieldName( "nte_ifnext" );
dprint_addr_list( ( ULONG_PTR )_obj.nte_ifnext,
FIELD_OFFSET( _objType, nte_ifnext ));
PrintFlags( nte_flags, FlagsNTE );
PrintUShort( nte_context );
PrintULong( nte_instance );
PrintPtr( nte_pnpcontext );
PrintLock( nte_lock );
PrintPtr( nte_ralist );
PrintPtr( nte_echolist );
PrintCTETimer( nte_timer );
PrintAddr( nte_timerblock );
PrintUShort( nte_mss );
PrintULong( nte_icmpseq );
PrintPtr( nte_igmplist );
PrintPtr( nte_addrhandle );
PrintIPAddress( nte_rtrdiscaddr );
PrintUChar( nte_rtrdiscstate );
PrintUChar( nte_rtrdisccount );
PrintUChar( nte_rtrdiscovery );
PrintUChar( nte_deleting );
PrintPtr( nte_rtrlist );
PrintULong( nte_igmpcount );
PrintEndStruct();
return( (ULONG_PTR)_obj.nte_next );
}
VOID
DumpNTEList
(
VERBOSITY Verbosity
)
{
ULONG Listlen=0;
ULONG NteAddr;
ULONG result;
NetTableEntry **NteList, **PreservedPtr;
ULONG_PTR CurrentNTE;
ULONG index;
ULONG NET_TABLE_SIZE;
NteAddr = GetUlongValue( "tcpip!NewNetTableList" );
NET_TABLE_SIZE = GetUlongValue( "tcpip!NET_TABLE_SIZE" );
NteList = malloc(sizeof( NetTableEntry * ) * NET_TABLE_SIZE);
if (NteList == NULL) {
dprintf("malloc failed\n");
return;
}
PreservedPtr = NteList;
// Listlen = GetUlongValue( "tcpip!NumNTE" );
if ( !ReadMemory( NteAddr,
&NteList[0],
4 * NET_TABLE_SIZE,
&result ))
{
dprintf("%08lx: Could not read the list.\n", NteAddr);
return;
}
for (index=0; index<NET_TABLE_SIZE; index++) {
CurrentNTE = (ULONG_PTR)NteList[index];
while (CurrentNTE) {
dprintf("The hash is %d \n", index);
CurrentNTE = DumpNTE(CurrentNTE, Verbosity );
Listlen++;
}
}
dprintf("total %d \n", Listlen);
free(NteList);
return;
}
#ifdef _obj
# undef _obj
# undef _objAddr
# undef _objType
# undef _objTypeName
#endif
#define _obj IF
#define _objAddr InterfaceToDump
#define _objType Interface
#define _objTypeName "Interface"
ULONG_PTR
DumpInterface
(
ULONG _objAddr,
VERBOSITY Verbosity
)
/*++
Routine Description:
Dumps the fields of the specified DEVICE_CONTEXT structure
Arguments:
DeviceToDump - The device context object to display
Full - Display a partial listing if 0, full listing otherwise.
Return Value:
None
--*/
{
_objType _obj;
ULONG result;
unsigned int index;
BOOL bActive;
if ( !ReadMemory( _objAddr,
&_obj,
sizeof( _obj ),
&result ))
{
dprintf("%08lx: Could not read %s structure.\n", _objAddr, _objTypeName );
return(0);
}
if ( Verbosity == VERBOSITY_ONE_LINER )
{
dprintf( "NOT IMPLEMENTED" );
return(0);
}
dprintf( "%s @ %08lx\n", _objTypeName, _objAddr );
PrintStartStruct();
PrintFieldName( "if_next" );
dprint_addr_list( ( ULONG_PTR )_obj.if_next,
FIELD_OFFSET( _objType, if_next ));
PrintPtr( if_lcontext );
PrintSymbolPtr( if_xmit );
PrintSymbolPtr( if_transfer );
PrintSymbolPtr( if_close );
PrintSymbolPtr( if_invalidate );
PrintSymbolPtr( if_addaddr );
PrintSymbolPtr( if_deladdr );
PrintSymbolPtr( if_qinfo );
PrintSymbolPtr( if_setinfo );
PrintSymbolPtr( if_getelist );
PrintSymbolPtr( if_dondisreq );
PrintSymbolPtr( if_dowakeupptrn );
PrintSymbolPtr( if_pnpcomplete );
PrintSymbolPtr( if_setndisrequest );
PrintSymbolPtr( if_arpresolveip );
PrintSymbolPtr( if_arpflushate );
PrintSymbolPtr( if_arpflushallate );
PrintULong( if_numgws );
for (index = 0; index < MAX_DEFAULT_GWS; index++) {
PrintIPAddress(if_gw[index]);
}
PrintUShort( if_rtrdiscovery );
PrintUShort( if_dhcprtrdiscovery );
PrintPtr( if_tdpacket );
PrintULong( if_index );
PrintULong( if_mediatype );
PrintUChar( if_accesstype );
PrintUChar( if_conntype );
PrintUChar( if_mcastttl );
PrintUChar( if_mcastflags );
PrintULong( if_lastupcall );
PrintULong( if_ntecount );
PrintFieldName( "if_nte" );
dprint_addr_list( ( ULONG_PTR )_obj.if_nte,
FIELD_OFFSET( NetTableEntry, nte_ifnext ));
PrintIPAddress( if_bcast );
PrintULong( if_mtu );
PrintULong( if_speed );
PrintFlags( if_flags, FlagsIF );
PrintULong( if_addrlen );
PrintPtr( if_addr );
PrintULong( IgmpVersion );
PrintULong( IgmpVer1Timeout );
PrintULong( IgmpVer2Timeout );
PrintULong( IgmpGeneralTimer );
PrintULong( if_refcount );
PrintPtr( if_block );
PrintPtr( if_pnpcontext );
PrintPtr( if_tdibindhandle );
PrintXULong( if_llipflags );
PrintAddr( if_configname );
PrintUString( if_configname );
PrintAddr( if_devname );
PrintUString( if_devname );
PrintAddr( if_name );
PrintUString( if_name );
PrintPtr( if_ipsecsniffercontext );
PrintLock( if_lock );
#if FFP_SUPPORT
PrintULong( if_ffpversion );
PrintULong( if_ffpdriver );
#endif
PrintULong( if_OffloadFlags ); // Checksum capability holder.
PrintULong( if_MaxOffLoadSize );
PrintULong( if_MaxSegments );
PrintAddr( if_TcpLargeSend );
PrintULong( if_TcpWindowSize );
PrintULong( if_TcpInitialRTT );
PrintULong( if_TcpDelAckTicks );
PrintULong( if_promiscuousmode ); // promiscuous mode or not
PrintULong( if_InitInProgress );
PrintPtr( if_link );
PrintSymbolPtr( if_closelink );
PrintULong( if_mediastatus );
PrintULong( if_iftype);
PrintUChar( if_absorbfwdpkts );
PrintULong( if_pnpcap );
PrintPtr( if_dampnext );
PrintULong( if_damptimer );
PrintULong( if_resetInProgress );
PrintEndStruct();
return( (ULONG_PTR)_obj.if_next );
}
VOID
DumpIFList
(
VERBOSITY Verbosity
)
{
ULONG Listlen;
ULONG_PTR IFAddr;
ULONG result;
IFAddr = GetUlongValue( "tcpip!IFList" );
Listlen = GetUlongValue( "tcpip!NumIF" );
dprintf("Dumping IFList @ %08lx\n",
IFAddr, Listlen );
while (IFAddr) {
IFAddr = DumpInterface(IFAddr, Verbosity );
}
return;
}
#ifdef _obj
# undef _obj
# undef _objAddr
# undef _objType
# undef _objTypeName
#endif
#define _obj RCE
#define _objAddr RCEToDump
#define _objType RouteCacheEntry
#define _objTypeName "RouteCacheEntry"
ULONG
DumpRCE
(
ULONG _objAddr,
VERBOSITY Verbosity
)
/*++
Routine Description:
Dumps the fields of the specified DEVICE_CONTEXT structure
Arguments:
DeviceToDump - The device context object to display
Full - Display a partial listing if 0, full listing otherwise.
Return Value:
None
--*/
{
_objType _obj;
ULONG result;
unsigned int index;
BOOL bActive;
if ( !ReadMemory( _objAddr,
&_obj,
sizeof( _obj ),
&result ))
{
dprintf("%08lx: Could not read %s structure.\n", _objAddr, _objTypeName );
return(0);
}
if ( Verbosity == VERBOSITY_ONE_LINER )
{
dprintf( "NOT IMPLEMENTED" );
return(0);
}
dprintf( "%s @ %08lx\n", _objTypeName, _objAddr );
PrintStartStruct();
PrintFieldName( "rce_next" );
dprint_addr_list( ( ULONG_PTR )_obj.rce_next,
FIELD_OFFSET( _objType, rce_next ));
PrintPtr( rce_rte );
PrintIPAddress( rce_dest );
PrintIPAddress( rce_src );
PrintFlags( rce_flags, FlagsRCE );
PrintUChar( rce_dtype );
PrintULong( rce_usecnt );
PrintPtr( rce_context[0] );
PrintPtr( rce_context[1] );
PrintLock( rce_lock );
PrintULong ( rce_OffloadFlags ); // interface chksum capability flags
PrintAddr( rce_TcpLargeSend );
PrintULong( rce_TcpWindowSize );
PrintULong( rce_TcpInitialRTT );
PrintULong( rce_TcpDelAckTicks );
PrintULong( rce_cnt );
PrintULong( rce_mediaspeed );
PrintEndStruct();
return( (ULONG_PTR)_obj.rce_next );
}
#ifdef _obj
# undef _obj
# undef _objAddr
# undef _objType
# undef _objTypeName
#endif
#define _obj RTE
#define _objAddr RTEToDump
#define _objType RouteTableEntry
#define _objTypeName "RouteTableEntry"
ULONG
DumpRTE
(
ULONG _objAddr,
VERBOSITY Verbosity
)
/*++
Routine Description:
Dumps the fields of the specified DEVICE_CONTEXT structure
Arguments:
DeviceToDump - The device context object to display
Full - Display a partial listing if 0, full listing otherwise.
Return Value:
None
--*/
{
_objType _obj;
ULONG result;
unsigned int index;
BOOL bActive;
if ( !ReadMemory( _objAddr,
&_obj,
sizeof( _obj ),
&result ))
{
dprintf("%08lx: Could not read %s structure.\n", _objAddr, _objTypeName );
return(0);
}
if ( Verbosity == VERBOSITY_ONE_LINER )
{
dprintf( "NOT IMPLEMENTED" );
return(0);
}
dprintf( "%s @ %08lx\n", _objTypeName, _objAddr );
PrintStartStruct();
PrintFieldName( "rte_next" );
dprint_addr_list( ( ULONG_PTR )_obj.rte_next,
FIELD_OFFSET( _objType, rte_next ));
PrintIPAddress( rte_dest );
PrintIPAddress( rte_mask );
PrintIPAddress( rte_addr );
PrintPtr( rte_rcelist );
PrintPtr( rte_if );
PrintULong( rte_priority );
PrintULong( rte_metric );
PrintULong( rte_mtu );
PrintUShort( rte_type );
PrintFlags( rte_flags, FlagsRTE );
PrintULong( rte_admintype );
PrintULong( rte_proto );
PrintULong( rte_valid );
PrintULong( rte_mtuchange );
PrintPtr( rte_context );
PrintPtr( rte_arpcontext[0] );
PrintPtr( rte_arpcontext[1] );
PrintPtr( rte_todg );
PrintPtr( rte_fromdg );
PrintULong( rte_rces );
PrintPtr( rte_link );
PrintPtr( rte_nextlinkrte );
PrintEndStruct();
return( (ULONG_PTR)_obj.rte_next );
}
#ifdef _obj
# undef _obj
# undef _objAddr
# undef _objType
# undef _objTypeName
#endif
#define _obj ATE
#define _objAddr ATEToDump
#define _objType ARPTableEntry
#define _objTypeName "ARPTableEntry"
ULONG
DumpATE
(
ULONG _objAddr,
VERBOSITY Verbosity
)
/*++
Routine Description:
Dumps the fields of the specified DEVICE_CONTEXT structure
Arguments:
DeviceToDump - The device context object to display
Full - Display a partial listing if 0, full listing otherwise.
Return Value:
None
--*/
{
_objType _obj;
ULONG result;
unsigned int index;
BOOL bActive;
UCHAR MacAddr[ARP_802_ADDR_LENGTH];
if ( !ReadMemory( _objAddr,
&_obj,
sizeof( _obj ),
&result ))
{
dprintf("%08lx: Could not read %s structure.\n", _objAddr, _objTypeName );
return(0);
}
if ( Verbosity == VERBOSITY_ONE_LINER )
{
dprintf( "NOT IMPLEMENTED" );
return(0);
}
dprintf( "%s @ %08lx\n", _objTypeName, _objAddr );
PrintStartStruct();
PrintFieldName( "ate_next" );
dprint_addr_list( ( ULONG_PTR )_obj.ate_next,
FIELD_OFFSET( _objType, ate_next ));
PrintULong( ate_valid );
PrintIPAddress( ate_dest );
PrintPtr( ate_packet );
PrintPtr( ate_rce );
PrintLock( ate_lock );
PrintULong( ate_useticks );
PrintUChar( ate_addrlength );
PrintUChar( ate_state );
PrintULong( ate_userarp );
PrintPtr( ate_resolveonly );
PrintAddr( ate_addr );
if ( !ReadMemory( AddressOf( ate_addr ),
&MacAddr,
sizeof( MacAddr ),
&result ))
{
dprintf("%08lx: Could not read %s structure.\n", _objAddr, _objTypeName );
return(0);
}
PrintMacAddr( ate_addr, MacAddr );
PrintEndStruct();
return( (ULONG)_obj.ate_next );
}
#ifdef _obj
# undef _obj
# undef _objAddr
# undef _objType
# undef _objTypeName
#endif
#define _obj AI
#define _objAddr AIToDump
#define _objType ARPInterface
#define _objTypeName "ARPInterface"
ULONG
DumpAI
(
ULONG _objAddr,
VERBOSITY Verbosity
)
/*++
Routine Description:
Dumps the fields of the specified DEVICE_CONTEXT structure
Arguments:
DeviceToDump - The device context object to display
Full - Display a partial listing if 0, full listing otherwise.
Return Value:
None
--*/
{
_objType _obj;
ULONG result;
unsigned int index;
BOOL bActive;
if ( !ReadMemory( _objAddr,
&_obj,
sizeof( _obj ),
&result ))
{
dprintf("%08lx: Could not read %s structure.\n", _objAddr, _objTypeName );
return(0);
}
if ( Verbosity == VERBOSITY_ONE_LINER )
{
dprintf( "NOT IMPLEMENTED" );
return(0);
}
dprintf( "%s @ %08lx\n", _objTypeName, _objAddr );
PrintStartStruct();
PrintLL( ai_linkage );
PrintPtr( ai_context );
#if FFP_SUPPORT
PrintPtr( ai_driver );
#endif
PrintPtr( ai_handle );
PrintULong( ai_media );
PrintPtr( ai_ppool );
PrintLock( ai_lock );
PrintLock( ai_ARPTblLock );
PrintPtr( ai_ARPTbl );
PrintAddr( ai_ipaddr );
PrintPtr( ai_parpaddr );
PrintIPAddress( ai_bcast );
PrintULong( ai_inoctets );
PrintULong( ai_inpcount[0] );
PrintULong( ai_inpcount[1] );
PrintULong( ai_inpcount[2] );
PrintULong( ai_outoctets );
PrintULong( ai_outpcount[0] );
PrintULong( ai_outpcount[1] );
PrintULong( ai_qlen );
PrintMacAddr( ai_addr, _obj.ai_addr );
PrintUChar( ai_state );
PrintUChar( ai_addrlen );
PrintXUChar( ai_bcastmask );
PrintXUChar( ai_bcastval );
PrintUChar( ai_bcastoff );
PrintUChar( ai_hdrsize );
PrintUChar( ai_snapsize );
PrintUChar( ai_pad[0] );
PrintUChar( ai_pad[1] );
PrintULong( ai_pfilter );
PrintULong( ai_count );
PrintULong( ai_parpcount );
PrintCTETimer( ai_timer );
PrintBool( ai_timerstarted );
PrintBool( ai_stoptimer );
PrintAddr( ai_timerblock );
PrintAddr( ai_block );
PrintUShort( ai_mtu );
PrintUChar( ai_adminstate );
PrintUChar( ai_operstate );
PrintULong( ai_speed );
PrintULong( ai_lastchange );
PrintULong( ai_indiscards );
PrintULong( ai_inerrors );
PrintULong( ai_uknprotos );
PrintULong( ai_outdiscards );
PrintULong( ai_outerrors );
PrintULong( ai_desclen );
PrintULong( ai_index );
PrintULong( ai_ifinst );
PrintULong( ai_atinst );
PrintPtr( ai_desc );
PrintPtr( ai_mcast );
PrintULong( ai_mcastcnt );
PrintULong( ai_ipaddrcnt );
PrintULong( ai_telladdrchng );
PrintULong( ai_promiscuous );
#if FFP_SUPPORT
PrintULong( ai_ffpversion );
PrintULong( ai_ffplastflush );
#endif
PrintULong ( ai_OffloadFlags ); // H/W checksum capability flag
PrintAddr ( ai_TcpLargeSend );
PrintULong( ai_wakeupcap );
PrintUShort( ai_devicename.Length );
PrintUShort( ai_devicename.MaximumLength );
PrintPtr( ai_devicename.Buffer );
PrintEndStruct();
return(0);
}
VOID
DumpARPTable
(
ULONG ARPTableAddr,
VERBOSITY Verbosity
)
{
ARPTableEntry **ARPTable, **PreservedPtr;
ARPInterface AI;
LIST_ENTRY *ALE;
LIST_ENTRY ArpListEntry;
ULONG_PTR AIList;
ULONG ATE;
ULONG TabAddr;
ULONG TabLen;
ULONG result;
UINT index;
UINT count = 0;
if (ARPTableAddr)
{
//
// ARPTable address given: dump all ARPTableEntry's starting from
// that address
//
TabAddr = ARPTableAddr;
TabLen = ARP_TABLE_SIZE;
dprintf("Dumping ARPTable @ %08lx - maximum ARPTableSize = %08lx\n", TabAddr, TabLen);
ARPTable = malloc(sizeof(ARPTableEntry *) * TabLen);
if (ARPTable == NULL) {
dprintf("malloc failed in DumpARPTable.\n");
return;
}
PreservedPtr = ARPTable;
if (!ReadMemory(TabAddr,
&ARPTable[0],
sizeof(ARPTableEntry *) * TabLen,
&result))
{
dprintf("%08lx: Could not read %s structure.\n", TabAddr, "ARPTable");
free(ARPTable);
return;
}
for (index = 0; index < TabLen; index++) {
if (*ARPTable != NULL) {
ATE = (ULONG_PTR)*ARPTable;
while (ATE) {
ATE = DumpATE(ATE, Verbosity);
count++;
}
}
ARPTable++;
}
dprintf("\n %d Active ARPTable entries.\n", count);
free(PreservedPtr);
} else {
//
// ARPTable address not given, dump all ARPTableEntry's using
// ARPTable found in ARPInterface
//
AIList = GetExpression("tcpip!ArpInterfaceList");
if (!ReadMemory(AIList,
&ArpListEntry,
sizeof(LIST_ENTRY),
&result))
{
dprintf("%08lx: Could not read %s structure.\n",
AIList,
"LIST_ENTRY");
return;
}
ALE = ArpListEntry.Flink;
while (ALE != (PLIST_ENTRY)AIList) {
if (!ReadMemory((ULONG_PTR)ALE,
&ArpListEntry,
sizeof(LIST_ENTRY),
&result))
{
dprintf("%08lx: Could not read %s structure.\n",
ALE,
"LIST_ENTRY");
return;
}
if (!ReadMemory((ULONG_PTR)STRUCT_OF(ARPInterface, ALE, ai_linkage),
&AI,
sizeof(ARPInterface),
&result))
{
dprintf("%08lx: Could not read %s structure.\n",
STRUCT_OF(ARPInterface, ALE, ai_linkage),
"ArpInterface");
return;
}
//
// check address before making the recursive call to avoid
// loop if one ARPInterface has no ARPTable
//
if (AI.ai_ARPTbl) {
DumpARPTable((ULONG_PTR)AI.ai_ARPTbl, Verbosity);
}
ALE = ArpListEntry.Flink;
}
}
return;
}
VOID
DumpLog
(
)
{
#if 0 // Currently, there is no such log support in tcpip
ULONG LogAddr;
UCHAR TraceBuffer[TRACE_BUFFER_SIZE]; //80 * 128;
int result;
int i;
LogAddr = GetUlongValue( "tcpip!IPTraceBuffer" );
if (!LogAddr) {
dprintf("Error in tcpip!IPTraceBuffer: Please try reload\n");
return;
}
dprintf("Dumping IP Log @ %08lx \n",LogAddr);
if ( !ReadMemory( LogAddr,
&TraceBuffer[0],
sizeof(UCHAR) * TRACE_BUFFER_SIZE,
&result ))
{
dprintf("%08lx: Could not read log\n", LogAddr);
return;
}
for (i=0; i <INDEX_LIMIT; i++)
dprintf("%s", &TraceBuffer[i*TRACE_STRING_LENGTH]);
#else
return;
#endif
}
#ifdef _obj
# undef _obj
# undef _objAddr
# undef _objType
# undef _objTypeName
#endif
#define _obj IPH
#define _objAddr IPHToDump
#define _objType IPHeader
#define _objTypeName "IPHeader"
VOID
DumpIPH(
ULONG _objAddr
)
/*++
Routine Description:
Dumps the fields of the specified DEVICE_CONTEXT structure
Arguments:
DeviceToDump - The device context object to display
Full - Display a partial listing if 0, full listing otherwise.
Return Value:
None
--*/
{
_objType _obj;
ULONG result;
unsigned int index;
BOOL bActive;
if ( !ReadMemory( _objAddr,
&_obj,
sizeof( _obj ),
&result ))
{
dprintf("%08lx: Could not read %s structure.\n", _objAddr, _objTypeName );
return;
}
dprintf( "%s @ %08lx\n", _objTypeName, _objAddr );
PrintStartStruct();
PrintUChar(iph_verlen);
PrintUChar(iph_tos);
PrintIPAddress(iph_src);
PrintIPAddress(iph_dest)
PrintEndStruct();
return;
}
Reference in a new issue Copy permalink