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

2168 lines
50 KiB
C
Raw Permalink Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1993 Microsoft Corporation
Module Name:
ipxext.c
Abstract:
This file contains kernel debugger extensions for examining the
IPX structures.
Author:
Heath Hunnicutt (T-HeathH) 3-Aug-1995
Environment:
User Mode
--*/
#include "precomp.h"
#pragma hdrstop
#include "config.h"
#include "mac.h"
#include "ipxtypes.h"
#define LIMIT_BINDINGS 25
//
// Local function prototypes
//
VOID DumpDeviceObject
(
ULONG DevObjToDump,
VERBOSITY Verbosity
);
VOID
DumpIpxDevice
(
ULONG DeviceToDump,
VERBOSITY Verbosity
);
VOID
DumpIpxSend
(
ULONG IpxSendToDump,
VERBOSITY Verbosity
);
VOID
DumpIpxReceive
(
ULONG IpxReceiveToDump,
VERBOSITY Verbosity
);
VOID
DumpIpxAddress
(
ULONG AddressToDump,
VERBOSITY Verbosity
);
VOID
DumpIpxAddressFile
(
ULONG AddressFileToDump,
VERBOSITY Verbosity
);
VOID
DumpIpxBinding
(
ULONG BindingToDump,
VERBOSITY Verbosity
);
VOID
DumpIpxRouterSegment
(
ULONG SegmentToDump,
VERBOSITY Verbosity
);
VOID
DumpIpxRequest
(
ULONG RequestToDump,
VERBOSITY Verbosity
);
VOID
DumpIpxAdapter
(
ULONG AdapterToDump,
VERBOSITY Verbosity
);
VOID
DumpIpxIrpStack
(
PREQUEST pRequest,
VERBOSITY Verbosity
);
ENUM_INFO EnumIrpMajorFunction[] =
{
EnumString( IRP_MJ_CREATE ),
EnumString( IRP_MJ_CREATE_NAMED_PIPE ),
EnumString( IRP_MJ_CLOSE ),
EnumString( IRP_MJ_READ ),
EnumString( IRP_MJ_WRITE ),
EnumString( IRP_MJ_QUERY_INFORMATION ),
EnumString( IRP_MJ_SET_INFORMATION ),
EnumString( IRP_MJ_QUERY_EA ),
EnumString( IRP_MJ_SET_EA ),
EnumString( IRP_MJ_FLUSH_BUFFERS ),
EnumString( IRP_MJ_QUERY_VOLUME_INFORMATION ),
EnumString( IRP_MJ_SET_VOLUME_INFORMATION ),
EnumString( IRP_MJ_DIRECTORY_CONTROL ),
EnumString( IRP_MJ_FILE_SYSTEM_CONTROL ),
EnumString( IRP_MJ_DEVICE_CONTROL ),
EnumString( IRP_MJ_INTERNAL_DEVICE_CONTROL ),
EnumString( IRP_MJ_SHUTDOWN ),
EnumString( IRP_MJ_LOCK_CONTROL ),
EnumString( IRP_MJ_CLEANUP ),
EnumString( IRP_MJ_CREATE_MAILSLOT ),
EnumString( IRP_MJ_QUERY_SECURITY ),
EnumString( IRP_MJ_SET_SECURITY ),
EnumString( IRP_MJ_POWER ),
// EnumString( IRP_MJ_SYSTEM_CONTROL ),
EnumString( IRP_MJ_DEVICE_CHANGE ),
EnumString( IRP_MJ_QUERY_QUOTA ),
EnumString( IRP_MJ_SET_QUOTA ),
{ 0, NULL }
};
ENUM_INFO EnumIrpMinorFunction[ IRP_MJ_MAXIMUM_FUNCTION + 1 ][ 18 ] =
{
{{ 0, NULL}}, // IRP_MJ_CREATE
{{ 0, NULL}}, // IRP_MJ_CREATE_NAMED_PIPE
{{ 0, NULL}}, // IRP_MJ_CLOSE
{{ 0, NULL}}, // IRP_MJ_READ
{{ 0, NULL}}, // IRP_MJ_WRITE
{{ 0, NULL}}, // IRP_MJ_QUERY_INFORMATION
{{ 0, NULL}}, // IRP_MJ_SET_INFORMATION
{{ 0, NULL}}, // IRP_MJ_QUERY_EA
{{ 0, NULL}}, // IRP_MJ_SET_EA
{{ 0, NULL}}, // IRP_MJ_FLUSH_BUFFERS
{{ 0, NULL}}, // IRP_MJ_QUERY_VOLUME_INFORMATION
{{ 0, NULL}}, // IRP_MJ_SET_VOLUME_INFORMATION
{{ 0, NULL}}, // IRP_MJ_DIRECTORY_CONTROL
{{ 0, NULL}}, // IRP_MJ_FILE_SYSTEM_CONTROL
{{ 0, NULL}}, // IRP_MJ_DEVICE_CONTROL
{ // IRP_MJ_INTERNAL_DEVICE_CONTROL
EnumString( TDI_ASSOCIATE_ADDRESS ),
EnumString( TDI_DISASSOCIATE_ADDRESS ),
EnumString( TDI_CONNECT ),
EnumString( TDI_LISTEN ),
EnumString( TDI_ACCEPT ),
EnumString( TDI_DISCONNECT ),
EnumString( TDI_SEND ),
EnumString( TDI_RECEIVE ),
EnumString( TDI_SEND_DATAGRAM ),
EnumString( TDI_RECEIVE_DATAGRAM ),
EnumString( TDI_SET_EVENT_HANDLER ),
EnumString( TDI_QUERY_INFORMATION ),
EnumString( TDI_SET_INFORMATION ),
EnumString( TDI_ACTION ),
EnumString( TDI_DIRECT_SEND ),
EnumString( TDI_DIRECT_SEND_DATAGRAM ),
{ 0, NULL }
},
{{ 0, NULL}}, // IRP_MJ_SHUTDOWN
{{ 0, NULL}}, // IRP_MJ_LOCK_CONTROL
{{ 0, NULL}}, // IRP_MJ_CLEANUP
{{ 0, NULL}}, // IRP_MJ_CREATE_MAILSLOT
{{ 0, NULL}}, // IRP_MJ_QUERY_SECURITY
{{ 0, NULL}}, // IRP_MJ_SET_SECURITY
{{ 0, NULL}}, // IRP_MJ_QUERY_POWER
{{ 0, NULL}}, // IRP_MJ_SET_POWER
{{ 0, NULL}}, // IRP_MJ_DEVICE_CHANGE
{{ 0, NULL}}, // IRP_MJ_QUERY_QUOTA
{{ 0, NULL}}, // IRP_MJ_SET_QUOTA
};
ENUM_INFO EnumAddressFileState[] =
{
EnumString( ADDRESSFILE_STATE_OPENING ),
EnumString( ADDRESSFILE_STATE_OPEN ),
EnumString( ADDRESSFILE_STATE_CLOSING ),
{ 0, NULL }
};
ENUM_INFO EnumBindingFrameType[] =
{
EnumString( ISN_FRAME_TYPE_802_2 ),
EnumString( ISN_FRAME_TYPE_802_3 ),
EnumString( ISN_FRAME_TYPE_ETHERNET_II ),
EnumString( ISN_FRAME_TYPE_SNAP ),
{ 0, NULL }
};
ENUM_INFO EnumSendReservedIdentifier[] =
{
EnumString( IDENTIFIER_NB ),
EnumString( IDENTIFIER_SPX ),
EnumString( IDENTIFIER_RIP ),
EnumString( IDENTIFIER_IPX ),
EnumString( IDENTIFIER_RIP_INTERNAL ),
EnumString( IDENTIFIER_RIP_RESPONSE ),
{ 0, NULL }
};
ENUM_INFO EnumSendReservedDestinationType[] =
{
EnumString( DESTINATION_DEF ),
EnumString( DESTINATION_BCAST ),
EnumString( DESTINATION_MCAST ),
{ 0, NULL }
};
FLAG_INFO FlagsRouteEntry[] =
{
{IPX_ROUTER_PERMANENT_ENTRY,"Permanent"},
{IPX_ROUTER_LOCAL_NET,"Local Net"},
{IPX_ROUTER_SCHEDULE_ROUTE, "Call Schedule Route"},
{IPX_ROUTER_GLOBAL_WAN_NET,"Global Wan Net"},
{0, NULL}
};
MEMBER_TABLE IpxDeviceMembers[] =
{
{ "GlobalSendPacketList",
FIELD_OFFSET( DEVICE, GlobalSendPacketList ),
DumpIpxSend,
NextListEntry,
PrevListEntry,
FIELD_OFFSET( NDIS_PACKET, ProtocolReserved ) + FIELD_OFFSET( IPX_SEND_RESERVED, GlobalLinkage )
},
{ "GlobalReceivePacketList",
FIELD_OFFSET( DEVICE, GlobalReceivePacketList ),
DumpIpxReceive,
NextListEntry,
PrevListEntry,
FIELD_OFFSET( NDIS_PACKET, ProtocolReserved ) + FIELD_OFFSET( IPX_RECEIVE_RESERVED, GlobalLinkage )
},
{ NULL }
};
///////////////////////////////////////////////////////////////////////
// DEVICE
//////////////////////////////////////////////////////////////////////
//
// Exported functions
//
VOID ipxdev_usage( VOID )
{
dprintf( "Use me!\n" );
}
DECLARE_API( ipxdev )
/*++
Routine Description:
Dumps the most important fields of the specified DEVICE_CONTEXT object
Arguments:
args - Address
Return Value:
None
--*/
{
ULONG deviceToDump = 0;
ULONG pDevice = 0;
ULONG result;
char VarName[ MAX_LIST_VARIABLE_NAME_LENGTH + 1 ];
MEMBER_VARIABLE_INFO MemberInfo;
BOOL bFocusOnMemberVariable = FALSE;
if ( *args )
{
bFocusOnMemberVariable = ReadArgsForTraverse( args, VarName );
}
if ( *args && *args!='-' )
{
if (!sscanf(args, "%lx", &deviceToDump))
{
return;
}
}
if ( deviceToDump == 0 ) {
pDevice = GetExpression( "nwlnkipx!IpxDevice" );
if ( !pDevice ) {
dprintf("Could not get nwlnkipx!IpxDevice, Try !reload\n");
return;
} else {
if (!ReadMemory(pDevice,
&deviceToDump,
sizeof(deviceToDump),
&result
)
)
{
dprintf("%08lx: Could not read device address\n", pDevice);
return;
}
}
}
if ( bFocusOnMemberVariable )
{
if ( !LocateMemberVariable( "IpxDevice", VarName, ( PVOID )deviceToDump, &MemberInfo ))
{
return;
}
WriteMemberInfo( &MemberInfo );
next( hCurrentProcess, hCurrentThread, dwCurrentPc, dwProcessor, "" );
return;
}
DumpIpxDevice(deviceToDump, VERBOSITY_NORMAL );
return;
}
#ifdef _obj
# undef _obj
# undef _objAddr
# undef _objType
#endif
#define _obj Device
#define _objAddr DeviceToDump
#define _objType DEVICE
//
// Local functions
//
VOID
DumpIpxDevice
(
ULONG DeviceToDump,
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
--*/
{
DEVICE Device;
ULONG result;
unsigned int index;
BIND_ARRAY_ELEM Bindings[ LIMIT_BINDINGS ];
WCHAR Buffer[ 1000 ];
PWCHAR pDeviceName = NULL;
if (!ReadMemory(
DeviceToDump,
&Device,
sizeof(Device),
&result
)
)
{
dprintf("%08lx: Could not read device context\n", DeviceToDump);
return;
}
if (Device.Type != IPX_DEVICE_SIGNATURE)
{
dprintf( "Signature does not match, probably not a device object %lx\n", DeviceToDump);
dprintf( "Device.Type == %04X, and I think it should be %04X\n", Device.Type, IPX_DEVICE_SIGNATURE );
dprintf( "DeviceToDump = %08X\n", DeviceToDump );
dprintf( "Offset to Device.Type = %d\n", FIELD_OFFSET( DEVICE, Type ) );
return;
}
if ( !ReadMemory( ( ULONG )Device.DeviceName,
Buffer,
sizeof( WCHAR ) * Device.DeviceNameLength,
&result ))
{
dprintf("%08lx: Could not read device name buffer\n", Device.DeviceName );
}
else
{
pDeviceName = Buffer;
}
if ( Verbosity == VERBOSITY_ONE_LINER )
{
dprintf( "\"%S\"", pDeviceName );
return;
}
dprintf("Device General Info ");
PrintStartStruct();
#if DBG
# if DREF_TOTAL != 13
# error The DREF_TOTAL constant has changed, and so must ipxext.c
# endif
PrintULong( RefTypes[ DREF_CREATE ] );
PrintULong( RefTypes[ DREF_LOADED ] );
PrintULong( RefTypes[ DREF_ADAPTER ] );
PrintULong( RefTypes[ DREF_ADDRESS ] );
PrintULong( RefTypes[ DREF_SR_TIMER ] );
PrintULong( RefTypes[ DREF_RIP_TIMER ] );
PrintULong( RefTypes[ DREF_LONG_TIMER ] );
PrintULong( RefTypes[ DREF_RIP_PACKET ] );
PrintULong( RefTypes[ DREF_ADDRESS_NOTIFY ] );
PrintULong( RefTypes[ DREF_LINE_CHANGE ] );
PrintULong( RefTypes[ DREF_NIC_NOTIFY ] );
PrintULong( RefTypes[ DREF_BINDING ] );
PrintULong( RefTypes[ DREF_PNP ] );
#endif
PrintEnum( Type, EnumStructureType );
PrintUShort( Size );
#if DBG
PrintNChar( Signature1, sizeof( Device.Signature1 ));
#endif
PrintLock( Interlock );
PrintULong( TempDatagramBytesSent );
PrintULong( TempDatagramsSent );
PrintULong( TempDatagramBytesReceived );
PrintULong( TempDatagramsReceived );
PrintBool( EthernetPadToEven );
PrintBool( SingleNetworkActive );
PrintBool( DisableDialoutSap );
PrintBool( MultiCardZeroVirtual );
PrintLock( Lock );
PrintULong( ReferenceCount );
PrintStartStruct();
dprintf( " ( We are assumed not to be at init time )\n" );
PrintUShort( MaxBindings );
if ( Device.MaxBindings > LIMIT_BINDINGS )
{
dprintf(" isnext can only display the first %d bindings, because malloc() always crashed under the kernel debugger.\n", LIMIT_BINDINGS );
dprintf(" This device struct has more bindings than that, but you're only going to see some of them.\n" );
dprintf(" You could always change LIMIT_BINDINGS in ipxext.c and recompile isnext\n" );
Device.MaxBindings = LIMIT_BINDINGS;
}
if ( !ReadMemory( ( ULONG )Device.Bindings,
Bindings,
((sizeof( PBIND_ARRAY_ELEM )) * Device.MaxBindings),
&result ) )
{
dprintf( "Could not read Bindings array.\n" );
}
else
{
for( index = LOOPBACK_NIC_ID; index <= Device.MaxBindings; index ++ )
{
if ( Bindings[ index ].Binding != NULL )
{
dprintf( " Bindings[ %d ] = %-10X", index, Bindings[ index ].Binding );
DumpIpxBinding( ( ULONG )Bindings[ index ].Binding, VERBOSITY_ONE_LINER );
dprintf( "\n" );
}
}
}
PrintEndStruct();
PrintUShort( ValidBindings );
PrintUShort( HighestExternalNicId );
PrintUShort( SapNicCount );
PrintUShort( HighestType20NicId );
PrintUShort( HighestLanNicId);
PrintLL( GlobalSendPacketList );
PrintLL( GlobalReceivePacketList );
PrintLL( GlobalReceiveBufferList );
PrintLL( AddressNotifyQueue );
PrintLL( LineChangeQueue );
PrintLL( SendPoolList );
PrintLL( ReceivePoolList );
PrintL( SendPacketList );
PrintL( ReceivePacketList );
PrintUChar( State );
PrintUChar( FrameTypeDefault );
PrintBool( ActiveNetworkWan );
PrintBool( VirtualNetwork );
PrintUShort( FirstLanNicId );
PrintUShort( FirstWanNicId );
PrintULong( MemoryUsage );
PrintULong( MemoryLimit );
PrintULong( AllocatedDatagrams );
PrintULong( AllocatedReceivePackets );
PrintULong( AllocatedPaddingBuffers );
PrintULong( InitDatagrams );
PrintULong( MaxDatagrams );
PrintULong( RipAgeTime );
PrintULong( RipCount );
PrintULong( RipTimeout );
PrintULong( RipUsageTime );
PrintULong( SourceRouteUsageTime );
PrintUShort( SocketStart );
PrintUShort( SocketEnd );
PrintULong( SocketUniqueness );
PrintULong( VirtualNetworkNumber );
PrintULong( EthernetExtraPadding );
PrintBool( DedicatedRouter );
PrintBool( VirtualNetworkOptional );
PrintUChar( DisableDialinNetbios );
PrintULong( InitReceivePackets );
PrintULong( InitReceiveBuffers );
PrintULong( MaxReceivePackets );
PrintULong( MaxReceiveBuffers );
PrintUShort( ControlChannelIdentifier );
PrintUShort( CurrentSocket );
PrintULong( SegmentCount );
// MORE - dump actual locks
PrintPtr( SegmentLocks );
PrintPtr(Segments);
for( index = 0; index < Device.SegmentCount; index++ ) {
DumpIpxRouterSegment((ULONG)&Device.Segments[index], VERBOSITY_NORMAL);
}
PrintLL( WaitingRipPackets );
PrintULong( RipPacketCount );
PrintBool( RipShortTimerActive );
PrintUShort( RipSendTime );
PrintCTETimer( RipShortTimer );
PrintCTETimer( RipLongTimer );
PrintBool( SourceRoutingUsed ); // TRUE if any 802.5 bindings exist.
PrintUChar( SourceRoutingTime ); // incremented each time timer fires.
PrintCTETimer( SourceRoutingTimer );
PrintULong( LinkSpeed );
PrintULong( MacOptions );
PrintULong( IncludedHeaderOffset );
PrintTDIAddress( SourceAddress );
#if IPX_ADDRESS_HASH_COUNT != 16
# error An assumption is made here concerning the value of IPX_ADDRESS_HASH_COUNT
#endif
PrintLL( AddressDatabases[ 0 ] );
PrintLL( AddressDatabases[ 1 ] );
PrintLL( AddressDatabases[ 2 ] );
PrintLL( AddressDatabases[ 3 ] );
PrintLL( AddressDatabases[ 4 ] );
PrintLL( AddressDatabases[ 5 ] );
PrintLL( AddressDatabases[ 6 ] );
PrintLL( AddressDatabases[ 7 ] );
PrintLL( AddressDatabases[ 8 ] );
PrintLL( AddressDatabases[ 9 ] );
PrintLL( AddressDatabases[ 10 ] );
PrintLL( AddressDatabases[ 11 ] );
PrintLL( AddressDatabases[ 12 ] );
PrintLL( AddressDatabases[ 13 ] );
PrintLL( AddressDatabases[ 14 ] );
PrintLL( AddressDatabases[ 15 ] );
PrintPtr( LastAddress );
PrintPtr( NdisBufferPoolHandle );
PrintAddr( Information );
PrintULong( RealMaxDatagramSize );
#if DBG
PrintNChar( Signature2, sizeof( Device.Signature2 ));
#endif
PrintFlushLeft();
PrintBool( AnyUpperDriverBound );
PrintBool( ForwarderBound );
if ( Device.AnyUpperDriverBound )
{
for ( index = 0; index < UPPER_DRIVER_COUNT; index ++ )
{
PrintFlushLeft();
dprintf( "UpperDriver...[ %d ] = ", index );
PrintStartStruct();
PrintFieldName( "UpperDriverBound" );
PrintRawBool( UpperDriverBound[ index ] );
if ( !Device.UpperDriverBound[ index ] )
{
PrintEndStruct();
continue;
}
PrintFieldName( "ReceiveCompletePending" );
PrintRawBool( ReceiveCompletePending[ index ] );
PrintPtr( UpperDriverControlChannel[ index ] );
PrintSymbolPtr( UpperDrivers[ index ].ReceiveHandler );
PrintEndStruct();
}
}
PrintFlushLeft();
PrintULong( EnableBroadcastCount );
PrintBool( EnableBroadcastPending );
PrintBool( DisableBroadcastPending );
PrintBool( ReverseBroadcastOperation );
PrintBool( WanGlobalNetworkNumber );
PrintULong( GlobalWanNetwork );
PrintBool( GlobalNetworkIndicated );
PrintBool( RipResponder );
PrintBool( SapWarningLogged );
PrintWorkQueueItem( BroadcastOperationQueueItem );
PrintAddr( UnloadEvent );
PrintBool( UnloadWaiting );
PrintAddr( Statistics );
PrintBool( AutoDetect );
PrintBool( DefaultAutoDetected );
PrintUChar( AutoDetectState );
PrintAddr( AutoDetectEvent );
PrintAddr( IpxStartTime );
PrintAddr( AddressResource );
PrintPtr( DeviceObject );
PrintJoin();
PrintPtr( DeviceName );
dprintf( "\"%S\"\n", pDeviceName );
PrintULong( DeviceNameLength );
PrintEndStruct();
PrintEnd
return;
}
#ifdef _obj
# undef _obj
# undef _objAddr
# undef _objType
#endif
#define _obj Reserved
#define _objAddr pReserved
#define _objType IPX_SEND_RESERVED
VOID
DumpIpxSend
(
ULONG IpxSendToDump,
VERBOSITY Verbosity
)
{
PIPX_SEND_RESERVED pReserved;
IPX_SEND_RESERVED Reserved;
ULONG result;
pReserved = SEND_RESERVED(( PIPX_SEND_PACKET )IpxSendToDump );
if ( !ReadMemory( ( ULONG )pReserved,
&Reserved,
sizeof( Reserved ),
&result ))
{
dprintf("%08lx: Could not read IPX_SEND_RESERVED structure\n", pReserved );
return;
}
dprintf( "NDIS_PACKET @(0x%08X) ", IpxSendToDump );
if ( Verbosity == VERBOSITY_ONE_LINER )
{
dprintf( "{ " );
if ( Reserved.Address != NULL )
{
DumpIpxAddress( ( ULONG )( Reserved.Address ), VERBOSITY_ONE_LINER );
}
else
{
dprintf( "(NULL Address)" );
}
dprintf( " (" );
dprint_enum_name( (ULONG) _obj.Identifier, EnumSendReservedIdentifier );
dprintf( ") }" );
return;
}
PrintStart;
PrintStartStruct();
PrintEnum( Identifier, EnumSendReservedIdentifier );
PrintBool( SendInProgress );
PrintBool( OwnedByAddress );
PrintEnum( DestinationType, EnumSendReservedDestinationType );
PrintPtr( PaddingBuffer );
PrintPtr( PreviousTail );
PrintL( PoolLinkage );
PrintLL( GlobalLinkage );
PrintLL( WaitLinkage );
#ifdef IPX_TRACK_POOL
PrintPtr( Pool );
#endif
PrintJoin();
PrintPtr( Address );
if ( Reserved.Address != NULL )
{
DumpIpxAddress( ( ULONG )( Reserved.Address ), VERBOSITY_ONE_LINER );
}
dprintf( "\n" );
PrintFlushLeft();
switch ( Reserved.Identifier )
{
case IDENTIFIER_NB:
case IDENTIFIER_IPX:
case IDENTIFIER_SPX:
dprintf( " --- SR_DG part of union ---------------------------\n");
PrintPtr( u.SR_DG.Request );
PrintJoin();
PrintPtr( u.SR_DG.AddressFile );
if ( Reserved.u.SR_DG.AddressFile != NULL )
{
DumpIpxAddressFile( ( ULONG )( Reserved.u.SR_DG.AddressFile ), VERBOSITY_ONE_LINER );
}
dprintf( "\n" );
PrintUShort( u.SR_DG.CurrentNicId );
PrintBool( u.SR_DG.Net0SendSucceeded );
PrintBool( u.SR_DG.OutgoingSap );
break;
case IDENTIFIER_RIP:
case IDENTIFIER_RIP_INTERNAL:
case IDENTIFIER_RIP_RESPONSE:
PrintStartStruct();
dprintf( " --- SR_RIP part of union ---------------------------\n");
PrintULong( u.SR_RIP.Network );
PrintUShort( u.SR_RIP.CurrentNicId );
PrintUChar( u.SR_RIP.RetryCount );
PrintBool( u.SR_RIP.RouteFound );
PrintUShort( u.SR_RIP.SendTime );
PrintBool( u.SR_RIP.NoIdAdvance );
break;
default:
dprintf( "*** Couldn't determine which part of union to display.\n" );
}
PrintFlushLeft();
PrintPtr( Header );
PrintJoin();
PrintPtr( HeaderBuffer );
DumpMdlChain( ( ULONG )_obj.HeaderBuffer, VERBOSITY_ONE_LINER );
dprintf( "\n" );
PrintEndStruct();
PrintEnd;
}
#ifdef _obj
# undef _obj
# undef _objAddr
# undef _objType
#endif
#define _obj Reserved
#define _objAddr pReserved
#define _objType IPX_RECEIVE_RESERVED
VOID
DumpIpxReceive
(
ULONG IpxReceiveToDump,
VERBOSITY Verbosity
)
{
_objType *_objAddr;
_objType _obj;
ULONG result;
dprintf( "NDIS_PACKET at 0x%08X\n", IpxReceiveToDump );
pReserved = RECEIVE_RESERVED(( PIPX_SEND_PACKET )IpxReceiveToDump );
if ( !ReadMemory( IpxReceiveToDump,
&_obj,
sizeof( _obj ),
&result ))
{
dprintf("%08lx: Could not read IPX_SEND_RESERVED structure\n", _objAddr );
return;
}
PrintStartStruct();
PrintEnum( Identifier, EnumSendReservedIdentifier );
PrintBool( TransferInProgress );
PrintBool( OwnedByAddress );
#ifdef IPX_TRACK_POOL
PrintPtr( Pool );
#endif
PrintJoin();
PrintPtr( Address );
if ( Reserved.Address != NULL )
{
DumpIpxAddress( ( ULONG )( Reserved.Address ), VERBOSITY_ONE_LINER );
}
dprintf( "\n" );
PrintPtr( SingleRequest );
PrintPtr( ReceiveBuffer );
PrintL( PoolLinkage );
PrintLL( GlobalLinkage );
PrintLL( Requests );
PrintEndStruct();
}
DECLARE_API( ipxaddrfile )
{
ULONG AddressFileToDump = 0;
ULONG result;
char VarName[ MAX_LIST_VARIABLE_NAME_LENGTH + 1 ];
MEMBER_VARIABLE_INFO MemberInfo;
BOOL bFocusOnMemberVariable = FALSE;
if ( *args )
{
bFocusOnMemberVariable = ReadArgsForTraverse( args, VarName );
}
if ( *args && *args!='-' )
{
if (!sscanf(args, "%lx", &AddressFileToDump))
{
return;
}
}
if ( AddressFileToDump == 0 )
{
dprintf( "Please specify an address.\n" );
}
if ( bFocusOnMemberVariable )
{
if ( !LocateMemberVariable( "IpxAddressFile", VarName, ( PVOID )AddressFileToDump, &MemberInfo ))
{
return;
}
WriteMemberInfo( &MemberInfo );
next( hCurrentProcess, hCurrentThread, dwCurrentPc, dwProcessor, "" );
return;
}
DumpIpxAddressFile( AddressFileToDump, VERBOSITY_FULL );
return;
}
#ifdef _obj
# undef _obj
# undef _objAddr
# undef _objType
#endif
#define _obj AddressFile
#define _objAddr prAddressFile
#define _objType ADDRESS_FILE
VOID
DumpIpxAddressFile
(
ULONG AddressFileToDump,
VERBOSITY Verbosity
)
{
_objType _obj;
_objType *_objAddr;
ULONG result;
_objAddr = ( _objType * )AddressFileToDump;
if ( !ReadMemory( AddressFileToDump,
&_obj,
sizeof( _obj ),
&result ))
{
dprintf( "%08lx: Could not read %s structure\n",
AddressFileToDump,
"ADDRESS_FILE" );
return;
}
if ( Verbosity == VERBOSITY_ONE_LINER )
{
switch ( _obj.State )
{
case ADDRESSFILE_STATE_OPENING:
dprintf( "OPENING " );
break;
case ADDRESSFILE_STATE_OPEN:
dprintf( "OPEN " );
break;
case ADDRESSFILE_STATE_CLOSING:
dprintf( "CLOSING " );
break;
default:
dprintf( "Bogus state " );
break;
}
DumpIpxAddress( ( ULONG )( AddressFile.Address ), VERBOSITY_ONE_LINER );
return;
}
PrintStartStruct();
#if DBG
# if AFREF_TOTAL != 8
# error AFREF_TOTAL was assumed to equal 8
# endif
PrintULong( RefTypes[ AFREF_CREATE ] );
PrintULong( RefTypes[ AFREF_RCV_DGRAM ] );
PrintULong( RefTypes[ AFREF_SEND_DGRAM ] );
PrintULong( RefTypes[ AFREF_VERIFY ] );
PrintULong( RefTypes[ AFREF_INDICATION ] );
PrintULong( RefTypes[ 5 ] );
PrintULong( RefTypes[ 6 ] );
PrintULong( RefTypes[ 7 ] );
#endif
PrintEnum( Type, EnumStructureType );
PrintUShort( Size );
PrintLL( Linkage );
PrintULong( ReferenceCount );
PrintEnum( State, EnumAddressFileState );
PrintPtr( AddressLock );
PrintPtr( Request );
PrintJoin();
PrintPtr( Address );
if ( AddressFile.Address != NULL )
{
dprintf( "(" );
DumpIpxAddress( ( ULONG )( AddressFile.Address ), VERBOSITY_ONE_LINER );
dprintf( ")" );
}
dprintf( "\n" );
#ifdef ISN_NT
PrintPtr( FileObject );
#endif
PrintJoin();
PrintPtr( Device );
if ( AddressFile.Device != NULL )
{
DumpIpxDevice( ( ULONG )( AddressFile.Device ), VERBOSITY_ONE_LINER );
}
dprintf( "\n" );
PrintBool( SpecialReceiveProcessing );
PrintBool( ExtendedAddressing );
PrintBool( ReceiveFlagsAddressing );
PrintBool( ReceiveIpxHeader );
PrintUChar( DefaultPacketType );
PrintBool( FilterOnPacketType );
PrintUChar( FilteredType );
PrintBool( EnableBroadcast );
PrintBool( IsSapSocket );
PrintLL( ReceiveDatagramQueue );
PrintPtr( CloseRequest );
PrintBool( RegisteredReceiveDatagramHandler );
PrintBool( RegisteredErrorHandler );
PrintSymbolPtr( ReceiveDatagramHandler );
PrintXULong( ReceiveDatagramHandlerContext );
PrintSymbolPtr( ErrorHandler );
PrintXULong( ErrorHandlerContext );
PrintEndStruct();
}
DECLARE_API( ipxaddr )
{
ULONG AddressToDump = 0;
ULONG result;
char VarName[ MAX_LIST_VARIABLE_NAME_LENGTH + 1 ];
MEMBER_VARIABLE_INFO MemberInfo;
BOOL bFocusOnMemberVariable = FALSE;
if ( *args )
{
bFocusOnMemberVariable = ReadArgsForTraverse( args, VarName );
}
if ( *args && *args!='-' )
{
if (!sscanf(args, "%lx", &AddressToDump))
{
return;
}
}
if ( AddressToDump == 0 )
{
dprintf( "Please specify an address.\n" );
}
if ( bFocusOnMemberVariable )
{
if ( !LocateMemberVariable( "IpxBinding", VarName, ( PVOID )AddressToDump, &MemberInfo ))
{
return;
}
WriteMemberInfo( &MemberInfo );
next( hCurrentProcess, hCurrentThread, dwCurrentPc, dwProcessor, "" );
return;
}
DumpIpxAddress( AddressToDump, VERBOSITY_FULL );
return;
}
#ifdef _obj
# undef _obj
# undef _objAddr
# undef _objType
#endif
#define _obj Address
#define _objAddr prAddress
#define _objType ADDRESS
VOID
DumpIpxAddress
(
ULONG AddressToDump,
VERBOSITY Verbosity
)
{
_objType _obj;
_objType *_objAddr;
ULONG result;
_objAddr = ( _objType * )AddressToDump;
if ( !ReadMemory( AddressToDump,
&_obj,
sizeof( _obj ),
&result ))
{
dprintf( "%08lx: Could not read %s structure\n",
AddressToDump,
"ADDRESS" );
return;
}
if ( Verbosity == VERBOSITY_ONE_LINER )
{
dprint_hardware_address( _obj.LocalAddress.NodeAddress );
dprintf( ".%d", Address.LocalAddress.Socket );
return;
}
PrintStartStruct();
#if DBG
# if AREF_TOTAL != 4
# error AREF_TOTAL was assumed to equal 4
# endif
PrintULong( RefTypes[ AREF_ADDRESS_FILE ] );
PrintULong( RefTypes[ AREF_LOOKUP ] );
PrintULong( RefTypes[ AREF_RECEIVE ] );
PrintULong( RefTypes[ 3 ] );
#endif
PrintEnum( Type, EnumStructureType );
PrintUShort( Size );
PrintLL( Linkage );
PrintULong( ReferenceCount );
PrintLock( Lock );
PrintPtr( Request );
PrintUShort( Socket );
PrintUShort( SendSourceSocket );
PrintBool( Stopping );
PrintULong( Flags );
PrintJoin();
PrintPtr( Device );
if ( Address.Device != NULL )
{
DumpIpxDevice( ( ULONG )( Address.Device ), VERBOSITY_ONE_LINER );
}
dprintf( "\n" );
PrintPtr( DeviceLock );
PrintLL( AddressFileDatabase );
PrintTDIAddress( LocalAddress );
PrintAddr( SendPacket );
PrintAddr( ReceivePacket );
PrintAddr( SendPacketHeader );
#ifdef ISN_NT
PrintStartStruct();
if ( Address.ReferenceCount )
{
PrintULong( u.ShareAccess.OpenCount );
PrintULong( u.ShareAccess.Readers );
PrintULong( u.ShareAccess.Writers );
PrintULong( u.ShareAccess.Deleters );
PrintULong( u.ShareAccess.SharedRead );
PrintULong( u.ShareAccess.SharedWrite );
PrintULong( u.ShareAccess.SharedDelete );
}
else
{
PrintWorkQueueItem( u.DestroyAddressQueueItem );
}
PrintEndStruct();
PrintPtr( SecurityDescriptor );
#endif
PrintEndStruct();
}
DECLARE_API( ipxadapter )
{
ULONG AdapterToDump = 0;
ULONG result;
char VarName[ MAX_LIST_VARIABLE_NAME_LENGTH + 1 ];
MEMBER_VARIABLE_INFO MemberInfo;
BOOL bFocusOnMemberVariable = FALSE;
if ( *args )
{
bFocusOnMemberVariable = ReadArgsForTraverse( args, VarName );
}
if ( *args && *args!='-' )
{
if (!sscanf(args, "%lx", &AdapterToDump ))
{
return;
}
}
if ( AdapterToDump == 0 )
{
dprintf( "Please specify an address.\n" );
}
if ( bFocusOnMemberVariable )
{
if ( !LocateMemberVariable( "IpxAdapter", VarName, ( PVOID )AdapterToDump, &MemberInfo ))
{
return;
}
WriteMemberInfo( &MemberInfo );
next( hCurrentProcess, hCurrentThread, dwCurrentPc, dwProcessor, "" );
return;
}
DumpIpxAdapter( AdapterToDump, VERBOSITY_FULL );
return;
}
#ifdef _obj
# undef _obj
# undef _objAddr
# undef _objType
#endif
#define _obj Adapter
#define _objAddr prAdapter
#define _objType ADAPTER
VOID
DumpIpxAdapter
(
ULONG AdapterToDump,
VERBOSITY Verbosity
)
{
_objType _obj;
_objType *_objAddr;
ULONG result;
WCHAR Buffer[ 1000 ];
PWCHAR pAdapterName = NULL;
_objAddr = ( _objType * )AdapterToDump;
if ( !ReadMemory( AdapterToDump,
&_obj,
sizeof( _obj ),
&result ))
{
dprintf( "%08lx: Could not read %s structure\n",
AdapterToDump,
"ADAPTER" );
return;
}
if ( !ReadMemory( ( ULONG )Adapter.AdapterName,
Buffer,
sizeof( WCHAR ) * Adapter.AdapterNameLength,
&result ))
{
dprintf("%08lx: Could not read adapter name structure\n", Adapter.AdapterName );
}
else
{
pAdapterName = Buffer;
}
if ( Verbosity == VERBOSITY_ONE_LINER )
{
dprintf( "\"%S\"", pAdapterName );
return;
}
dprintf( "Adapter at 0x%08X\n", AdapterToDump );
PrintStart;
PrintEnum( Type, EnumStructureType );
PrintUShort( Size );
#if DBG
PrintNChar( Signature1, sizeof( Adapter.Signature1 ));
#endif
PrintULong( BindingCount );
PrintPtr( NdisBindingHandle );
PrintLL( RequestCompletionQueue );
#if ISN_FRAME_TYPE_MAX !=4
# error ISN_FRAME_TYPE_MAX is no longer 4.
#endif
PrintULong( DefHeaderSizes[ ISN_FRAME_TYPE_ETHERNET_II ] );
PrintULong( BcMcHeaderSizes[ ISN_FRAME_TYPE_ETHERNET_II ] );
PrintPtr( Bindings[ ISN_FRAME_TYPE_ETHERNET_II ] );
PrintULong( DefHeaderSizes[ ISN_FRAME_TYPE_802_3 ] );
PrintULong( BcMcHeaderSizes[ ISN_FRAME_TYPE_802_3 ] );
PrintPtr( Bindings[ ISN_FRAME_TYPE_802_3 ] );
PrintULong( DefHeaderSizes[ ISN_FRAME_TYPE_802_2 ] );
PrintULong( BcMcHeaderSizes[ ISN_FRAME_TYPE_802_2 ] );
PrintPtr( Bindings[ ISN_FRAME_TYPE_802_2 ] );
PrintULong( DefHeaderSizes[ ISN_FRAME_TYPE_SNAP ] );
PrintULong( BcMcHeaderSizes[ ISN_FRAME_TYPE_SNAP ] );
PrintPtr( Bindings[ ISN_FRAME_TYPE_SNAP ] );
PrintULong( AllocatedReceiveBuffers );
PrintLL( ReceiveBufferPoolList );
PrintL( ReceiveBufferList );
PrintULong( AllocatedPaddingBuffers );
PrintL( PaddingBufferList );
PrintBool( BroadcastEnabled );
PrintPtr( AutoDetectFoundOnBinding );
PrintBool( AutoDetectResponse );
PrintBool( DefaultAutoDetected );
PrintUShort( FirstWanNicId );
PrintUShort( LastWanNicId );
PrintULong( WanNicIdCount );
PrintUShort( BindSap );
PrintUShort( BindSapNetworkOrder );
PrintBool( SourceRouting );
PrintBool( EnableFunctionalAddress );
PrintBool( EnableWanRouter );
PrintULong( ConfigMaxPacketSize );
PrintJoin();
PrintPtr( AdapterName );
if ( pAdapterName != NULL )
{
dprintf( "\"%S\"", pAdapterName );
}
dprintf( "\n" );
PrintULong( AdapterNameLength );
PrintJoin();
PrintPtr( Device );
if ( Adapter.Device != NULL )
{
DumpIpxDevice( ( ULONG )( Adapter.Device ), VERBOSITY_ONE_LINER );
}
dprintf( "\n" );
PrintLock( Lock );
PrintPtr( DeviceLock );
PrintHardwareAddress( LocalMacAddress );
PrintUChar( LastSourceRoutingTime );
PrintAddr( NdisRequestEvent );
PrintXULong( NdisRequestStatus );
PrintXULong( OpenErrorStatus );
PrintStartStruct();
PrintULong( MacInfo.MediumType );
PrintULong( MacInfo.RealMediumType );
PrintBool( MacInfo.SourceRouting );
PrintBool( MacInfo.MediumAsync );
PrintUChar( MacInfo.BroadcastMask );
PrintULong( MacInfo.CopyLookahead );
PrintULong( MacInfo.MacOptions );
PrintULong( MacInfo.MinHeaderLength );
PrintULong( MacInfo.MaxHeaderLength );
PrintEndStruct();
PrintULong( MaxReceivePacketSize );
PrintULong( MaxSendPacketSize );
PrintULong( ReceiveBufferSpace );
PrintULong( MediumSpeed );
#if IDENTIFIER_TOTAL != 4
# error IDENTIFIER_TOTAL is assumed to equal 4
#endif
PrintBool( SourceRoutingEmpty[IDENTIFIER_NB] );
PrintPtr( SourceRoutingHeads[IDENTIFIER_NB] );
PrintBool( SourceRoutingEmpty[IDENTIFIER_IPX] );
PrintPtr( SourceRoutingHeads[IDENTIFIER_IPX] );
PrintBool( SourceRoutingEmpty[IDENTIFIER_SPX] );
PrintPtr( SourceRoutingHeads[IDENTIFIER_SPX] );
PrintBool( SourceRoutingEmpty[IDENTIFIER_RIP] );
PrintPtr( SourceRoutingHeads[IDENTIFIER_RIP] );
PrintEnd;
}
DECLARE_API( ipxbinding )
{
ULONG BindingToDump = 0;
ULONG result;
char VarName[ MAX_LIST_VARIABLE_NAME_LENGTH + 1 ];
MEMBER_VARIABLE_INFO MemberInfo;
BOOL bFocusOnMemberVariable = FALSE;
if ( *args )
{
bFocusOnMemberVariable = ReadArgsForTraverse( args, VarName );
}
if ( *args && *args!='-' )
{
if (!sscanf(args, "%lx", &BindingToDump))
{
return;
}
}
if ( BindingToDump == 0 )
{
dprintf( "Please specify an address.\n" );
}
if ( bFocusOnMemberVariable )
{
if ( !LocateMemberVariable( "IpxBinding", VarName, ( PVOID )BindingToDump, &MemberInfo ))
{
return;
}
WriteMemberInfo( &MemberInfo );
next( hCurrentProcess, hCurrentThread, dwCurrentPc, dwProcessor, "" );
return;
}
DumpIpxBinding( BindingToDump, VERBOSITY_FULL );
return;
}
#ifdef _obj
# undef _obj
# undef _objAddr
# undef _objType
#endif
#define _obj Binding
#define _objAddr pBinding
#define _objType BINDING
VOID
DumpIpxBinding
(
ULONG BindingToDump,
VERBOSITY Verbosity
)
{
BINDING Binding;
PBINDING pBinding;
ULONG result;
pBinding = ( PBINDING )BindingToDump;
if ( !ReadMemory( BindingToDump,
&Binding,
sizeof( Binding ),
&result ))
{
dprintf("%08lx: Could not read BINDING structure\n", BindingToDump );
return;
}
if ( Verbosity == VERBOSITY_ONE_LINER )
{
if ( Binding.Adapter != NULL )
{
DumpIpxAdapter( ( ULONG )( Binding.Adapter ), VERBOSITY_ONE_LINER );
}
dprintf( " %s\n", Binding.LineUp ? "UP" : "DOWN" );
return;
}
dprintf( "Binding at 0x%08X\n", BindingToDump );
PrintStart;
PrintStartStruct();
#if DBG
# if BREF_TOTAL != 5
# error The BREF_TOTAL constant has changed, and so must ipxext.c
# endif
PrintULong( RefTypes[ 0 ] );
PrintULong( RefTypes[ BREF_BOUND ] );
PrintULong( RefTypes[ 2 ] );
PrintULong( RefTypes[ 3 ] );
PrintULong( RefTypes[ 4 ] );
#endif
PrintEnum( Type, EnumStructureType );
PrintUShort( Size );
#if DBG
PrintNChar( Signature1, sizeof( Binding.Signature1 ));
#endif
PrintULong( ReferenceCount );
PrintJoin();
PrintPtr( Adapter );
if ( Binding.Adapter != NULL )
{
DumpIpxAdapter( ( ULONG )( Binding.Adapter ), VERBOSITY_ONE_LINER );
}
dprintf( "\n" );
PrintUShort( NicId );
PrintULong( MaxSendPacketSize );
PrintJoin();
PrintULong( MediumSpeed ); // in units of 100 bytes/sec
dprintf( "(In units of 100 bytes/sec)\n" );
PrintHardwareAddress( LocalMacAddress );
PrintHardwareAddress( RemoteMacAddress );
PrintFieldName( "WanRemoteNode" );
dprint_hardware_address( Binding.WanRemoteNode );
dprintf( "\n" );
PrintBool( AutoDetect );
PrintBool( DefaultAutoDetect );
PrintUShort( MatchingResponses );
PrintUShort( NonMatchingResponses );
PrintXULong( TentativeNetworkAddress );
PrintBool( BindingSetMember );
PrintBool( ReceiveBroadcast );
PrintBool( LineUp );
PrintBool( DialOutAsync );
if ( Binding.BindingSetMember )
{
PrintPtr( NextBinding );
PrintPtr( CurrentSendBinding );
PrintPtr( MasterBinding );
}
PrintULong( WanInactivityCounter );
PrintTDIAddress( LocalAddress );
PrintSymbolPtr( SendFrameHandler );
PrintPtr( Device );
PrintJoin();
PrintPtr( DeviceLock );
if ( Binding.DeviceLock != NULL )
{
DumpCTELock( ( ULONG )Binding.DeviceLock, VERBOSITY_ONE_LINER );
}
dprintf( "\n" );
PrintULong( DefHeaderSize );
PrintULong( BcMcHeaderSize );
PrintULong( AnnouncedMaxDatagramSize );
PrintULong( RealMaxDatagramSize );
PrintULong( MaxLookaheadData );
PrintULong( FwdAdapterContext );
PrintULong( InterfaceIndex );
PrintULong( ConnectionId );
PrintULong( IpxwanConfigRequired );
{
ULONG i;
for (i=0; i<UPPER_DRIVER_COUNT; i++) {
PrintBool( IsnInformed[i] );
}
}
PrintEnum( FrameType, EnumBindingFrameType );
PrintWorkQueueItem( WanDelayedQueueItem );
PrintEndStruct();
PrintEnd;
}
#ifdef _obj
# undef _obj
# undef _objAddr
# undef _objType
#endif
#define _obj RouteEntry
#define _objAddr pRouteEntry
#define _objType IPX_ROUTE_ENTRY
VOID
DumpIpxRouteEntry
(
ULONG EntryToDump,
VERBOSITY Verbosity
) {
PIPX_ROUTE_ENTRY pRouteEntry;
IPX_ROUTE_ENTRY RouteEntry;
ULONG result;
pRouteEntry = ( PIPX_ROUTE_ENTRY )EntryToDump;
if ( !ReadMemory( EntryToDump,
&RouteEntry,
sizeof( IPX_ROUTE_ENTRY ),
&result ))
{
dprintf("%08lx: Could not read IPX_ROUTE_ENTRY structure\n", EntryToDump );
return;
}
PrintStart;
PrintStartStruct();
dprintf( "\tRoute Entry at 0x%08X\n", EntryToDump );
PrintNetworkAddress(Network);
PrintUShort(NicId);
PrintMacAddress(NextRouter);
PrintPtr(NdisBindingContext);
PrintFlags(Flags,FlagsRouteEntry);
PrintUShort(Timer);
PrintUShort(TickCount);
PrintUShort(HopCount);
PrintEndStruct();
PrintEnd;
}
#ifdef _obj
# undef _obj
# undef _objAddr
# undef _objType
#endif
#define _obj RouterSegment
#define _objAddr pRouterSegment
#define _objType ROUTER_SEGMENT
VOID
DumpIpxRouterSegment
(
ULONG SegmentToDump,
VERBOSITY Verbosity
) {
PROUTER_SEGMENT pRouterSegment;
ROUTER_SEGMENT RouterSegment;
ULONG result;
PLIST_ENTRY p;
LIST_ENTRY temp;
PIPX_ROUTE_ENTRY pRouteEntry;
pRouterSegment = ( PROUTER_SEGMENT )SegmentToDump;
if ( !ReadMemory( SegmentToDump,
&RouterSegment,
sizeof( ROUTER_SEGMENT ),
&result ))
{
dprintf("%08lx: Could not read ROUTER_SEGMENT structure\n", SegmentToDump );
return;
}
if ( Verbosity == VERBOSITY_ONE_LINER )
{
PrintLL(Entries);
return;
}
PrintStart;
PrintStartStruct();
dprintf( "\tSegment Entry at 0x%08X\n", SegmentToDump );
PrintLL(WaitingForRoute);
PrintLL(FindWaitingForRoute);
PrintLL(WaitingLocalTarget);
PrintLL(WaitingReripNetnum);
PrintLL(Entries);
PrintPtr(EnumerateLocation);
for (p = RouterSegment.Entries.Flink;
p != &(pRouterSegment->Entries);) {
pRouteEntry = CONTAINING_RECORD(p,
IPX_ROUTE_ENTRY,
PRIVATE.Linkage);
DumpIpxRouteEntry((ULONG)pRouteEntry,VERBOSITY_ONE_LINER);
if ( !ReadMemory( (ULONG) p,
&temp,
sizeof( LIST_ENTRY ),
&result ))
{
dprintf("%08lx: Could not read LIST_ENTRY structure\n", p);
break;
} else {
p = temp.Flink;
}
}
PrintEnd;
PrintEndStruct();
return;
}
DECLARE_API( ipxrequest )
{
ULONG RequestToDump = 0;
ULONG result;
char VarName[ MAX_LIST_VARIABLE_NAME_LENGTH + 1 ];
MEMBER_VARIABLE_INFO MemberInfo;
BOOL bFocusOnMemberVariable = FALSE;
if ( *args )
{
bFocusOnMemberVariable = ReadArgsForTraverse( args, VarName );
}
if ( *args && *args!='-' )
{
if (!sscanf(args, "%lx", &RequestToDump))
{
return;
}
}
if ( RequestToDump == 0 )
{
dprintf( "Please specify an address.\n" );
}
if ( bFocusOnMemberVariable )
{
if ( !LocateMemberVariable( "IpxRequest", VarName, ( PVOID )RequestToDump, &MemberInfo ))
{
return;
}
WriteMemberInfo( &MemberInfo );
next( hCurrentProcess, hCurrentThread, dwCurrentPc, dwProcessor, "" );
return;
}
DumpIpxRequest( RequestToDump, VERBOSITY_FULL );
return;
}
#ifdef _obj
# undef _obj
# undef _objAddr
# undef _objType
#endif
#define _obj Request
#define _objAddr prRequest
#define _objType REQUEST
VOID
DumpIpxRequest
(
ULONG RequestToDump,
VERBOSITY Verbosity
)
{
_objType _obj;
_objType *_objAddr;
ULONG result;
_objAddr = ( _objType * )RequestToDump;
if ( !ReadMemory( RequestToDump,
&_obj,
sizeof( _obj ),
&result ))
{
dprintf( "%08lx: Could not read %s structure\n",
RequestToDump,
"REQUEST" );
return;
}
PrintStartStruct();
DumpIpxIrpStack( &Request, VERBOSITY_FULL );
PrintEndStruct();
}
PDEVICE_OBJECT GetIpxDeviceObject( VOID )
{
ULONG deviceToDump = 0;
ULONG prDevice = 0;
ULONG result;
DEVICE Device;
prDevice = GetExpression( "nwlnkipx!IpxDevice" );
if ( !prDevice )
{
dprintf("Could not get nwlnkipx!IpxDevice, Try !reload\n");
return( NULL );
}
if (!ReadMemory( prDevice,
&deviceToDump,
sizeof(deviceToDump),
&result ))
{
dprintf("%08lx: Could not read device address\n", prDevice);
return( NULL );
}
if ( !ReadMemory( deviceToDump,
&Device,
sizeof(Device),
&result ))
{
dprintf("%08lx: Could not read device context\n", deviceToDump);
return( NULL );
}
return( Device.DeviceObject );
}
#ifdef _obj
# undef _obj
# undef _objAddr
# undef _objType
#endif
#define _obj ConnInfo
#define _objAddr prConnInfo
#define _objType TDI_CONNECTION_INFORMATION
VOID
DumpTdiConnectionInformation
(
ULONG InformationToDump,
VERBOSITY Verbosity
)
{
_objType _obj;
_objType *_objAddr;
ULONG result;
_objAddr = ( _objType * )InformationToDump;
if ( !ReadMemory( InformationToDump,
&_obj,
sizeof( _obj ),
&result ))
{
dprintf( "%08lx: Could not read %s structure\n",
InformationToDump,
"TDI_CONNECTION_INFORMATION" );
return;
}
PrintStartStruct();
PrintULong( UserDataLength ); // length of user data buffer
PrintPtr( UserData ); // pointer to user data buffer
PrintULong( OptionsLength ); // length of follwoing buffer
PrintPtr( Options ); // pointer to buffer containing options
PrintULong( RemoteAddressLength ); // length of following buffer
PrintPtr( RemoteAddress ); // buffer containing the remote address
PrintEndStruct();
}
#ifdef _obj
# undef _obj
# undef _objAddr
# undef _objType
#endif
#define _obj Parameters
#define _objAddr prParameters
#define _objType TDI_REQUEST_KERNEL_SENDDG
VOID
DumpTdiSendParameters
(
ULONG ParametersToDump,
VERBOSITY Verbosity
)
{
_objType _obj;
_objType *_objAddr;
ULONG result;
_objAddr = ( _objType * )ParametersToDump;
if ( !ReadMemory( ParametersToDump,
&_obj,
sizeof( _obj ),
&result ))
{
dprintf( "%08lx: Could not read %s structure\n",
ParametersToDump,
"TDI_REQUEST_KERNEL_SENDDG" );
return;
}
PrintStartStruct();
PrintULong( SendLength );
PrintPtr( SendDatagramInformation );
DumpTdiConnectionInformation(( ULONG )_obj.SendDatagramInformation, Verbosity );
PrintEndStruct();
}
#ifdef _obj
# undef _obj
# undef _objAddr
# undef _objType
#endif
#define _obj Stack
#define _objAddr prStack
#define _objType IO_STACK_LOCATION
VOID
DumpIpxIrpStack
(
PREQUEST pRequest,
VERBOSITY Verbosity
)
/*++
Routine Description:
Given an IRP of interest to the debugger, this routine will search that IRP's
stacks for the stack location that involves IPX. This stack location will be
dumped, and the file object contained in it will be followed. The file object
will then be used to ....
Matching the IRP stack locations to IPX requires finding the IPX device object
pointer from the ipxdev structure, and looking in the devobjects referred to
by the IRP to see if they refer to ipx.
--*/
{
_objType _obj;
_objType *_objAddr;
ULONG result;
PIO_STACK_LOCATION pStack;
ULONG StackToDump;
PDEVICE_OBJECT IpxDeviceObject;
CHAR idxStack;
IpxDeviceObject = GetIpxDeviceObject();
if ( IpxDeviceObject == NULL )
{
return;
}
prStack = pRequest->Tail.Overlay.CurrentStackLocation;
for ( idxStack = 0; idxStack < pRequest->StackCount; idxStack ++ )
{
StackToDump = ( ULONG )prStack;
if ( !ReadMemory( StackToDump,
&Stack,
sizeof( Stack ),
&result ))
{
dprintf( "%08lx: Could not read %s structure\n",
StackToDump,
"STACK" );
return;
}
if ( Stack.DeviceObject == IpxDeviceObject )
{
break;
}
prStack --;
}
if ( Stack.DeviceObject != IpxDeviceObject )
{
dprintf( "None of the device objects in this IRP's stacks seem to match the IPX device object.\n ");
return;
}
PrintStartStruct();
PrintXEnum( MajorFunction, EnumIrpMajorFunction );
PrintXEnum( MinorFunction, EnumIrpMinorFunction[ _obj.MajorFunction ] );
// Send? Dump Parameters
PrintAddr( Parameters );
DumpTdiSendParameters( AddressOf( Parameters ), VERBOSITY_FULL );
PrintXULong( Flags );
PrintXULong( Control );
PrintJoin();
PrintPtr( DeviceObject );
DumpDeviceObject(( ULONG ) Stack.DeviceObject, VERBOSITY_ONE_LINER );
PrintJoin();
PrintPtr( FileObject );
if ( Stack.FileObject != NULL )
{
FILE_OBJECT FileObject;
if ( !ReadMemory( ( ULONG )Stack.FileObject,
&FileObject,
sizeof( FileObject ),
&result ))
{
dprintf( "%08lx: Could not read FileObject", Stack.FileObject );
}
else
{
dprintf( "Addressfile at %8X: ", ( ULONG )FileObject.FsContext );
DumpIpxAddressFile( ( ULONG )FileObject.FsContext, VERBOSITY_ONE_LINER );
}
}
dprintf( "\n" );
PrintSymbolPtr( CompletionRoutine );
PrintXULong( Context );
PrintEndStruct();
}
#ifdef _obj
# undef _obj
# undef _objAddr
# undef _objType
#endif
#define _obj DevObj
#define _objAddr prDevObj
#define _objType DEVICE_OBJECT
VOID DumpDeviceObject
(
ULONG DevObjToDump,
VERBOSITY Verbosity
)
{
_objType _obj;
_objType *_objAddr;
ULONG result;
PIO_STACK_LOCATION pStack;
_objAddr = ( _objType * )DevObjToDump;
if ( !ReadMemory( DevObjToDump,
&_obj,
sizeof( _obj ),
&result ))
{
dprintf( "%08lx: Could not read %s structure\n",
DevObjToDump,
"DEVICE_OBJECT" );
return;
}
if ( Verbosity != VERBOSITY_ONE_LINER )
{
dprintf( "DumpDeviceObject only support VERBOSITY_ONE_LINER.\n" );
}
dprintf( "Ref = %d, Driver = %08X, CurrentIrp = %08X\n",
_obj.ReferenceCount,
_obj.DriverObject,
_obj.CurrentIrp );
}
Reference in a new issue Copy permalink