mirror of https://github.com/tongzx/nt5src
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.
762 lines
20 KiB
762 lines
20 KiB
/*++
|
|
|
|
Copyright (c) 1995-1997 Microsoft Corporation
|
|
|
|
Module Name :
|
|
|
|
dbgatq.cxx
|
|
|
|
Abstract:
|
|
|
|
This module contains the NTSD Debugger extensions for the
|
|
Asynchronous Thread Queue DLL
|
|
|
|
Author:
|
|
|
|
Murali R. Krishnan ( MuraliK ) 12-May-1997
|
|
|
|
Environment:
|
|
Debugger Mode - inside NT command line debuggers
|
|
|
|
Project:
|
|
|
|
Internet Server Debugging DLL
|
|
|
|
Functions Exported:
|
|
|
|
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
|
|
/************************************************************
|
|
* Include Headers
|
|
************************************************************/
|
|
|
|
|
|
#include "inetdbgp.h"
|
|
|
|
|
|
/************************************************************
|
|
* Definitions of Variables & Macros
|
|
************************************************************/
|
|
|
|
//
|
|
// Text names of ATQ_SOCK_STATE values
|
|
//
|
|
|
|
char * AtqSockState[] = {
|
|
"ATQ_SOCK_CLOSED",
|
|
"ATQ_SOCK_UNCONNECTED",
|
|
"ATQ_SOCK_LISTENING",
|
|
"ATQ_SOCK_CONNECTED"
|
|
};
|
|
|
|
char * AtqEndpointState[] = {
|
|
"AtqStateInit",
|
|
"AtqStateActive",
|
|
"AtqStateClosed",
|
|
"AtqStateMax",
|
|
};
|
|
|
|
#define LookupSockState( SockState ) \
|
|
((SockState) <= ATQ_SOCK_CONNECTED ? AtqSockState[ (SockState) ] :\
|
|
"<Invalid>")
|
|
|
|
|
|
/************************************************************
|
|
* Functions
|
|
************************************************************/
|
|
|
|
VOID
|
|
DumpAtqGlobals(
|
|
VOID
|
|
);
|
|
|
|
VOID
|
|
DumpAtqContextList(
|
|
CHAR Level,
|
|
CHAR Verbosity,
|
|
ATQ_ENDPOINT * pEndpointIn
|
|
);
|
|
|
|
void
|
|
DumpEndpointList(
|
|
LIST_ENTRY * pAtqClientHead,
|
|
CHAR Level,
|
|
DWORD * pcContext,
|
|
BYTE * pvStart,
|
|
BYTE * pvEnd,
|
|
ATQ_ENDPOINT * pEndpointIn
|
|
);
|
|
|
|
VOID
|
|
PrintAtqContext(
|
|
ATQ_CONTEXT * AtqContext
|
|
);
|
|
|
|
|
|
void
|
|
PrintEndpoint(
|
|
ATQ_ENDPOINT * pEp
|
|
);
|
|
|
|
VOID
|
|
DumpEndpoint(
|
|
CHAR Level
|
|
);
|
|
|
|
|
|
DECLARE_API( atq )
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function is called as an NTSD extension to format and dump
|
|
an object attributes structure.
|
|
|
|
Arguments:
|
|
|
|
hCurrentProcess - Supplies a handle to the current process (at the
|
|
time the extension was called).
|
|
|
|
hCurrentThread - Supplies a handle to the current thread (at the
|
|
time the extension was called).
|
|
|
|
CurrentPc - Supplies the current pc at the time the extension is
|
|
called.
|
|
|
|
lpExtensionApis - Supplies the address of the functions callable
|
|
by this extension.
|
|
|
|
lpArgumentString - Supplies the asciiz string that describes the
|
|
ansi string to be dumped.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
BOOL fRet;
|
|
ATQ_CONTEXT AtqContext;
|
|
ATQ_CONTEXT * pAtqContext;
|
|
|
|
INIT_API();
|
|
|
|
while (*lpArgumentString == ' ')
|
|
lpArgumentString++;
|
|
|
|
if ( !*lpArgumentString )
|
|
{
|
|
PrintUsage( "atq" );
|
|
return;
|
|
}
|
|
|
|
if ( *lpArgumentString == '-' )
|
|
{
|
|
lpArgumentString++;
|
|
|
|
switch ( *lpArgumentString ) {
|
|
|
|
|
|
case 'g':
|
|
{
|
|
DumpAtqGlobals();
|
|
break;
|
|
}
|
|
|
|
case 'c':
|
|
{
|
|
DumpAtqContextList( lpArgumentString[1],
|
|
lpArgumentString[2],
|
|
NULL );
|
|
break;
|
|
}
|
|
|
|
case 'e':
|
|
{
|
|
|
|
ATQ_ENDPOINT * pEndpoint;
|
|
|
|
// Arguments: -e<Level><Verbosity> <EndpointAddr>
|
|
|
|
pEndpoint = ((ATQ_ENDPOINT * )
|
|
GetExpression( lpArgumentString + 4));
|
|
if ( !pEndpoint ) {
|
|
|
|
dprintf( "inetdbg: Unable to evaluate "
|
|
"EndpointAddr \"%s\"\n",
|
|
lpArgumentString );
|
|
|
|
break;
|
|
}
|
|
|
|
DumpAtqContextList( lpArgumentString[1],
|
|
lpArgumentString[2],
|
|
pEndpoint );
|
|
break;
|
|
}
|
|
|
|
case 'l':
|
|
{
|
|
DumpEndpoint( lpArgumentString[1] );
|
|
break;
|
|
}
|
|
|
|
case 'p':
|
|
{
|
|
//
|
|
// Treat the argument as the address of an AtqEndpoint
|
|
//
|
|
|
|
ATQ_ENDPOINT * pEndpoint;
|
|
|
|
// Arguments: -p <EndpointAddr>
|
|
|
|
pEndpoint = ((ATQ_ENDPOINT *)
|
|
GetExpression( lpArgumentString + 2 )
|
|
);
|
|
|
|
if ( !pEndpoint )
|
|
{
|
|
dprintf( "inetdbg: Unable to evaluate \"%s\"\n",
|
|
lpArgumentString );
|
|
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
ATQ_ENDPOINT Endpoint;
|
|
move( Endpoint, pEndpoint );
|
|
PrintEndpoint( &Endpoint );
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
case 'h':
|
|
{
|
|
PrintUsage( "atq" );
|
|
break;
|
|
}
|
|
|
|
} // switch
|
|
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Treat the argument as the address of an AtqContext
|
|
//
|
|
|
|
pAtqContext = (PATQ_CONT)GetExpression( lpArgumentString );
|
|
|
|
if ( !pAtqContext )
|
|
{
|
|
dprintf( "inetdbg: Unable to evaluate \"%s\"\n",
|
|
lpArgumentString );
|
|
|
|
return;
|
|
}
|
|
|
|
move( AtqContext, pAtqContext );
|
|
PrintAtqContext( &AtqContext );
|
|
} // DECLARE_API( atq )
|
|
|
|
|
|
|
|
|
|
/************************************************************
|
|
* ATQ related functions
|
|
************************************************************/
|
|
|
|
VOID
|
|
DumpAtqGlobals(
|
|
VOID
|
|
)
|
|
{
|
|
//
|
|
// Dump Atq Globals
|
|
//
|
|
|
|
dprintf("Atq Globals:\n");
|
|
|
|
DumpDword( "isatq!g_cConcurrency " );
|
|
DumpDword( "isatq!g_cThreads " );
|
|
DumpDword( "isatq!g_cAvailableThreads " );
|
|
DumpDword( "isatq!g_cMaxThreads " );
|
|
|
|
dprintf("\n");
|
|
DumpDword( "isatq!g_fUseAcceptEx " );
|
|
DumpDword( "isatq!g_fUseTransmitFile " );
|
|
DumpDword( "isatq!g_cbXmitBufferSize " );
|
|
DumpDword( "isatq!g_cbMinKbSec " );
|
|
DumpDword( "isatq!g_cCPU " );
|
|
DumpDword( "isatq!g_fShutdown " );
|
|
dprintf("\n");
|
|
|
|
DumpDword( "isatq!g_msThreadTimeout " );
|
|
DumpDword( "isatq!g_dwTimeoutCookie " );
|
|
DumpDword( "isatq!g_cListenBacklog " );
|
|
DumpDword( "isatq!AtqCurrentTick " );
|
|
DumpDword( "isatq!AtqGlobalContextCount" );
|
|
dprintf("\tsizeof(ATQ_CONTEXT) = %d\n", sizeof(ATQ_CONTEXT));
|
|
|
|
return;
|
|
} // DumpAtqGlobals()
|
|
|
|
|
|
|
|
VOID
|
|
DumpAtqContextList(
|
|
CHAR Level,
|
|
CHAR Verbosity,
|
|
ATQ_ENDPOINT * pEndpointIn
|
|
)
|
|
{
|
|
LIST_ENTRY AtqClientHead;
|
|
LIST_ENTRY * pAtqClientHead;
|
|
ATQ_CONTEXT * pAtqContext;
|
|
ATQ_CONTEXT AtqContext;
|
|
CHAR Symbol[256];
|
|
DWORD cContext = 0;
|
|
DWORD cc1;
|
|
ATQ_CONTEXT_LISTHEAD * pAtqActiveContextList;
|
|
ATQ_CONTEXT_LISTHEAD AtqActiveContextList[ATQ_NUM_CONTEXT_LIST];
|
|
DWORD i;
|
|
|
|
pAtqActiveContextList =
|
|
(ATQ_CONTEXT_LISTHEAD *) GetExpression( "&isatq!AtqActiveContextList" );
|
|
|
|
if ( !pAtqActiveContextList )
|
|
{
|
|
dprintf("Unable to get AtqActiveContextList symbol\n" );
|
|
return;
|
|
}
|
|
|
|
if ( !ReadMemory( (LPVOID) pAtqActiveContextList,
|
|
AtqActiveContextList,
|
|
sizeof(AtqActiveContextList),
|
|
NULL ))
|
|
{
|
|
dprintf("Unable to read AtqActiveContextList memory\n" );
|
|
return;
|
|
}
|
|
|
|
for ( i = 0; i < ATQ_NUM_CONTEXT_LIST; i++ )
|
|
{
|
|
dprintf("================================================\n");
|
|
dprintf("== Context List %d ==\n", i );
|
|
dprintf("================================================\n");
|
|
|
|
dprintf(" Active List ==>\n" );
|
|
|
|
cc1 = 0;
|
|
DumpEndpointList( &(AtqActiveContextList[i].ActiveListHead),
|
|
Verbosity,
|
|
&cc1,
|
|
(BYTE *) pAtqActiveContextList,
|
|
(BYTE *) &pAtqActiveContextList[ATQ_NUM_CONTEXT_LIST],
|
|
pEndpointIn
|
|
);
|
|
|
|
if ( 0 != cc1) {
|
|
dprintf( "\n\t%d Atq contexts traversed\n", cc1 );
|
|
cContext += cc1;
|
|
}
|
|
|
|
if ( Level >= '1' )
|
|
{
|
|
dprintf("================================================\n");
|
|
dprintf("Pending AcceptEx List\n");
|
|
|
|
cc1 = 0;
|
|
DumpEndpointList( &(AtqActiveContextList[i].PendingAcceptExListHead),
|
|
Verbosity,
|
|
&cc1,
|
|
(BYTE *) pAtqActiveContextList,
|
|
(BYTE *) &pAtqActiveContextList[ATQ_NUM_CONTEXT_LIST],
|
|
pEndpointIn
|
|
);
|
|
if ( 0 != cc1) {
|
|
dprintf( "\n\t%d Atq contexts traversed\n", cc1 );
|
|
cContext += cc1;
|
|
}
|
|
}
|
|
|
|
if ( CheckControlC() )
|
|
{
|
|
dprintf( "\n^C\n" );
|
|
return;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
dprintf( "%d Atq contexts traversed\n",
|
|
cContext );
|
|
|
|
return;
|
|
} // DumpAtqContextList()
|
|
|
|
|
|
|
|
void
|
|
DumpEndpointList(
|
|
LIST_ENTRY * pAtqClientHead,
|
|
CHAR Verbosity,
|
|
DWORD * pcContext,
|
|
BYTE * pvStart,
|
|
BYTE * pvEnd,
|
|
ATQ_ENDPOINT * pEndpointIn
|
|
)
|
|
{
|
|
LIST_ENTRY * pEntry;
|
|
ATQ_CONTEXT * pAtqContext;
|
|
ATQ_CONTEXT AtqContext;
|
|
|
|
//
|
|
// the list head is embedded in a structure so the exit condition of the
|
|
// loop is when the remote memory address ends up in the array memory
|
|
//
|
|
|
|
for ( pEntry = pAtqClientHead->Flink;
|
|
!((BYTE *)pEntry >= pvStart && (BYTE *)pEntry <= pvEnd);
|
|
)
|
|
{
|
|
if ( CheckControlC() )
|
|
{
|
|
return;
|
|
}
|
|
|
|
pAtqContext = CONTAINING_RECORD( pEntry,
|
|
ATQ_CONTEXT,
|
|
m_leTimeout );
|
|
|
|
move( AtqContext, pAtqContext );
|
|
|
|
// selectively print only the contexts that have a matching Endpoint
|
|
if ( (pEndpointIn != NULL) &&
|
|
(AtqContext.pEndpoint != pEndpointIn)
|
|
) {
|
|
|
|
move( pEntry, &pEntry->Flink );
|
|
continue;
|
|
}
|
|
|
|
|
|
(*pcContext)++;
|
|
|
|
if ( AtqContext.Signature != ATQ_CONTEXT_SIGNATURE )
|
|
{
|
|
dprintf( "AtqContext(%08lp) signature %08lx doesn't"
|
|
" match expected %08lx\n",
|
|
pAtqContext,
|
|
AtqContext.Signature,
|
|
ATQ_CONTEXT_SIGNATURE
|
|
);
|
|
|
|
return;
|
|
}
|
|
|
|
if ( Verbosity >= '1' )
|
|
{
|
|
//
|
|
// Print all
|
|
//
|
|
|
|
dprintf( "\nAtqContext at %08lp\n",
|
|
pAtqContext );
|
|
|
|
PrintAtqContext( &AtqContext );
|
|
|
|
}
|
|
else if ( Verbosity >= '0' )
|
|
{
|
|
//
|
|
// Print all with one line summary info
|
|
//
|
|
|
|
dprintf( "hAsyncIO = %4lp, Flink = %08lp, Blink = %08lp,"
|
|
" State = %8lx, Flags =%8lx\n",
|
|
AtqContext.hAsyncIO,
|
|
AtqContext.m_leTimeout.Blink,
|
|
AtqContext.m_leTimeout.Flink,
|
|
AtqContext.m_acState,
|
|
AtqContext.m_acFlags
|
|
);
|
|
}
|
|
|
|
move( pEntry, &pEntry->Flink );
|
|
}
|
|
} // DumpEndpointList()
|
|
|
|
|
|
|
|
VOID
|
|
PrintAtqContext(
|
|
ATQ_CONTEXT * pContext
|
|
)
|
|
{
|
|
UCHAR szSymFnCallback[MAX_SYMBOL_LEN];
|
|
ULONG_PTR offset;
|
|
|
|
|
|
GetSymbol((ULONG_PTR) pContext->pfnCompletion,
|
|
szSymFnCallback, &offset);
|
|
|
|
if (!*szSymFnCallback)
|
|
sprintf((char*) szSymFnCallback, "%p()",
|
|
pContext->pfnCompletion);
|
|
|
|
dprintf( "\n" );
|
|
dprintf( "\thAsyncIO = %08lp Signature = %08lx\n"
|
|
"\tOverlapped.Internal = %08lp Overlapped.Offset= %08lx\n"
|
|
"\tLE-Timeout.Flink = %08lp LE-Timeout.Blink = %p\n"
|
|
"\tClientContext = %08lp ContextList = %p\n"
|
|
"\tpfnIOCompletion = %s\n"
|
|
"\tlSyncTimeout = %8d m_nIO = %8d\n"
|
|
"\tTimeOut = %08lx NextTimeout = %08lx\n"
|
|
"\tBytesSent = %d (0x%08lx)\n"
|
|
"\tpvBuff = %08lp pEndPoint = %08lp\n"
|
|
"\tState = %8lx Flags = %08lx\n",
|
|
pContext->hAsyncIO, pContext->Signature,
|
|
pContext->Overlapped.Internal,pContext->Overlapped.Offset,
|
|
pContext->m_leTimeout.Flink, pContext->m_leTimeout.Blink,
|
|
pContext->ClientContext, pContext->ContextList,
|
|
szSymFnCallback,
|
|
pContext->lSyncTimeout, pContext->m_nIO,
|
|
pContext->TimeOut, pContext->NextTimeout,
|
|
pContext->BytesSent, pContext->BytesSent,
|
|
pContext->pvBuff, pContext->pEndpoint,
|
|
pContext->m_acState, pContext->m_acFlags
|
|
);
|
|
|
|
// identify and print the various properties
|
|
dprintf( "\t");
|
|
// First print the state bits
|
|
if ( pContext->m_acState & ACS_SOCK_CLOSED) {
|
|
dprintf( " ACS_SOCK_CLOSED");
|
|
}
|
|
if ( pContext->m_acState & ACS_SOCK_UNCONNECTED) {
|
|
dprintf( " ACS_SOCK_UNCONNECTED");
|
|
}
|
|
if ( pContext->m_acState & ACS_SOCK_LISTENING) {
|
|
dprintf( " ACS_SOCK_LISTENING");
|
|
}
|
|
if ( pContext->m_acState & ACS_SOCK_CONNECTED) {
|
|
dprintf( " ACS_SOCK_CONNECTED");
|
|
}
|
|
if ( pContext->m_acState & ACS_SOCK_TOBE_FREED) {
|
|
dprintf( " ACS_SOCK_TOBE_FREED");
|
|
}
|
|
|
|
// now print the flags associated with this context
|
|
if ( pContext->m_acFlags & ACF_ACCEPTEX_ROOT_CONTEXT) {
|
|
dprintf( " ACCEPTEX_CONTEXT");
|
|
}
|
|
if ( pContext->m_acFlags & ACF_CONN_INDICATED) {
|
|
dprintf( " CONNECTION_INDICATED");
|
|
}
|
|
if ( pContext->m_acFlags & ACF_IN_TIMEOUT) {
|
|
dprintf( " IN_TIMEOUT");
|
|
}
|
|
if ( pContext->m_acFlags & ACF_BLOCKED) {
|
|
dprintf( " BLOCKED_BY_BWT");
|
|
}
|
|
if ( pContext->m_acFlags & ACF_REUSE_CONTEXT) {
|
|
dprintf( " REUSE_CONTEXT");
|
|
}
|
|
if ( pContext->m_acFlags & ACF_RECV_ISSUED) {
|
|
dprintf( " RECV_ISSUED");
|
|
}
|
|
if ( pContext->m_acFlags & ACF_ABORTIVE_CLOSE) {
|
|
dprintf( " ABORTIVE_CLOSE");
|
|
}
|
|
dprintf( "\n");
|
|
|
|
if ( pContext->IsFlag( ACF_ACCEPTEX_ROOT_CONTEXT) && pContext->pvBuff )
|
|
{
|
|
//
|
|
// This size should correspond to the MIN_SOCKADDR_SIZE field in
|
|
// atqnew.c. We assume it's two thirty two byte values currently.
|
|
//
|
|
|
|
DWORD AddrInfo[16];
|
|
ATQ_ENDPOINT * pEndpoint = pContext->pEndpoint;
|
|
ATQ_ENDPOINT Endpoint;
|
|
|
|
move( Endpoint, pEndpoint );
|
|
|
|
if ( ReadMemory( (LPVOID) ((BYTE *) pContext->pvBuff +
|
|
Endpoint.InitialRecvSize +
|
|
2 * MIN_SOCKADDR_SIZE -
|
|
sizeof( AddrInfo )),
|
|
AddrInfo,
|
|
sizeof(AddrInfo),
|
|
NULL ))
|
|
{
|
|
|
|
dprintf( "\tLocal/Remote Addr = %08x %08x %08x %08x\n"
|
|
"\t %08x %08x %08x %08x\n"
|
|
"\t %08x %08x %08x %08x\n"
|
|
"\t %08x %08x %08x %08x\n",
|
|
AddrInfo[0],
|
|
AddrInfo[1],
|
|
AddrInfo[2],
|
|
AddrInfo[3],
|
|
AddrInfo[4],
|
|
AddrInfo[5],
|
|
AddrInfo[6],
|
|
AddrInfo[7],
|
|
AddrInfo[8],
|
|
AddrInfo[9],
|
|
AddrInfo[10],
|
|
AddrInfo[11],
|
|
AddrInfo[12],
|
|
AddrInfo[13],
|
|
AddrInfo[14],
|
|
AddrInfo[15] );
|
|
}
|
|
}
|
|
} // PrintAtqContext()
|
|
|
|
|
|
VOID
|
|
DumpEndpoint(
|
|
CHAR Verbosity
|
|
)
|
|
{
|
|
LIST_ENTRY AtqEndpointList;
|
|
LIST_ENTRY * pAtqEndpointList;
|
|
LIST_ENTRY * pEntry;
|
|
ATQ_CONTEXT * pAtqContext;
|
|
ATQ_CONTEXT AtqContext;
|
|
CHAR Symbol[256];
|
|
DWORD cEndp = 0;
|
|
DWORD i;
|
|
ATQ_ENDPOINT * pEndpoint;
|
|
ATQ_ENDPOINT Endpoint;
|
|
|
|
pAtqEndpointList = (LIST_ENTRY *) GetExpression( "&isatq!AtqEndpointList" );
|
|
|
|
if ( !pAtqEndpointList )
|
|
{
|
|
dprintf("Unable to get AtqEndpointList symbol\n" );
|
|
return;
|
|
}
|
|
|
|
move( AtqEndpointList, pAtqEndpointList );
|
|
|
|
for ( pEntry = AtqEndpointList.Flink;
|
|
pEntry != pAtqEndpointList;
|
|
cEndp++
|
|
)
|
|
{
|
|
if ( CheckControlC() )
|
|
{
|
|
return;
|
|
}
|
|
|
|
pEndpoint = CONTAINING_RECORD( pEntry,
|
|
ATQ_ENDPOINT,
|
|
ListEntry );
|
|
|
|
move( Endpoint, pEndpoint );
|
|
|
|
if ( Endpoint.Signature != ATQ_ENDPOINT_SIGNATURE )
|
|
{
|
|
dprintf( "Endpoint(%08p) signature %08lx doesn't match expected %08lx\n",
|
|
pEndpoint,
|
|
Endpoint.Signature,
|
|
ATQ_ENDPOINT_SIGNATURE
|
|
);
|
|
|
|
break;
|
|
}
|
|
|
|
if ( Verbosity >= '1' )
|
|
{
|
|
//
|
|
// Print all
|
|
//
|
|
|
|
dprintf( "\nEndpoint at %08lp\n",
|
|
pEndpoint );
|
|
|
|
PrintEndpoint( &Endpoint );
|
|
|
|
}
|
|
else if ( Verbosity >= '0' )
|
|
{
|
|
//
|
|
// Print all with one line summary info
|
|
//
|
|
|
|
dprintf( "sListenSocket = %4lp, cRef = %d, cSocketsAvail = %d\n",
|
|
Endpoint.ListenSocket,
|
|
Endpoint.m_refCount,
|
|
Endpoint.nSocketsAvail );
|
|
}
|
|
|
|
move( pEntry, &pEntry->Flink );
|
|
}
|
|
|
|
dprintf( "%d Atq Endpoints traversed\n",
|
|
cEndp );
|
|
|
|
return;
|
|
} // DumpEndpoint()
|
|
|
|
|
|
void
|
|
PrintEndpoint(
|
|
ATQ_ENDPOINT * pEp
|
|
)
|
|
{
|
|
|
|
dprintf( "\tcRef = %8d State = %s\n"
|
|
"\tIP Address = %s Port = %04x\n"
|
|
"\tsListenSocket = %8p InitRecvSize = %04x\n"
|
|
"\tnSocketsAvail = %8d nAvailAtTimeout = %d\n"
|
|
"\tnAcceptExOutstdg =%8d\n"
|
|
"\tUseAcceptEx = %8s AcceptExTimeout = %8d\n"
|
|
"\tEnableBw Throttle= %s\n"
|
|
"\tListEntry.Flink = %08lp ListEntry.Blink = %08lp\n"
|
|
"\tClient Context = %08lp pfnCompletion = %08lp()\n"
|
|
"\tpfnConnComp = %08lp() pfnConnExComp = %08lp()\n"
|
|
"\tShutDownCallback = %08lp() ShutDown Context = %08lp\n"
|
|
,
|
|
pEp->m_refCount,
|
|
AtqEndpointState[pEp->State],
|
|
pEp->IpAddress,
|
|
pEp->Port,
|
|
pEp->ListenSocket,
|
|
pEp->InitialRecvSize,
|
|
pEp->nSocketsAvail,
|
|
pEp->nAvailDuringTimeOut,
|
|
pEp->nAcceptExOutstanding,
|
|
BoolValue( pEp->UseAcceptEx),
|
|
pEp->AcceptExTimeout,
|
|
BoolValue( pEp->EnableBw),
|
|
pEp->ListEntry.Flink,
|
|
pEp->ListEntry.Blink,
|
|
pEp->Context,
|
|
pEp->IoCompletion,
|
|
pEp->ConnectCompletion,
|
|
pEp->ConnectExCompletion,
|
|
pEp->ShutdownCallback,
|
|
pEp->ShutdownCallbackContext
|
|
);
|
|
|
|
return;
|
|
} // PrintEndpoint()
|
|
|
|
|
|
/************************ End of File ***********************/
|
|
|