mirror of https://github.com/lianthony/NT4.0
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2221 lines
46 KiB
2221 lines
46 KiB
/*++
|
|
|
|
Copyright (c) 1992 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
afdutil.c
|
|
|
|
Abstract:
|
|
|
|
Utility functions for dumping various AFD structures.
|
|
|
|
Author:
|
|
|
|
Keith Moore (keithmo) 19-Apr-1995
|
|
|
|
Environment:
|
|
|
|
User Mode.
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
|
|
#include "afdkdp.h"
|
|
#pragma hdrstop
|
|
|
|
|
|
//
|
|
// Private constants.
|
|
//
|
|
|
|
#define MAX_SYMBOL_LENGTH 128
|
|
|
|
#define ACTUAL_ADDRESS(a,s,f) \
|
|
( (DWORD)(a) + ( (PUCHAR)(&(s)->f) - (PUCHAR)(s) ) )
|
|
|
|
#define IS_LIST_EMPTY(a,s,f) \
|
|
( (DWORD)(s)->f.Flink == ACTUAL_ADDRESS(a,s,f) )
|
|
|
|
|
|
//
|
|
// Private globals.
|
|
//
|
|
|
|
PSTR WeekdayNames[] =
|
|
{
|
|
"Sunday",
|
|
"Monday",
|
|
"Tuesday",
|
|
"Wednesday",
|
|
"Thursday",
|
|
"Friday",
|
|
"Saturday"
|
|
};
|
|
|
|
PSTR MonthNames[] =
|
|
{
|
|
"",
|
|
"January",
|
|
"February",
|
|
"March",
|
|
"April",
|
|
"May",
|
|
"June",
|
|
"July",
|
|
"August",
|
|
"September",
|
|
"October",
|
|
"November",
|
|
"December"
|
|
};
|
|
|
|
|
|
//
|
|
// Private prototypes.
|
|
//
|
|
|
|
PSTR
|
|
StructureTypeToString(
|
|
USHORT Type
|
|
);
|
|
|
|
PSTR
|
|
BooleanToString(
|
|
BOOLEAN Flag
|
|
);
|
|
|
|
PSTR
|
|
EndpointStateToString(
|
|
UCHAR State
|
|
);
|
|
|
|
PSTR
|
|
EndpointTypeToString(
|
|
AFD_ENDPOINT_TYPE Type
|
|
);
|
|
|
|
PSTR
|
|
ConnectionStateToString(
|
|
USHORT State
|
|
);
|
|
|
|
PSTR
|
|
SystemTimeToString(
|
|
LONGLONG Value
|
|
);
|
|
|
|
PSTR
|
|
GroupTypeToString(
|
|
AFD_GROUP_TYPE GroupType
|
|
);
|
|
|
|
VOID
|
|
DumpReferenceDebug(
|
|
PAFD_REFERENCE_DEBUG ReferenceDebug,
|
|
ULONG CurrentSlot
|
|
);
|
|
|
|
BOOL
|
|
IsTransmitIrpBusy(
|
|
PIRP Irp
|
|
);
|
|
|
|
|
|
//
|
|
// Public functions.
|
|
//
|
|
|
|
VOID
|
|
DumpAfdEndpoint(
|
|
PAFD_ENDPOINT Endpoint,
|
|
DWORD ActualAddress
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Dumps the specified AFD_ENDPOINT structure.
|
|
|
|
Arguments:
|
|
|
|
Endpoint - Points to the AFD_ENDPOINT to dump.
|
|
|
|
ActualAddress - The actual address where the structure resides on the
|
|
debugee.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
AFD_TRANSPORT_INFO transportInfo;
|
|
UNICODE_STRING unicodeString;
|
|
WCHAR buffer[MAX_PATH];
|
|
UCHAR address[MAX_TRANSPORT_ADDR];
|
|
ULONG result;
|
|
|
|
dprintf(
|
|
"AFD_ENDPOINT @ %08lx:\n",
|
|
ActualAddress
|
|
);
|
|
|
|
dprintf(
|
|
" Type = %04X (%s)\n",
|
|
Endpoint->Type,
|
|
StructureTypeToString( Endpoint->Type )
|
|
);
|
|
|
|
dprintf(
|
|
" ReferenceCount = %d\n",
|
|
Endpoint->ReferenceCount
|
|
);
|
|
|
|
dprintf(
|
|
" State = %02X (%s)\n",
|
|
Endpoint->State,
|
|
EndpointStateToString( Endpoint->State )
|
|
);
|
|
|
|
dprintf(
|
|
" NonBlocking = %s\n",
|
|
BooleanToString( Endpoint->NonBlocking )
|
|
);
|
|
|
|
dprintf(
|
|
" InLine = %s\n",
|
|
BooleanToString( Endpoint->InLine )
|
|
);
|
|
|
|
dprintf(
|
|
" TdiBufferring = %s\n",
|
|
BooleanToString( Endpoint->TdiBufferring )
|
|
);
|
|
|
|
dprintf(
|
|
" TransportInfo = %08lx\n",
|
|
Endpoint->TransportInfo
|
|
);
|
|
|
|
if( ReadMemory(
|
|
(DWORD)Endpoint->TransportInfo,
|
|
&transportInfo,
|
|
sizeof(transportInfo),
|
|
&result
|
|
) &&
|
|
ReadMemory(
|
|
(DWORD)transportInfo.TransportDeviceName.Buffer,
|
|
buffer,
|
|
sizeof(buffer),
|
|
&result
|
|
) ) {
|
|
|
|
unicodeString = transportInfo.TransportDeviceName;
|
|
unicodeString.Buffer = buffer;
|
|
|
|
dprintf(
|
|
" TransportDeviceName = %wZ\n",
|
|
&unicodeString
|
|
);
|
|
|
|
}
|
|
|
|
dprintf(
|
|
" EndpointType = %08lx (%s)\n",
|
|
Endpoint->EndpointType,
|
|
EndpointTypeToString( Endpoint->EndpointType )
|
|
);
|
|
|
|
dprintf(
|
|
" AddressHandle = %08lx\n",
|
|
Endpoint->AddressHandle
|
|
);
|
|
|
|
dprintf(
|
|
" AddressFileObject = %08lx\n",
|
|
Endpoint->AddressFileObject
|
|
);
|
|
|
|
switch( Endpoint->Type ) {
|
|
|
|
case AfdBlockTypeVcConnecting :
|
|
|
|
dprintf(
|
|
" Connection = %08lx\n",
|
|
Endpoint->Common.VcConnecting.Connection
|
|
);
|
|
|
|
dprintf(
|
|
" ConnectStatus = %08lx\n",
|
|
Endpoint->Common.VcConnecting.ConnectStatus
|
|
);
|
|
|
|
dprintf(
|
|
" ListenEndpoint = %08lx\n",
|
|
Endpoint->Common.VcConnecting.ListenEndpoint
|
|
);
|
|
|
|
break;
|
|
|
|
case AfdBlockTypeVcListening :
|
|
|
|
if( IS_LIST_EMPTY(
|
|
ActualAddress,
|
|
Endpoint,
|
|
Common.VcListening.FreeConnectionListHead ) ) {
|
|
|
|
dprintf(
|
|
" FreeConnectionListHead = EMPTY\n"
|
|
);
|
|
|
|
} else {
|
|
|
|
dprintf(
|
|
" FreeConnectionListHead @ %08lx\n",
|
|
ACTUAL_ADDRESS(
|
|
ActualAddress,
|
|
Endpoint,
|
|
Common.VcListening.FreeConnectionListHead
|
|
)
|
|
);
|
|
|
|
}
|
|
|
|
if( IS_LIST_EMPTY(
|
|
ActualAddress,
|
|
Endpoint,
|
|
Common.VcListening.UnacceptedConnectionListHead ) ) {
|
|
|
|
dprintf(
|
|
" UnacceptedConnectionListHead = EMPTY\n"
|
|
);
|
|
|
|
} else {
|
|
|
|
dprintf(
|
|
" UnacceptedConnectionListHead @ %08lx\n",
|
|
ACTUAL_ADDRESS(
|
|
ActualAddress,
|
|
Endpoint,
|
|
Common.VcListening.UnacceptedConnectionListHead
|
|
)
|
|
);
|
|
|
|
}
|
|
|
|
if( IS_LIST_EMPTY(
|
|
ActualAddress,
|
|
Endpoint,
|
|
Common.VcListening.ReturnedConnectionListHead ) ) {
|
|
|
|
dprintf(
|
|
" ReturnedConnectionListHead = EMPTY\n"
|
|
);
|
|
|
|
} else {
|
|
|
|
dprintf(
|
|
" ReturnedConnectionListHead @ %08lx\n",
|
|
ACTUAL_ADDRESS(
|
|
ActualAddress,
|
|
Endpoint,
|
|
Common.VcListening.ReturnedConnectionListHead
|
|
)
|
|
);
|
|
|
|
}
|
|
|
|
if( IS_LIST_EMPTY(
|
|
ActualAddress,
|
|
Endpoint,
|
|
Common.VcListening.ListeningIrpListHead ) ) {
|
|
|
|
dprintf(
|
|
" ListeningIrpListHead = EMPTY\n"
|
|
);
|
|
|
|
} else {
|
|
|
|
dprintf(
|
|
" ListeningIrpListHead @ %08lx\n",
|
|
ACTUAL_ADDRESS(
|
|
ActualAddress,
|
|
Endpoint,
|
|
Common.VcListening.ListeningIrpListHead
|
|
)
|
|
);
|
|
|
|
}
|
|
|
|
dprintf(
|
|
" FailedConnectionAdds = %08lx\n",
|
|
Endpoint->Common.VcListening.FailedConnectionAdds
|
|
);
|
|
|
|
break;
|
|
|
|
case AfdBlockTypeDatagram :
|
|
|
|
dprintf(
|
|
" RemoteAddress = %08lx\n",
|
|
Endpoint->Common.Datagram.RemoteAddress
|
|
);
|
|
|
|
dprintf(
|
|
" RemoteAddressLength = %08lx\n",
|
|
Endpoint->Common.Datagram.RemoteAddressLength
|
|
);
|
|
|
|
if( IS_LIST_EMPTY(
|
|
ActualAddress,
|
|
Endpoint,
|
|
Common.Datagram.ReceiveIrpListHead ) ) {
|
|
|
|
dprintf(
|
|
" ReceiveIrpListHead = EMPTY\n"
|
|
);
|
|
|
|
} else {
|
|
|
|
dprintf(
|
|
" ReceiveIrpListHead @ %08lx\n",
|
|
ACTUAL_ADDRESS(
|
|
ActualAddress,
|
|
Endpoint,
|
|
Common.Datagram.ReceiveIrpListHead
|
|
)
|
|
);
|
|
|
|
}
|
|
|
|
if( IS_LIST_EMPTY(
|
|
ActualAddress,
|
|
Endpoint,
|
|
Common.Datagram.PeekIrpListHead ) ) {
|
|
|
|
dprintf(
|
|
" PeekIrpListHead = EMPTY\n"
|
|
);
|
|
|
|
} else {
|
|
|
|
dprintf(
|
|
" PeekIrpListHead @ %08lx\n",
|
|
ACTUAL_ADDRESS(
|
|
ActualAddress,
|
|
Endpoint,
|
|
Common.Datagram.PeekIrpListHead
|
|
)
|
|
);
|
|
|
|
}
|
|
|
|
if( IS_LIST_EMPTY(
|
|
ActualAddress,
|
|
Endpoint,
|
|
Common.Datagram.ReceiveBufferListHead ) ) {
|
|
|
|
dprintf(
|
|
" ReceiveBufferListHead = EMPTY\n"
|
|
);
|
|
|
|
} else {
|
|
|
|
dprintf(
|
|
" ReceiveBufferListHead @ %08lx\n",
|
|
ACTUAL_ADDRESS(
|
|
ActualAddress,
|
|
Endpoint,
|
|
Common.Datagram.ReceiveBufferListHead
|
|
)
|
|
);
|
|
|
|
}
|
|
|
|
dprintf(
|
|
" BufferredDatagramBytes = %08lx\n",
|
|
Endpoint->BufferredDatagramBytes
|
|
);
|
|
|
|
dprintf(
|
|
" BufferredDatagramCount = %04X\n",
|
|
Endpoint->BufferredDatagramCount
|
|
);
|
|
|
|
dprintf(
|
|
" MaxBufferredReceiveBytes = %08lx\n",
|
|
Endpoint->Common.Datagram.MaxBufferredReceiveBytes
|
|
);
|
|
|
|
dprintf(
|
|
" MaxBufferredSendBytes = %08lx\n",
|
|
Endpoint->Common.Datagram.MaxBufferredSendBytes
|
|
);
|
|
|
|
dprintf(
|
|
" MaxBufferredReceiveCount = %04X\n",
|
|
Endpoint->Common.Datagram.MaxBufferredReceiveCount
|
|
);
|
|
|
|
dprintf(
|
|
" MaxBufferredSendCount = %04X\n",
|
|
Endpoint->Common.Datagram.MaxBufferredSendCount
|
|
);
|
|
|
|
dprintf(
|
|
" CircularQueueing = %s\n",
|
|
BooleanToString( Endpoint->Common.Datagram.CircularQueueing )
|
|
);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
dprintf(
|
|
" DisconnectMode = %08lx\n",
|
|
Endpoint->DisconnectMode
|
|
);
|
|
|
|
dprintf(
|
|
" OutstandingIrpCount = %08lx\n",
|
|
Endpoint->OutstandingIrpCount
|
|
);
|
|
|
|
dprintf(
|
|
" LocalAddress = %08lx\n",
|
|
Endpoint->LocalAddress
|
|
);
|
|
|
|
dprintf(
|
|
" LocalAddressLength = %08lx\n",
|
|
Endpoint->LocalAddressLength
|
|
);
|
|
|
|
if( Endpoint->LocalAddressLength <= sizeof(address) &&
|
|
Endpoint->LocalAddress != NULL ) {
|
|
|
|
if( ReadMemory(
|
|
(DWORD)Endpoint->LocalAddress,
|
|
address,
|
|
sizeof(address),
|
|
&result
|
|
) ) {
|
|
|
|
DumpTransportAddress(
|
|
" ",
|
|
(PTRANSPORT_ADDRESS)address,
|
|
(DWORD)Endpoint->LocalAddress
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
dprintf(
|
|
" Context = %08lx\n",
|
|
Endpoint->Context
|
|
);
|
|
|
|
dprintf(
|
|
" ContextLength = %08lx\n",
|
|
Endpoint->ContextLength
|
|
);
|
|
|
|
dprintf(
|
|
" OwningProcess = %08lx\n",
|
|
Endpoint->OwningProcess
|
|
);
|
|
|
|
dprintf(
|
|
" ConnectDataBuffers = %08lx\n",
|
|
Endpoint->ConnectDataBuffers
|
|
);
|
|
|
|
dprintf(
|
|
" TransmitIrp = %08lx\n",
|
|
Endpoint->TransmitIrp
|
|
);
|
|
|
|
dprintf(
|
|
" TransmitInfo = %08lx\n",
|
|
Endpoint->TransmitInfo
|
|
);
|
|
|
|
dprintf(
|
|
" AddressDeviceObject = %08lx\n",
|
|
Endpoint->AddressDeviceObject
|
|
);
|
|
|
|
dprintf(
|
|
" ConnectOutstanding = %s\n",
|
|
BooleanToString( Endpoint->ConnectOutstanding )
|
|
);
|
|
|
|
dprintf(
|
|
" SendDisconnected = %s\n",
|
|
BooleanToString( Endpoint->SendDisconnected )
|
|
);
|
|
|
|
dprintf(
|
|
" EndpointCleanedUp = %s\n",
|
|
BooleanToString( Endpoint->EndpointCleanedUp )
|
|
);
|
|
|
|
dprintf(
|
|
" TdiMessageMode = %s\n",
|
|
BooleanToString( Endpoint->TdiMessageMode )
|
|
);
|
|
|
|
#if !defined(NT351)
|
|
dprintf(
|
|
" EventObject = %08lx\n",
|
|
Endpoint->EventObject
|
|
);
|
|
|
|
dprintf(
|
|
" EventsEnabled = %08lx\n",
|
|
Endpoint->EventsEnabled
|
|
);
|
|
|
|
dprintf(
|
|
" EventsDisabled = %08lx\n",
|
|
Endpoint->EventsDisabled
|
|
);
|
|
|
|
dprintf(
|
|
" EventsActive = %08lx\n",
|
|
Endpoint->EventsActive
|
|
);
|
|
|
|
dprintf(
|
|
" EventStatus = %08lx\n",
|
|
ACTUAL_ADDRESS( ActualAddress, Endpoint, EventStatus[0] )
|
|
);
|
|
|
|
dprintf(
|
|
" GroupID = %08lx\n",
|
|
Endpoint->GroupID
|
|
);
|
|
|
|
dprintf(
|
|
" GroupType = %s\n",
|
|
GroupTypeToString( Endpoint->GroupType )
|
|
);
|
|
#endif
|
|
|
|
if( IsCheckedAfd ) {
|
|
|
|
dprintf(
|
|
" ReferenceDebug = %08lx\n",
|
|
Endpoint->ReferenceDebug
|
|
);
|
|
|
|
dprintf(
|
|
" CurrentReferenceSlot = %lu\n",
|
|
Endpoint->CurrentReferenceSlot % MAX_REFERENCE
|
|
);
|
|
|
|
}
|
|
|
|
dprintf( "\n" );
|
|
|
|
} // DumpAfdEndpoint
|
|
|
|
VOID
|
|
DumpAfdConnection(
|
|
PAFD_CONNECTION Connection,
|
|
DWORD ActualAddress
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Dumps the specified AFD_CONNECTION structures.
|
|
|
|
Arguments:
|
|
|
|
Connection - Points to the AFD_CONNECTION structure to dump.
|
|
|
|
ActualAddress - The actual address where the structure resides on the
|
|
debugee.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
UCHAR address[MAX_TRANSPORT_ADDR];
|
|
ULONG result;
|
|
|
|
dprintf(
|
|
"AFD_CONNECTION @ %08lx:\n",
|
|
ActualAddress
|
|
);
|
|
|
|
dprintf(
|
|
" Type = %04X (%s)\n",
|
|
Connection->Type,
|
|
StructureTypeToString( Connection->Type )
|
|
);
|
|
|
|
dprintf(
|
|
" ReferenceCount = %d\n",
|
|
Connection->ReferenceCount
|
|
);
|
|
|
|
dprintf(
|
|
" State = %08X (%s)\n",
|
|
Connection->State,
|
|
ConnectionStateToString( Connection->State )
|
|
);
|
|
|
|
dprintf(
|
|
" Handle = %08lx\n",
|
|
Connection->Handle
|
|
);
|
|
|
|
dprintf(
|
|
" FileObject = %08lx\n",
|
|
Connection->FileObject
|
|
);
|
|
|
|
dprintf(
|
|
" ConnectTime = %s\n",
|
|
SystemTimeToString( Connection->ConnectTime )
|
|
);
|
|
|
|
if( Connection->TdiBufferring )
|
|
{
|
|
dprintf(
|
|
" ReceiveBytesIndicated = %s\n",
|
|
LongLongToString( Connection->Common.Bufferring.ReceiveBytesIndicated.QuadPart )
|
|
);
|
|
|
|
dprintf(
|
|
" ReceiveBytesTaken = %s\n",
|
|
LongLongToString( Connection->Common.Bufferring.ReceiveBytesTaken.QuadPart )
|
|
);
|
|
|
|
dprintf(
|
|
" ReceiveBytesOutstanding = %s\n",
|
|
LongLongToString( Connection->Common.Bufferring.ReceiveBytesOutstanding.QuadPart )
|
|
);
|
|
|
|
dprintf(
|
|
" ReceiveExpeditedBytesIndicated = %s\n",
|
|
LongLongToString( Connection->Common.Bufferring.ReceiveExpeditedBytesIndicated.QuadPart )
|
|
);
|
|
|
|
dprintf(
|
|
" ReceiveExpeditedBytesTaken = %s\n",
|
|
LongLongToString( Connection->Common.Bufferring.ReceiveExpeditedBytesTaken.QuadPart )
|
|
);
|
|
|
|
dprintf(
|
|
" ReceiveExpeditedBytesOutstanding = %s\n",
|
|
LongLongToString( Connection->Common.Bufferring.ReceiveExpeditedBytesOutstanding.QuadPart )
|
|
);
|
|
|
|
dprintf(
|
|
" NonBlockingSendPossible = %s\n",
|
|
BooleanToString( Connection->Common.Bufferring.NonBlockingSendPossible )
|
|
);
|
|
|
|
dprintf(
|
|
" ZeroByteReceiveIndicated = %s\n",
|
|
BooleanToString( Connection->Common.Bufferring.ZeroByteReceiveIndicated )
|
|
);
|
|
}
|
|
else
|
|
{
|
|
if( IS_LIST_EMPTY(
|
|
ActualAddress,
|
|
Connection,
|
|
Common.NonBufferring.ReceiveIrpListHead ) ) {
|
|
|
|
dprintf(
|
|
" ReceiveIrpListHead = EMPTY\n"
|
|
);
|
|
|
|
} else {
|
|
|
|
dprintf(
|
|
" ReceiveIrpListHead @ %08lx\n",
|
|
ACTUAL_ADDRESS(
|
|
ActualAddress,
|
|
Connection,
|
|
Common.NonBufferring.ReceiveIrpListHead
|
|
)
|
|
);
|
|
|
|
}
|
|
|
|
if( IS_LIST_EMPTY(
|
|
ActualAddress,
|
|
Connection,
|
|
Common.NonBufferring.ReceiveBufferListHead ) ) {
|
|
|
|
dprintf(
|
|
" ReceiveBufferListHead = EMPTY\n"
|
|
);
|
|
|
|
} else {
|
|
|
|
dprintf(
|
|
" ReceiveBufferListHead @ %08lx\n",
|
|
ACTUAL_ADDRESS(
|
|
ActualAddress,
|
|
Connection,
|
|
Common.NonBufferring.ReceiveBufferListHead
|
|
)
|
|
);
|
|
|
|
}
|
|
|
|
if( IS_LIST_EMPTY(
|
|
ActualAddress,
|
|
Connection,
|
|
Common.NonBufferring.SendIrpListHead ) ) {
|
|
|
|
dprintf(
|
|
" SendIrpListHead = EMPTY\n"
|
|
);
|
|
|
|
} else {
|
|
|
|
dprintf(
|
|
" SendIrpListHead @ %08lx\n",
|
|
ACTUAL_ADDRESS(
|
|
ActualAddress,
|
|
Connection,
|
|
Common.NonBufferring.SendIrpListHead
|
|
)
|
|
);
|
|
|
|
}
|
|
|
|
dprintf(
|
|
" BufferredReceiveBytes = %lu\n",
|
|
Connection->Common.NonBufferring.BufferredReceiveBytes
|
|
);
|
|
|
|
dprintf(
|
|
" BufferredExpeditedBytes = %lu\n",
|
|
Connection->Common.NonBufferring.BufferredExpeditedBytes
|
|
);
|
|
|
|
dprintf(
|
|
" BufferredReceiveCount = %u\n",
|
|
Connection->Common.NonBufferring.BufferredReceiveCount
|
|
);
|
|
|
|
dprintf(
|
|
" BufferredExpeditedCount = %u\n",
|
|
Connection->Common.NonBufferring.BufferredExpeditedCount
|
|
);
|
|
|
|
dprintf(
|
|
" ReceiveBytesInTransport = %lu\n",
|
|
Connection->Common.NonBufferring.ReceiveBytesInTransport
|
|
);
|
|
|
|
dprintf(
|
|
" BufferredSendBytes = %lu\n",
|
|
Connection->Common.NonBufferring.BufferredSendBytes
|
|
);
|
|
|
|
dprintf(
|
|
" ReceiveCountInTransport = %u\n",
|
|
Connection->Common.NonBufferring.ReceiveCountInTransport
|
|
);
|
|
|
|
dprintf(
|
|
" BufferredSendCount = %u\n",
|
|
Connection->Common.NonBufferring.BufferredSendCount
|
|
);
|
|
|
|
dprintf(
|
|
" DisconnectIrp = %08lx\n",
|
|
Connection->Common.NonBufferring.DisconnectIrp
|
|
);
|
|
}
|
|
|
|
dprintf(
|
|
" Endpoint = %08lx\n",
|
|
Connection->Endpoint
|
|
);
|
|
|
|
dprintf(
|
|
" MaxBufferredReceiveBytes = %lu\n",
|
|
Connection->MaxBufferredReceiveBytes
|
|
);
|
|
|
|
dprintf(
|
|
" MaxBufferredSendBytes = %lu\n",
|
|
Connection->MaxBufferredSendBytes
|
|
);
|
|
|
|
dprintf(
|
|
" MaxBufferredReceiveCount = %u\n",
|
|
Connection->MaxBufferredReceiveCount
|
|
);
|
|
|
|
dprintf(
|
|
" MaxBufferredSendCount = %u\n",
|
|
Connection->MaxBufferredSendCount
|
|
);
|
|
|
|
dprintf(
|
|
" ConnectDataBuffers = %08lx\n",
|
|
Connection->ConnectDataBuffers
|
|
);
|
|
|
|
dprintf(
|
|
" OwningProcess = %08lx\n",
|
|
Connection->OwningProcess
|
|
);
|
|
|
|
dprintf(
|
|
" DeviceObject = %08lx\n",
|
|
Connection->DeviceObject
|
|
);
|
|
|
|
dprintf(
|
|
" RemoteAddress = %08lx\n",
|
|
Connection->RemoteAddress
|
|
);
|
|
|
|
dprintf(
|
|
" RemoteAddressLength = %lu\n",
|
|
Connection->RemoteAddressLength
|
|
);
|
|
|
|
if( Connection->RemoteAddressLength <= sizeof(address) &&
|
|
Connection->RemoteAddress != NULL ) {
|
|
|
|
if( ReadMemory(
|
|
(DWORD)Connection->RemoteAddress,
|
|
address,
|
|
sizeof(address),
|
|
&result
|
|
) ) {
|
|
|
|
DumpTransportAddress(
|
|
" ",
|
|
(PTRANSPORT_ADDRESS)address,
|
|
(DWORD)Connection->RemoteAddress
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
dprintf(
|
|
" DisconnectIndicated = %s\n",
|
|
BooleanToString( Connection->DisconnectIndicated )
|
|
);
|
|
|
|
dprintf(
|
|
" AbortIndicated = %s\n",
|
|
BooleanToString( Connection->AbortIndicated )
|
|
);
|
|
|
|
dprintf(
|
|
" TdiBufferring = %s\n",
|
|
BooleanToString( Connection->TdiBufferring )
|
|
);
|
|
|
|
dprintf(
|
|
" ConnectedReferenceAdded = %s\n",
|
|
BooleanToString( Connection->ConnectedReferenceAdded )
|
|
);
|
|
|
|
dprintf(
|
|
" SpecialCondition = %s\n",
|
|
BooleanToString( Connection->SpecialCondition )
|
|
);
|
|
|
|
dprintf(
|
|
" CleanupBegun = %s\n",
|
|
BooleanToString( Connection->CleanupBegun )
|
|
);
|
|
|
|
dprintf(
|
|
" ClosePendedTransmit = %s\n",
|
|
BooleanToString( Connection->ClosePendedTransmit )
|
|
);
|
|
|
|
if( IsCheckedAfd ) {
|
|
|
|
dprintf(
|
|
" CurrentReferenceSlot = %lu\n",
|
|
Connection->CurrentReferenceSlot % MAX_REFERENCE
|
|
);
|
|
|
|
dprintf(
|
|
" ReferenceDebug = %08lx\n",
|
|
ACTUAL_ADDRESS(
|
|
ActualAddress,
|
|
Connection,
|
|
ReferenceDebug
|
|
)
|
|
);
|
|
|
|
}
|
|
|
|
dprintf( "\n" );
|
|
|
|
} // DumpAfdConnection
|
|
|
|
VOID
|
|
DumpAfdConnectionReferenceDebug(
|
|
PAFD_REFERENCE_DEBUG ReferenceDebug,
|
|
DWORD ActualAddress
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Dumps the AFD_REFERENCE_DEBUG structures associated with an
|
|
AFD_CONNECTION object.
|
|
|
|
Arguments:
|
|
|
|
ReferenceDebug - Points to an array of AFD_REFERENCE_DEBUG structures.
|
|
There are assumed to be MAX_REFERENCE entries in this array.
|
|
|
|
ActualAddress - The actual address where the array resides on the
|
|
debugee.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
ULONG i;
|
|
ULONG result;
|
|
LPSTR fileName;
|
|
CHAR filePath[MAX_PATH];
|
|
CHAR action[16];
|
|
|
|
dprintf(
|
|
"AFD_REFERENCE_DEBUG @ %08lx\n",
|
|
ActualAddress
|
|
);
|
|
|
|
for( i = 0 ; i < MAX_REFERENCE ; i++, ReferenceDebug++ ) {
|
|
|
|
if( CheckControlC() ) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if( ReferenceDebug->Info1 == NULL &&
|
|
ReferenceDebug->Info2 == NULL &&
|
|
ReferenceDebug->Action == 0 &&
|
|
ReferenceDebug->NewCount == 0 ) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if( ReferenceDebug->Action == 0 ||
|
|
ReferenceDebug->Action == 1 ||
|
|
ReferenceDebug->Action == (ULONG)-1L ) {
|
|
|
|
sprintf(
|
|
action,
|
|
"%ld",
|
|
ReferenceDebug->Action
|
|
);
|
|
|
|
} else {
|
|
|
|
sprintf(
|
|
action,
|
|
"%08lx",
|
|
ReferenceDebug->Action
|
|
);
|
|
|
|
}
|
|
|
|
switch( (DWORD)ReferenceDebug->Info1 ) {
|
|
|
|
case 0xafdafd02 :
|
|
dprintf(
|
|
" %3lu: Buffered Send, IRP @ %08lx [%s] -> %lu\n",
|
|
i,
|
|
ReferenceDebug->Info2,
|
|
action,
|
|
ReferenceDebug->NewCount
|
|
);
|
|
break;
|
|
|
|
case 0xafdafd03 :
|
|
dprintf(
|
|
" %3lu: Nonbuffered Send, IRP @ %08lx [%s] -> %lu\n",
|
|
i,
|
|
ReferenceDebug->Info2,
|
|
action,
|
|
ReferenceDebug->NewCount
|
|
);
|
|
break;
|
|
|
|
case 0xafd11100 :
|
|
case 0xafd11101 :
|
|
dprintf(
|
|
" %3lu: AfdRestartSend (%08lx), IRP @ %08lx [%s] -> %lu\n",
|
|
i,
|
|
ReferenceDebug->Info1,
|
|
ReferenceDebug->Info2,
|
|
action,
|
|
ReferenceDebug->NewCount
|
|
);
|
|
break;
|
|
|
|
case 0xafd11102 :
|
|
case 0xafd11103 :
|
|
case 0xafd11104 :
|
|
case 0xafd11105 :
|
|
dprintf(
|
|
" %3lu: AfdRestartBufferSend (%08lx), IRP @ %08lx [%s] -> %lu\n",
|
|
i,
|
|
ReferenceDebug->Info1,
|
|
ReferenceDebug->Info2,
|
|
action,
|
|
ReferenceDebug->NewCount
|
|
);
|
|
break;
|
|
|
|
case 0 :
|
|
if( ReferenceDebug->Info2 == NULL ) {
|
|
|
|
dprintf(
|
|
" %3lu: AfdDeleteConnectedReference (%08lx)\n",
|
|
i,
|
|
ReferenceDebug->Action
|
|
);
|
|
break;
|
|
|
|
} else {
|
|
|
|
//
|
|
// Fall through to default case.
|
|
//
|
|
|
|
}
|
|
|
|
default :
|
|
if( ReadMemory(
|
|
(DWORD)ReferenceDebug->Info1,
|
|
filePath,
|
|
sizeof(filePath),
|
|
&result
|
|
) ) {
|
|
|
|
fileName = strrchr( filePath, '\\' );
|
|
|
|
if( fileName != NULL ) {
|
|
|
|
fileName++;
|
|
|
|
} else {
|
|
|
|
fileName = filePath;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
sprintf(
|
|
filePath,
|
|
"%08lx",
|
|
ReferenceDebug->Info1
|
|
);
|
|
|
|
fileName = filePath;
|
|
|
|
}
|
|
|
|
dprintf(
|
|
" %3lu: %s:%lu [%s] -> %lu\n",
|
|
i,
|
|
fileName,
|
|
ReferenceDebug->Info2,
|
|
action,
|
|
ReferenceDebug->NewCount
|
|
);
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} // DumpAfdConnectionReferenceDebug
|
|
|
|
VOID
|
|
DumpAfdEndpointReferenceDebug(
|
|
PAFD_REFERENCE_DEBUG ReferenceDebug,
|
|
DWORD ActualAddress
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Dumps the AFD_REFERENCE_DEBUG structures associated with an
|
|
AFD_ENDPOINT object.
|
|
|
|
Arguments:
|
|
|
|
ReferenceDebug - Points to an array of AFD_REFERENCE_DEBUG structures.
|
|
There are assumed to be MAX_REFERENCE entries in this array.
|
|
|
|
ActualAddress - The actual address where the array resides on the
|
|
debugee.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
ULONG i;
|
|
ULONG result;
|
|
LPSTR fileName;
|
|
CHAR filePath[MAX_PATH];
|
|
CHAR action[16];
|
|
|
|
dprintf(
|
|
"AFD_REFERENCE_DEBUG @ %08lx\n",
|
|
ActualAddress
|
|
);
|
|
|
|
for( i = 0 ; i < MAX_REFERENCE ; i++, ReferenceDebug++ ) {
|
|
|
|
if( CheckControlC() ) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if( ReferenceDebug->Info1 == NULL &&
|
|
ReferenceDebug->Info2 == NULL &&
|
|
ReferenceDebug->Action == 0 &&
|
|
ReferenceDebug->NewCount == 0 ) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if( ReferenceDebug->Action == 0 ||
|
|
ReferenceDebug->Action == 1 ||
|
|
ReferenceDebug->Action == (ULONG)-1L ) {
|
|
|
|
sprintf(
|
|
action,
|
|
"%ld",
|
|
ReferenceDebug->Action
|
|
);
|
|
|
|
} else {
|
|
|
|
sprintf(
|
|
action,
|
|
"%08lx",
|
|
ReferenceDebug->Action
|
|
);
|
|
|
|
}
|
|
|
|
if( ReadMemory(
|
|
(DWORD)ReferenceDebug->Info1,
|
|
filePath,
|
|
sizeof(filePath),
|
|
&result
|
|
) ) {
|
|
|
|
fileName = strrchr( filePath, '\\' );
|
|
|
|
if( fileName != NULL ) {
|
|
|
|
fileName++;
|
|
|
|
} else {
|
|
|
|
fileName = filePath;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
sprintf(
|
|
filePath,
|
|
"%08lx",
|
|
ReferenceDebug->Info1
|
|
);
|
|
|
|
fileName = filePath;
|
|
|
|
}
|
|
|
|
dprintf(
|
|
" %3lu: %s:%lu [%s] -> %ld\n",
|
|
i,
|
|
fileName,
|
|
ReferenceDebug->Info2,
|
|
action,
|
|
ReferenceDebug->NewCount
|
|
);
|
|
|
|
}
|
|
|
|
} // DumpAfdEndpointReferenceDebug
|
|
|
|
#if GLOBAL_REFERENCE_DEBUG
|
|
BOOL
|
|
DumpAfdGlobalReferenceDebug(
|
|
PAFD_GLOBAL_REFERENCE_DEBUG ReferenceDebug,
|
|
DWORD ActualAddress,
|
|
DWORD CurrentSlot,
|
|
DWORD StartingSlot,
|
|
DWORD NumEntries,
|
|
DWORD CompareAddress
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Dumps the AFD_GLOBAL_REFERENCE_DEBUG structures.
|
|
|
|
Arguments:
|
|
|
|
ReferenceDebug - Points to an array of AFD_GLOBAL_REFERENCE_DEBUG
|
|
structures. There are assumed to be MAX_GLOBAL_REFERENCE entries
|
|
in this array.
|
|
|
|
ActualAddress - The actual address where the array resides on the
|
|
debugee.
|
|
|
|
CurrentSlot - The last slot used.
|
|
|
|
CompareAddress - If zero, then dump all records. Otherwise, only dump
|
|
those records with a matching connection pointer.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
ULONG result;
|
|
LPSTR fileName;
|
|
CHAR decoration;
|
|
CHAR filePath[MAX_PATH];
|
|
CHAR action[16];
|
|
BOOL foundEnd = FALSE;
|
|
ULONG lowTick;
|
|
|
|
if( StartingSlot == 0 ) {
|
|
|
|
dprintf(
|
|
"AFD_GLOBAL_REFERENCE_DEBUG @ %08lx, Current Slot = %lu\n",
|
|
ActualAddress,
|
|
CurrentSlot
|
|
);
|
|
|
|
}
|
|
|
|
for( ; NumEntries > 0 ; NumEntries--, StartingSlot++, ReferenceDebug++ ) {
|
|
|
|
if( CheckControlC() ) {
|
|
|
|
foundEnd = TRUE;
|
|
break;
|
|
|
|
}
|
|
|
|
if( ReferenceDebug->Info1 == NULL &&
|
|
ReferenceDebug->Info2 == NULL &&
|
|
ReferenceDebug->Action == 0 &&
|
|
ReferenceDebug->NewCount == 0 &&
|
|
ReferenceDebug->Connection == NULL ) {
|
|
|
|
foundEnd = TRUE;
|
|
break;
|
|
|
|
}
|
|
|
|
if( CompareAddress != 0 &&
|
|
ReferenceDebug->Connection != (PVOID)CompareAddress ) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if( ReferenceDebug->Action == 0 ||
|
|
ReferenceDebug->Action == 1 ||
|
|
ReferenceDebug->Action == (ULONG)-1L ) {
|
|
|
|
sprintf(
|
|
action,
|
|
"%ld",
|
|
ReferenceDebug->Action
|
|
);
|
|
|
|
} else {
|
|
|
|
sprintf(
|
|
action,
|
|
"%08lx",
|
|
ReferenceDebug->Action
|
|
);
|
|
|
|
}
|
|
|
|
decoration = ( StartingSlot == CurrentSlot ) ? '>' : ' ';
|
|
lowTick = ReferenceDebug->TickCounter.LowPart;
|
|
|
|
switch( (DWORD)ReferenceDebug->Info1 ) {
|
|
|
|
case 0xafdafd02 :
|
|
dprintf(
|
|
"%c %3lu: %08lx (%8lu) Buffered Send, IRP @ %08lx [%s] -> %lu\n",
|
|
decoration,
|
|
StartingSlot,
|
|
ReferenceDebug->Connection,
|
|
lowTick,
|
|
ReferenceDebug->Info2,
|
|
action,
|
|
ReferenceDebug->NewCount
|
|
);
|
|
break;
|
|
|
|
case 0xafdafd03 :
|
|
dprintf(
|
|
"%c %3lu: %08lx (%8lu) Nonbuffered Send, IRP @ %08lx [%s] -> %lu\n",
|
|
decoration,
|
|
StartingSlot,
|
|
ReferenceDebug->Connection,
|
|
lowTick,
|
|
ReferenceDebug->Info2,
|
|
action,
|
|
ReferenceDebug->NewCount
|
|
);
|
|
break;
|
|
|
|
case 0xafd11100 :
|
|
case 0xafd11101 :
|
|
dprintf(
|
|
"%c %3lu: %08lx (%8lu) AfdRestartSend (%08lx), IRP @ %08lx [%s] -> %lu\n",
|
|
decoration,
|
|
StartingSlot,
|
|
ReferenceDebug->Connection,
|
|
lowTick,
|
|
ReferenceDebug->Info1,
|
|
ReferenceDebug->Info2,
|
|
action,
|
|
ReferenceDebug->NewCount
|
|
);
|
|
break;
|
|
|
|
case 0xafd11102 :
|
|
case 0xafd11103 :
|
|
case 0xafd11104 :
|
|
case 0xafd11105 :
|
|
dprintf(
|
|
"%c %3lu: %08lx (%8lu) AfdRestartBufferSend (%08lx), IRP @ %08lx [%s] -> %lu\n",
|
|
decoration,
|
|
StartingSlot,
|
|
ReferenceDebug->Connection,
|
|
lowTick,
|
|
ReferenceDebug->Info1,
|
|
ReferenceDebug->Info2,
|
|
action,
|
|
ReferenceDebug->NewCount
|
|
);
|
|
break;
|
|
|
|
case 0 :
|
|
if( ReferenceDebug->Info2 == NULL ) {
|
|
|
|
dprintf(
|
|
"%c %3lu: %08lx (%8lu) AfdDeleteConnectedReference (%08lx)\n",
|
|
decoration,
|
|
StartingSlot,
|
|
ReferenceDebug->Connection,
|
|
lowTick,
|
|
ReferenceDebug->Action
|
|
);
|
|
break;
|
|
|
|
} else {
|
|
|
|
//
|
|
// Fall through to default case.
|
|
//
|
|
|
|
}
|
|
|
|
default :
|
|
if( ReadMemory(
|
|
(DWORD)ReferenceDebug->Info1,
|
|
filePath,
|
|
sizeof(filePath),
|
|
&result
|
|
) ) {
|
|
|
|
fileName = strrchr( filePath, '\\' );
|
|
|
|
if( fileName != NULL ) {
|
|
|
|
fileName++;
|
|
|
|
} else {
|
|
|
|
fileName = filePath;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
sprintf(
|
|
filePath,
|
|
"%08lx",
|
|
ReferenceDebug->Info1
|
|
);
|
|
|
|
fileName = filePath;
|
|
|
|
}
|
|
|
|
dprintf(
|
|
"%c %3lu: %08lx (%8lu) %s:%lu [%s] -> %lu\n",
|
|
decoration,
|
|
StartingSlot,
|
|
ReferenceDebug->Connection,
|
|
lowTick,
|
|
fileName,
|
|
ReferenceDebug->Info2,
|
|
action,
|
|
ReferenceDebug->NewCount
|
|
);
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return foundEnd;
|
|
|
|
} // DumpAfdGlobalReferenceDebug
|
|
#endif
|
|
|
|
VOID
|
|
DumpAfdTransmitInfo(
|
|
PAFD_TRANSMIT_FILE_INFO_INTERNAL TransmitInfo,
|
|
DWORD ActualAddress
|
|
)
|
|
{
|
|
|
|
dprintf(
|
|
"AFD_TRANSMIT_FILE_INFO_INTERNAL @ %08lx\n",
|
|
ActualAddress
|
|
);
|
|
|
|
dprintf(
|
|
" Offset = %s\n",
|
|
LongLongToString( TransmitInfo->Offset )
|
|
);
|
|
|
|
dprintf(
|
|
" FileWriteLength = %s\n",
|
|
LongLongToString( TransmitInfo->FileWriteLength )
|
|
);
|
|
|
|
dprintf(
|
|
" SendPacketLength = %08lx\n",
|
|
TransmitInfo->SendPacketLength
|
|
);
|
|
|
|
dprintf(
|
|
" FileHandle = %08lx\n",
|
|
TransmitInfo->FileHandle
|
|
);
|
|
|
|
dprintf(
|
|
" Head = %08lx\n",
|
|
TransmitInfo->Head
|
|
);
|
|
|
|
dprintf(
|
|
" HeadLength = %08lx\n",
|
|
TransmitInfo->HeadLength
|
|
);
|
|
|
|
dprintf(
|
|
" Tail = %08lx\n",
|
|
TransmitInfo->Tail
|
|
);
|
|
|
|
dprintf(
|
|
" TailLength = %08lx\n",
|
|
TransmitInfo->TailLength
|
|
);
|
|
|
|
dprintf(
|
|
" Flags = %08lx\n",
|
|
TransmitInfo->Flags
|
|
);
|
|
|
|
dprintf(
|
|
" _Dummy = %08lx\n",
|
|
TransmitInfo->_Dummy
|
|
);
|
|
|
|
dprintf(
|
|
" TotalBytesToSend = %s\n",
|
|
LongLongToString( TransmitInfo->TotalBytesToSend )
|
|
);
|
|
|
|
dprintf(
|
|
" BytesRead = %s\n",
|
|
LongLongToString( TransmitInfo->BytesRead )
|
|
);
|
|
|
|
dprintf(
|
|
" BytesSent = %s\n",
|
|
LongLongToString( TransmitInfo->BytesSent )
|
|
);
|
|
|
|
dprintf(
|
|
" FileObject = %08lx\n",
|
|
TransmitInfo->FileObject
|
|
);
|
|
|
|
dprintf(
|
|
" DeviceObject = %08lx\n",
|
|
TransmitInfo->DeviceObject
|
|
);
|
|
|
|
dprintf(
|
|
" TdiFileObject = %08lx\n",
|
|
TransmitInfo->TdiFileObject
|
|
);
|
|
|
|
dprintf(
|
|
" TdiDeviceObject = %08lx\n",
|
|
TransmitInfo->TdiDeviceObject
|
|
);
|
|
|
|
dprintf(
|
|
" TransmitIrp = %08lx\n",
|
|
TransmitInfo->TransmitIrp
|
|
);
|
|
|
|
dprintf(
|
|
" Endpoint = %08lx\n",
|
|
TransmitInfo->Endpoint
|
|
);
|
|
|
|
dprintf(
|
|
" FileMdl = %08lx\n",
|
|
TransmitInfo->FileMdl
|
|
);
|
|
|
|
dprintf(
|
|
" HeadMdl = %08lx\n",
|
|
TransmitInfo->HeadMdl
|
|
);
|
|
|
|
dprintf(
|
|
" TailMdl = %08lx\n",
|
|
TransmitInfo->TailMdl
|
|
);
|
|
|
|
dprintf(
|
|
" FirstFileMdlAfterHead = %08lx\n",
|
|
TransmitInfo->FirstFileMdlAfterHead
|
|
);
|
|
|
|
dprintf(
|
|
" LastFileMdlBeforeTail = %08lx\n",
|
|
TransmitInfo->LastFileMdlBeforeTail
|
|
);
|
|
|
|
dprintf(
|
|
" IrpUsedTOSendTail = %08lx\n",
|
|
TransmitInfo->IrpUsedToSendTail
|
|
);
|
|
|
|
dprintf(
|
|
" FileMdlLength = %08lx\n",
|
|
TransmitInfo->FileMdlLength
|
|
);
|
|
|
|
dprintf(
|
|
" ReadPending = %s\n",
|
|
BooleanToString( TransmitInfo->ReadPending )
|
|
);
|
|
|
|
dprintf(
|
|
" CompletionPending = %s\n",
|
|
BooleanToString( TransmitInfo->CompletionPending )
|
|
);
|
|
|
|
dprintf(
|
|
" NeedToSendHead = %s\n",
|
|
BooleanToString( TransmitInfo->NeedToSendHead )
|
|
);
|
|
|
|
dprintf(
|
|
" Queued = %s\n",
|
|
BooleanToString( TransmitInfo->Queued )
|
|
);
|
|
|
|
dprintf(
|
|
" Read.Irp = %08lx%s\n",
|
|
TransmitInfo->Read.Irp,
|
|
IsTransmitIrpBusy( TransmitInfo->Read.Irp )
|
|
? " (BUSY)"
|
|
: ""
|
|
);
|
|
|
|
dprintf(
|
|
" Read.AfdBuffer = %08lx\n",
|
|
TransmitInfo->Read.AfdBuffer
|
|
);
|
|
|
|
dprintf(
|
|
" Read.Length = %08lx\n",
|
|
TransmitInfo->Read.Length
|
|
);
|
|
|
|
dprintf(
|
|
" Send1.Irp = %08lx%s\n",
|
|
TransmitInfo->Send1.Irp,
|
|
IsTransmitIrpBusy( TransmitInfo->Send1.Irp )
|
|
? " (BUSY)"
|
|
: ""
|
|
);
|
|
|
|
dprintf(
|
|
" Send1.AfdBuffer = %08lx\n",
|
|
TransmitInfo->Send1.AfdBuffer
|
|
);
|
|
|
|
dprintf(
|
|
" Send1.Length = %08lx\n",
|
|
TransmitInfo->Send1.Length
|
|
);
|
|
|
|
dprintf(
|
|
" Send2.Irp = %08lx%s\n",
|
|
TransmitInfo->Send2.Irp,
|
|
IsTransmitIrpBusy( TransmitInfo->Send2.Irp )
|
|
? " (BUSY)"
|
|
: ""
|
|
);
|
|
|
|
dprintf(
|
|
" Send2.AfdBuffer = %08lx\n",
|
|
TransmitInfo->Send2.AfdBuffer
|
|
);
|
|
|
|
dprintf(
|
|
" Send2.Length = %08lx\n",
|
|
TransmitInfo->Send2.Length
|
|
);
|
|
|
|
dprintf( "\n" );
|
|
|
|
} // DumpAfdTransmitInfo
|
|
|
|
VOID
|
|
DumpAfdBuffer(
|
|
PAFD_BUFFER Buffer,
|
|
DWORD ActualAddress
|
|
)
|
|
{
|
|
|
|
dprintf(
|
|
"AFD_BUFFER @ %08lx\n",
|
|
ActualAddress
|
|
);
|
|
|
|
dprintf(
|
|
" BufferListHead = %08lx\n",
|
|
Buffer->BufferListHead
|
|
);
|
|
|
|
dprintf(
|
|
" NextBuffer = %08lx\n",
|
|
Buffer->NextBuffer
|
|
);
|
|
|
|
dprintf(
|
|
" Buffer = %08lx\n",
|
|
Buffer->Buffer
|
|
);
|
|
|
|
dprintf(
|
|
" BufferLength = %08lx\n",
|
|
Buffer->BufferLength
|
|
);
|
|
|
|
dprintf(
|
|
" DataLength = %08lx\n",
|
|
Buffer->DataLength
|
|
);
|
|
|
|
dprintf(
|
|
" DataOffset = %08lx\n",
|
|
Buffer->DataOffset
|
|
);
|
|
|
|
dprintf(
|
|
" Irp = %08lx\n",
|
|
Buffer->Irp
|
|
);
|
|
|
|
dprintf(
|
|
" Mdl = %08lx\n",
|
|
Buffer->Mdl
|
|
);
|
|
|
|
dprintf(
|
|
" Context = %08lx\n",
|
|
Buffer->Context
|
|
);
|
|
|
|
dprintf(
|
|
" SourceAddress = %08lx\n",
|
|
Buffer->SourceAddress
|
|
);
|
|
|
|
dprintf(
|
|
" SourceAddressLength = %08lx\n",
|
|
Buffer->SourceAddressLength
|
|
);
|
|
|
|
dprintf(
|
|
" FileObject = %08lx\n",
|
|
Buffer->FileObject
|
|
);
|
|
|
|
dprintf(
|
|
" AllocatedAddressLength = %04X\n",
|
|
Buffer->AllocatedAddressLength
|
|
);
|
|
|
|
dprintf(
|
|
" ExpeditedData = %s\n",
|
|
BooleanToString( Buffer->ExpeditedData )
|
|
);
|
|
|
|
dprintf(
|
|
" PartialMessage = %s\n",
|
|
BooleanToString( Buffer->PartialMessage )
|
|
);
|
|
|
|
#if DBG
|
|
if( IsCheckedAfd ) {
|
|
|
|
dprintf(
|
|
" TotalChainLength = %08lx\n",
|
|
Buffer->TotalChainLength
|
|
);
|
|
|
|
}
|
|
#endif
|
|
|
|
dprintf( "\n" );
|
|
|
|
} // DumpAfdBuffer
|
|
|
|
|
|
//
|
|
// Private functions.
|
|
//
|
|
|
|
PSTR
|
|
StructureTypeToString(
|
|
USHORT Type
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Maps an AFD structure type to a displayable string.
|
|
|
|
Arguments:
|
|
|
|
Type - The AFD structure type to map.
|
|
|
|
Return Value:
|
|
|
|
PSTR - Points to the displayable form of the structure type.
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
switch( Type ) {
|
|
|
|
case AfdBlockTypeEndpoint :
|
|
return "Endpoint";
|
|
|
|
case AfdBlockTypeVcConnecting :
|
|
return "VcConnecting";
|
|
|
|
case AfdBlockTypeVcListening :
|
|
return "VcListening";
|
|
|
|
case AfdBlockTypeDatagram :
|
|
return "Datagram";
|
|
|
|
case AfdBlockTypeConnection :
|
|
return "Connection";
|
|
|
|
#if !defined(NT351)
|
|
case AfdBlockTypeHelper :
|
|
return "Helper";
|
|
#endif
|
|
|
|
}
|
|
|
|
return "INVALID";
|
|
|
|
} // StructureTypeToString
|
|
|
|
PSTR
|
|
BooleanToString(
|
|
BOOLEAN Flag
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Maps a BOOELEAN to a displayable form.
|
|
|
|
Arguments:
|
|
|
|
Flag - The BOOLEAN to map.
|
|
|
|
Return Value:
|
|
|
|
PSTR - Points to the displayable form of the BOOLEAN.
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
return Flag ? "TRUE" : "FALSE";
|
|
|
|
} // BooleanToString
|
|
|
|
PSTR
|
|
EndpointStateToString(
|
|
UCHAR State
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Maps an AFD endpoint state to a displayable string.
|
|
|
|
Arguments:
|
|
|
|
State - The AFD endpoint state to map.
|
|
|
|
Return Value:
|
|
|
|
PSTR - Points to the displayable form of the AFD endpoint state.
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
switch( State ) {
|
|
|
|
case AfdEndpointStateOpen :
|
|
return "Open";
|
|
|
|
case AfdEndpointStateBound :
|
|
return "Bound";
|
|
|
|
case AfdEndpointStateListening :
|
|
return "Listening";
|
|
|
|
case AfdEndpointStateConnected :
|
|
return "Connected";
|
|
|
|
case AfdEndpointStateCleanup :
|
|
return "Cleanup";
|
|
|
|
case AfdEndpointStateClosing :
|
|
return "Closing";
|
|
|
|
case AfdEndpointStateTransmitClosing :
|
|
return "Transmit Closing";
|
|
|
|
#if !defined(NT351)
|
|
case AfdEndpointStateInvalid :
|
|
return "Invalid";
|
|
#endif
|
|
|
|
}
|
|
|
|
return "INVALID";
|
|
|
|
} // EndpointStateToString
|
|
|
|
PSTR
|
|
EndpointTypeToString(
|
|
AFD_ENDPOINT_TYPE Type
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Maps an AFD_ENDPOINT_TYPE to a displayable string.
|
|
|
|
Arguments:
|
|
|
|
Type - The AFD_ENDPOINT_TYPE to map.
|
|
|
|
Return Value:
|
|
|
|
PSTR - Points to the displayable form of the AFD_ENDPOINT_TYPE.
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
switch( Type ) {
|
|
|
|
case AfdEndpointTypeStream :
|
|
return "Stream";
|
|
|
|
case AfdEndpointTypeDatagram :
|
|
return "Datagram";
|
|
|
|
case AfdEndpointTypeRaw :
|
|
return "Raw";
|
|
|
|
case AfdEndpointTypeSequencedPacket :
|
|
return "SequencedPacket";
|
|
|
|
case AfdEndpointTypeReliableMessage :
|
|
return "ReliableMessage";
|
|
|
|
case AfdEndpointTypeUnknown :
|
|
return "Unknown";
|
|
|
|
}
|
|
|
|
return "INVALID";
|
|
|
|
} // EndpointTypeToString
|
|
|
|
PSTR
|
|
ConnectionStateToString(
|
|
USHORT State
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Maps an AFD connection state to a displayable string.
|
|
|
|
Arguments:
|
|
|
|
State - The AFD connection state to map.
|
|
|
|
Return Value:
|
|
|
|
PSTR - Points to the displayable form of the AFD connection state.
|
|
|
|
--*/
|
|
|
|
{
|
|
switch( State ) {
|
|
|
|
case AfdConnectionStateFree :
|
|
return "Free";
|
|
|
|
case AfdConnectionStateUnaccepted :
|
|
return "Unaccepted";
|
|
|
|
case AfdConnectionStateReturned :
|
|
return "Returned";
|
|
|
|
case AfdConnectionStateConnected :
|
|
return "Connected";
|
|
|
|
case AfdConnectionStateClosing :
|
|
return "Closing";
|
|
|
|
}
|
|
|
|
return "INVALID";
|
|
|
|
} // ConnectionStateToString
|
|
|
|
PSTR
|
|
SystemTimeToString(
|
|
LONGLONG Value
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Maps a LONGLONG representing system time to a displayable string.
|
|
|
|
Arguments:
|
|
|
|
Value - The LONGLONG time to map.
|
|
|
|
Return Value:
|
|
|
|
PSTR - Points to the displayable form of the system time.
|
|
|
|
Notes:
|
|
|
|
This routine is NOT multithread safe!
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
static char buffer[64];
|
|
NTSTATUS status;
|
|
LARGE_INTEGER systemTime;
|
|
LARGE_INTEGER localTime;
|
|
TIME_FIELDS timeFields;
|
|
|
|
systemTime.QuadPart = Value;
|
|
|
|
status = RtlSystemTimeToLocalTime( &systemTime, &localTime );
|
|
|
|
if( !NT_SUCCESS(status) ) {
|
|
|
|
return LongLongToString( Value );
|
|
|
|
}
|
|
|
|
RtlTimeToTimeFields( &localTime, &timeFields );
|
|
|
|
sprintf(
|
|
buffer,
|
|
"%s %s %2d %4d %02d:%02d:%02d.%03d",
|
|
WeekdayNames[timeFields.Weekday],
|
|
MonthNames[timeFields.Month],
|
|
timeFields.Day,
|
|
timeFields.Year,
|
|
timeFields.Hour,
|
|
timeFields.Minute,
|
|
timeFields.Second,
|
|
timeFields.Milliseconds
|
|
);
|
|
|
|
return buffer;
|
|
|
|
} // SystemTimeToString
|
|
|
|
|
|
BOOL
|
|
IsTransmitIrpBusy(
|
|
PIRP Irp
|
|
)
|
|
{
|
|
IRP localIrp;
|
|
ULONG result;
|
|
|
|
if( Irp == NULL ) {
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
if( !ReadMemory(
|
|
(DWORD)Irp,
|
|
&localIrp,
|
|
sizeof(localIrp),
|
|
&result
|
|
) ) {
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
return localIrp.UserIosb != 0;
|
|
|
|
} // IsTransmitIrpBusy
|
|
|
|
PSTR
|
|
GroupTypeToString(
|
|
AFD_GROUP_TYPE GroupType
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Maps an AFD_GROUP_TYPE to a displayable string.
|
|
|
|
Arguments:
|
|
|
|
GroupType - The AFD_GROUP_TYPE to map.
|
|
|
|
Return Value:
|
|
|
|
PSTR - Points to the displayable form of the AFD_GROUP_TYPE.
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
switch( GroupType ) {
|
|
|
|
case GroupTypeNeither :
|
|
return "Neither";
|
|
|
|
case GroupTypeConstrained :
|
|
return "Constrained";
|
|
|
|
case GroupTypeUnconstrained :
|
|
return "Unconstrained";
|
|
|
|
}
|
|
|
|
return "INVALID";
|
|
|
|
} // GroupTypeToString
|
|
|