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.
1063 lines
24 KiB
1063 lines
24 KiB
/**********************************************************************/
|
|
/** Microsoft Windows NT **/
|
|
/** Copyright(c) Microsoft Corp., 1993 **/
|
|
/**********************************************************************/
|
|
|
|
/*
|
|
aap.cxx
|
|
|
|
This module contains implementation of the Asynchronous Accept Pool
|
|
package.
|
|
|
|
Functions exported by this module:
|
|
|
|
AapInitialize
|
|
AapTerminate
|
|
AapAcquire
|
|
AapRelease
|
|
AapAccept
|
|
AapAbort
|
|
|
|
|
|
FILE HISTORY:
|
|
KeithMo 01-Mar-1995 Created.
|
|
|
|
*/
|
|
|
|
|
|
#include "ftpdp.hxx"
|
|
|
|
|
|
//
|
|
// Private constants.
|
|
//
|
|
|
|
#define MAX_IDLE_THREADS 10
|
|
|
|
#define AapLockLists() EnterCriticalSection( &p_AapListLock )
|
|
#define AapUnlockLists() LeaveCriticalSection( &p_AapListLock )
|
|
|
|
|
|
//
|
|
// Private types.
|
|
//
|
|
|
|
typedef enum _AAP_STATE
|
|
{
|
|
AapStateFirst = -1, // Must be first aap state!
|
|
|
|
AapStateIdle, // Idle.
|
|
AapStateActive, // Waiting for incoming connection.
|
|
AapStateAbort, // Aborting, return to idle.
|
|
AapStateShutdown, // Shutting down.
|
|
|
|
AapStateLast // Must be last aap state!
|
|
|
|
} AAP_STATE;
|
|
|
|
#define IS_VALID_AAP_STATE(x) (((x) > AapStateFirst) && ((x) < AapStateLast))
|
|
|
|
typedef struct _AAP_CONTEXT
|
|
{
|
|
//
|
|
// Structure signature, for safety's sake.
|
|
//
|
|
|
|
DEBUG_SIGNATURE
|
|
|
|
//
|
|
// Links onto a list of idle/active contexts.
|
|
//
|
|
|
|
LIST_ENTRY ContextList;
|
|
|
|
//
|
|
// Current state.
|
|
//
|
|
|
|
AAP_STATE State;
|
|
|
|
//
|
|
// The listening socket.
|
|
//
|
|
|
|
SOCKET ListeningSocket;
|
|
|
|
//
|
|
// An event object for synchronizing with the worker thread.
|
|
//
|
|
|
|
HANDLE EventHandle;
|
|
|
|
//
|
|
// A handle to the worker thread for synchronizing shutdown.
|
|
//
|
|
|
|
HANDLE ThreadHandle;
|
|
|
|
//
|
|
// The callback associated with this context.
|
|
//
|
|
|
|
LPAAP_CALLBACK AapCallback;
|
|
|
|
//
|
|
// A user-definable context.
|
|
//
|
|
|
|
LPVOID UserContext;
|
|
|
|
} AAP_CONTEXT, * LPAAP_CONTEXT;
|
|
|
|
#if DBG
|
|
#define AAP_SIGNATURE (DWORD)'cPaA'
|
|
#define AAP_SIGNATURE_X (DWORD)'paaX'
|
|
#define INIT_AAP_SIG(p) ((p)->Signature = AAP_SIGNATURE)
|
|
#define KILL_AAP_SIG(p) ((p)->Signature = AAP_SIGNATURE_X)
|
|
#define IS_VALID_AAP_CONTEXT(p) (((p) != NULL) && ((p)->Signature == AAP_SIGNATURE))
|
|
#else // !DBG
|
|
#define INIT_AAP_SIG(p) ((void)(p))
|
|
#define KILL_AAP_SIG(p) ((void)(p))
|
|
#define IS_VALID_AAP_CONTEXT(p) (((void)(p)), TRUE)
|
|
#endif // DBG
|
|
|
|
|
|
//
|
|
// Private globals.
|
|
//
|
|
|
|
LIST_ENTRY p_AapIdleList;
|
|
LIST_ENTRY p_AapActiveList;
|
|
CRITICAL_SECTION p_AapListLock;
|
|
DWORD p_AapIdleCount;
|
|
|
|
|
|
//
|
|
// Private prototypes.
|
|
//
|
|
|
|
LPAAP_CONTEXT
|
|
AappCreateContext(
|
|
VOID
|
|
);
|
|
|
|
VOID
|
|
AappFreeResources(
|
|
LPAAP_CONTEXT AapContext
|
|
);
|
|
|
|
DWORD
|
|
AappWorkerThread(
|
|
LPVOID Param
|
|
);
|
|
|
|
|
|
//
|
|
// Public functions.
|
|
//
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: AapInitialize
|
|
|
|
SYNOPSIS: Initializes the AAP package.
|
|
|
|
EXIT: APIERR - 0 if successful, !0 if not.
|
|
|
|
HISTORY:
|
|
KeithMo 01-Mar-1995 Created.
|
|
|
|
********************************************************************/
|
|
APIERR
|
|
AapInitialize(
|
|
VOID
|
|
)
|
|
{
|
|
IF_DEBUG( AAP )
|
|
{
|
|
DBGPRINTF(( DBG_CONTEXT,
|
|
"in AapInitialize\n" ));
|
|
}
|
|
|
|
//
|
|
// Initialize the critical section.
|
|
//
|
|
|
|
INITIALIZE_CRITICAL_SECTION( &p_AapListLock );
|
|
|
|
//
|
|
// Initialize the worker lists.
|
|
//
|
|
|
|
InitializeListHead( &p_AapIdleList );
|
|
InitializeListHead( &p_AapActiveList );
|
|
|
|
p_AapIdleCount = 0;
|
|
|
|
//
|
|
// Success!
|
|
//
|
|
|
|
return 0;
|
|
|
|
} // AapInitialize
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: AapTerminate
|
|
|
|
SYNOPSIS: Terminates the AAP package.
|
|
|
|
HISTORY:
|
|
KeithMo 01-Mar-1995 Created.
|
|
|
|
********************************************************************/
|
|
VOID
|
|
AapTerminate(
|
|
VOID
|
|
)
|
|
{
|
|
PLIST_ENTRY Entry;
|
|
|
|
IF_DEBUG( AAP )
|
|
{
|
|
DBGPRINTF(( DBG_CONTEXT,
|
|
"in AapTerminate\n" ));
|
|
}
|
|
|
|
//
|
|
// Lock the lists.
|
|
//
|
|
|
|
AapLockLists();
|
|
|
|
//
|
|
// Scan the idle list and blow them away.
|
|
//
|
|
|
|
Entry = p_AapIdleList.Flink;
|
|
|
|
while( Entry != &p_AapIdleList )
|
|
{
|
|
LPAAP_CONTEXT AapContext;
|
|
|
|
AapContext = CONTAINING_RECORD( Entry, AAP_CONTEXT, ContextList );
|
|
Entry = Entry->Flink;
|
|
DBG_ASSERT( IS_VALID_AAP_CONTEXT( AapContext ) );
|
|
DBG_ASSERT( AapContext->State == AapStateIdle );
|
|
|
|
IF_DEBUG( AAP )
|
|
{
|
|
DBGPRINTF(( DBG_CONTEXT,
|
|
"AapTerminate: killing idle context @ %08lX\n",
|
|
AapContext ));
|
|
}
|
|
|
|
//
|
|
// Set the state to closing so the thread will know to exit.
|
|
//
|
|
|
|
AapContext->State = AapStateShutdown;
|
|
|
|
//
|
|
// Signal the event to wake up the thread.
|
|
//
|
|
|
|
DBG_ASSERT( AapContext->EventHandle != NULL );
|
|
TCP_REQUIRE( SetEvent( AapContext->EventHandle ) );
|
|
}
|
|
|
|
//
|
|
// Scan the active list and blow them away.
|
|
//
|
|
|
|
Entry = p_AapActiveList.Flink;
|
|
|
|
while( Entry != &p_AapActiveList )
|
|
{
|
|
LPAAP_CONTEXT AapContext;
|
|
SOCKET Socket;
|
|
|
|
AapContext = CONTAINING_RECORD( Entry, AAP_CONTEXT, ContextList );
|
|
Entry = Entry->Flink;
|
|
DBG_ASSERT( IS_VALID_AAP_CONTEXT( AapContext ) );
|
|
DBG_ASSERT( AapContext->State == AapStateActive );
|
|
|
|
IF_DEBUG( AAP )
|
|
{
|
|
DBGPRINTF(( DBG_CONTEXT,
|
|
"AapTerminate: killing active context @ %08lX\n",
|
|
AapContext ));
|
|
}
|
|
|
|
//
|
|
// Set the state to closing so the thread will know to exit.
|
|
//
|
|
|
|
AapContext->State = AapStateShutdown;
|
|
|
|
//
|
|
// Close the listening socket to wake up the thread.
|
|
//
|
|
|
|
Socket = AapContext->ListeningSocket;
|
|
DBG_ASSERT( Socket != INVALID_SOCKET );
|
|
AapContext->ListeningSocket = INVALID_SOCKET;
|
|
|
|
TCP_REQUIRE( closesocket( Socket ) == 0 );
|
|
|
|
DBG_ASSERT( AapContext->EventHandle != NULL );
|
|
TCP_REQUIRE( SetEvent( AapContext->EventHandle ) );
|
|
}
|
|
|
|
//
|
|
// Wait for the worker threads to exit. Note that the list
|
|
// lock is currently held.
|
|
//
|
|
|
|
for( ; ; )
|
|
{
|
|
LPAAP_CONTEXT AapContext;
|
|
|
|
//
|
|
// Find a thread to wait on. If both lists are empty,
|
|
// then we're done.
|
|
//
|
|
|
|
if( IsListEmpty( &p_AapIdleList ) )
|
|
{
|
|
if( IsListEmpty( &p_AapActiveList ) )
|
|
{
|
|
break;
|
|
}
|
|
|
|
AapContext = CONTAINING_RECORD( p_AapActiveList.Flink,
|
|
AAP_CONTEXT,
|
|
ContextList );
|
|
}
|
|
else
|
|
{
|
|
AapContext = CONTAINING_RECORD( p_AapIdleList.Flink,
|
|
AAP_CONTEXT,
|
|
ContextList );
|
|
}
|
|
|
|
DBG_ASSERT( IS_VALID_AAP_CONTEXT( AapContext ) );
|
|
DBG_ASSERT( AapContext->State == AapStateShutdown );
|
|
|
|
//
|
|
// Unlock the lists, wait for the thread to exit, then
|
|
// relock the lists.
|
|
//
|
|
|
|
AapUnlockLists();
|
|
WaitForSingleObject( AapContext->ThreadHandle, INFINITE );
|
|
AapLockLists();
|
|
|
|
//
|
|
// Note that worker threads will neither close their thread
|
|
// handles nor free their AAP_CONTEXT structures during shutdown.
|
|
// This is our responsibility.
|
|
//
|
|
|
|
AappFreeResources( AapContext );
|
|
}
|
|
|
|
DBG_ASSERT( p_AapIdleCount == 0 );
|
|
|
|
//
|
|
// Unlock the lists.
|
|
//
|
|
|
|
AapUnlockLists();
|
|
|
|
} // AapTerminate
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: AapAcquire
|
|
|
|
SYNOPSIS: Acquires an AAP socket/thread pair for a future
|
|
asynchronous accept request.
|
|
|
|
ENTRY: AapCallback - Pointer to a callback function to be
|
|
invoked when the accept() completes.
|
|
|
|
UserContext - An uninterpreted context value passed
|
|
into the callback.
|
|
|
|
EXIT: AAP_HANDLE - A valid AAP handle if !NULL, NULL if
|
|
an error occurred.
|
|
|
|
HISTORY:
|
|
KeithMo 01-Mar-1995 Created.
|
|
|
|
********************************************************************/
|
|
AAP_HANDLE
|
|
AapAcquire(
|
|
LPAAP_CALLBACK AapCallback,
|
|
LPVOID UserContext
|
|
)
|
|
{
|
|
PLIST_ENTRY Entry;
|
|
LPAAP_CONTEXT AapContext;
|
|
|
|
//
|
|
// Sanity check.
|
|
//
|
|
|
|
DBG_ASSERT( AapCallback != NULL );
|
|
|
|
IF_DEBUG( AAP )
|
|
{
|
|
DBGPRINTF(( DBG_CONTEXT,
|
|
"AapAcquire: callback @ %08lX, context = %08lX\n",
|
|
AapCallback,
|
|
UserContext ));
|
|
}
|
|
|
|
//
|
|
// See if there's something available on the idle list.
|
|
//
|
|
|
|
AapLockLists();
|
|
|
|
if( !IsListEmpty( &p_AapIdleList ) )
|
|
{
|
|
Entry = RemoveHeadList( &p_AapIdleList );
|
|
AapContext = CONTAINING_RECORD( Entry, AAP_CONTEXT, ContextList );
|
|
DBG_ASSERT( IS_VALID_AAP_CONTEXT( AapContext ) );
|
|
DBG_ASSERT( AapContext->State == AapStateIdle );
|
|
|
|
DBG_ASSERT( p_AapIdleCount > 0 );
|
|
p_AapIdleCount--;
|
|
|
|
IF_DEBUG( AAP )
|
|
{
|
|
DBGPRINTF(( DBG_CONTEXT,
|
|
"AapAcquire: got idle context @ %08lX\n",
|
|
AapContext ));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Create a new one.
|
|
//
|
|
|
|
AapContext = AappCreateContext();
|
|
}
|
|
|
|
if( AapContext != NULL )
|
|
{
|
|
//
|
|
// Initialize it.
|
|
//
|
|
|
|
AapContext->AapCallback = AapCallback;
|
|
AapContext->UserContext = UserContext;
|
|
AapContext->State = AapStateActive;
|
|
|
|
//
|
|
// Put it on the active list.
|
|
//
|
|
|
|
InsertHeadList( &p_AapActiveList, &AapContext->ContextList );
|
|
}
|
|
|
|
//
|
|
// Unlock the lists & return the (potentially NULL) context.
|
|
//
|
|
|
|
AapUnlockLists();
|
|
|
|
IF_DEBUG( AAP )
|
|
{
|
|
DBGPRINTF(( DBG_CONTEXT,
|
|
"AapAcquire: returning context @ %08lX\n",
|
|
AapContext ));
|
|
}
|
|
|
|
return AapContext;
|
|
|
|
} // AapAcquire
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: AapRelease
|
|
|
|
SYNOPSIS: Releases an open AAP handle and makes the associated
|
|
socket/thread pair available for use.
|
|
|
|
ENTRY: AapHandle - A valid AAP handle returned by AapAcquire().
|
|
After this API completes, the handle is no longer
|
|
valid.
|
|
|
|
HISTORY:
|
|
KeithMo 01-Mar-1995 Created.
|
|
|
|
********************************************************************/
|
|
VOID
|
|
AapRelease(
|
|
AAP_HANDLE AapHandle
|
|
)
|
|
{
|
|
//
|
|
// Sanity check.
|
|
//
|
|
|
|
DBG_ASSERT( IS_VALID_AAP_CONTEXT( AapHandle ) );
|
|
DBG_ASSERT( AapHandle->State == AapStateActive );
|
|
|
|
IF_DEBUG( AAP )
|
|
{
|
|
DBGPRINTF(( DBG_CONTEXT,
|
|
"AapRelease: releasing context @ %08lX\n",
|
|
AapHandle ));
|
|
}
|
|
|
|
//
|
|
// Lock the lists.
|
|
//
|
|
|
|
AapLockLists();
|
|
|
|
//
|
|
// let it decide how to handle this.
|
|
//
|
|
|
|
AapHandle->State = AapStateAbort;
|
|
|
|
DBG_ASSERT( AapHandle->EventHandle != NULL );
|
|
TCP_REQUIRE( SetEvent( AapHandle->EventHandle ) );
|
|
|
|
//
|
|
// Unlock the lists.
|
|
//
|
|
|
|
AapUnlockLists();
|
|
|
|
} // AapRelease
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: AapAccept
|
|
|
|
SYNOPSIS: Initiates an accept(). The callback associated with
|
|
the AAP handle will be invoked when the accept()
|
|
completes.
|
|
|
|
ENTRY: AapHandle - A valid AAP handle returned by AapAcquire().
|
|
|
|
EXIT: APIERR - 0 if successful, !0 if not.
|
|
|
|
HISTORY:
|
|
KeithMo 01-Mar-1995 Created.
|
|
|
|
********************************************************************/
|
|
APIERR
|
|
AapAccept(
|
|
AAP_HANDLE AapHandle
|
|
)
|
|
{
|
|
//
|
|
// Sanity check.
|
|
//
|
|
|
|
DBG_ASSERT( IS_VALID_AAP_CONTEXT( AapHandle ) );
|
|
DBG_ASSERT( AapHandle->State == AapStateActive );
|
|
|
|
IF_DEBUG( AAP )
|
|
{
|
|
DBGPRINTF(( DBG_CONTEXT,
|
|
"AapAccept: context @ %08lX\n",
|
|
AapHandle ));
|
|
}
|
|
|
|
//
|
|
// Release the worker thread.
|
|
//
|
|
|
|
TCP_REQUIRE( SetEvent( AapHandle->EventHandle ) );
|
|
|
|
return 0;
|
|
|
|
} // AapAccept
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: AapAbort
|
|
|
|
SYNOPSIS: Aborts a pending accept().
|
|
|
|
ENTRY: AapHandle - A valid AAP handle returned by AapAcquire().
|
|
|
|
EXIT: APIERR - 0 if successful, !0 if not.
|
|
|
|
HISTORY:
|
|
KeithMo 01-Mar-1995 Created.
|
|
|
|
********************************************************************/
|
|
APIERR
|
|
AapAbort(
|
|
AAP_HANDLE AapHandle
|
|
)
|
|
{
|
|
//
|
|
// Sanity check.
|
|
//
|
|
|
|
DBG_ASSERT( IS_VALID_AAP_CONTEXT( AapHandle ) );
|
|
DBG_ASSERT( AapHandle->State == AapStateActive );
|
|
|
|
IF_DEBUG( AAP )
|
|
{
|
|
DBGPRINTF(( DBG_CONTEXT,
|
|
"AapAbort: context @ %08lX\n",
|
|
AapHandle ));
|
|
}
|
|
|
|
//
|
|
// Just zap the listening handle. The worker thread will clean
|
|
// up after itself.
|
|
//
|
|
|
|
TCP_REQUIRE( closesocket( AapHandle->ListeningSocket ) == 0 );
|
|
|
|
return 0;
|
|
|
|
} // AapAbort
|
|
|
|
|
|
//
|
|
// Private functions.
|
|
//
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: AappCreateContext
|
|
|
|
SYNOPSIS: Creates a new AAP context, including the associated
|
|
thread, socket, and synchronization objects.
|
|
|
|
RETURNS: LPAAP_CONTEXT - The newly created context if successful,
|
|
NULL otherwise.
|
|
|
|
HISTORY:
|
|
KeithMo 01-Mar-1995 Created.
|
|
|
|
********************************************************************/
|
|
LPAAP_CONTEXT
|
|
AappCreateContext(
|
|
VOID
|
|
)
|
|
{
|
|
LPAAP_CONTEXT AapContext;
|
|
SOCKADDR_IN LocalAddress;
|
|
DWORD ThreadId;
|
|
|
|
//
|
|
// Create the context structure.
|
|
//
|
|
|
|
AapContext = (LPAAP_CONTEXT)TCP_ALLOC( sizeof(AAP_CONTEXT) );
|
|
|
|
if( AapContext == NULL )
|
|
{
|
|
DBGERROR(( DBG_CONTEXT,
|
|
"AappCreateContext: allocation failure\n" ));
|
|
|
|
goto FatalExit0;
|
|
}
|
|
|
|
RtlZeroMemory( AapContext, sizeof(AAP_CONTEXT) );
|
|
INIT_AAP_SIG( AapContext );
|
|
|
|
//
|
|
// Create the listening socket.
|
|
//
|
|
|
|
AapContext->ListeningSocket = socket( AF_INET, SOCK_STREAM, 0 );
|
|
|
|
if( AapContext->ListeningSocket == INVALID_SOCKET)
|
|
{
|
|
DBGERROR(( DBG_CONTEXT,
|
|
"AappCreateContext: socket() failure %d\n",
|
|
WSAGetLastError() ));
|
|
|
|
goto FatalExit1;
|
|
}
|
|
|
|
LocalAddress.sin_family = AF_INET;
|
|
LocalAddress.sin_port = 0;
|
|
LocalAddress.sin_addr.s_addr = 0;
|
|
|
|
if( bind( AapContext->ListeningSocket,
|
|
(LPSOCKADDR)&LocalAddress,
|
|
sizeof(LocalAddress) ) != 0 )
|
|
{
|
|
DBGERROR(( DBG_CONTEXT,
|
|
"AappCreateContext: bind() failure %d\n",
|
|
WSAGetLastError() ));
|
|
|
|
goto FatalExit2;
|
|
}
|
|
|
|
if( listen( AapContext->ListeningSocket, 2 ) != 0 )
|
|
{
|
|
DBGERROR(( DBG_CONTEXT,
|
|
"AappCreateContext: listen() failure %d\n",
|
|
WSAGetLastError() ));
|
|
|
|
goto FatalExit2;
|
|
}
|
|
|
|
//
|
|
// Create the event object.
|
|
//
|
|
|
|
AapContext->EventHandle = CreateEvent( NULL, // lpEventAttributes
|
|
FALSE, // bManualReset
|
|
FALSE, // bInitialState
|
|
NULL ); // lpName
|
|
|
|
if( AapContext->EventHandle == NULL )
|
|
{
|
|
DBGWARN(( DBG_CONTEXT,
|
|
"AappCreateContext: CreateEvent() failure %d\n",
|
|
GetLastError() ));
|
|
|
|
goto FatalExit2;
|
|
}
|
|
|
|
//
|
|
// Create the worker thread.
|
|
//
|
|
|
|
AapContext->ThreadHandle = CreateThread( NULL, // lpsa
|
|
0, // cbStack
|
|
AappWorkerThread, // lpStartAddr
|
|
AapContext, // lpvThreadParm
|
|
0, // fdwCreate
|
|
&ThreadId ); // lpIDThread
|
|
|
|
if( AapContext->ThreadHandle == NULL )
|
|
{
|
|
DBGPRINTF(( DBG_CONTEXT,
|
|
"AappCreateContext: CreateThread() failure %d\n",
|
|
GetLastError() ));
|
|
|
|
goto FatalExit3;
|
|
}
|
|
|
|
//
|
|
// Success!
|
|
//
|
|
|
|
return AapContext;
|
|
|
|
//
|
|
// Cleanup from various levels of fatal error.
|
|
//
|
|
|
|
FatalExit3:
|
|
|
|
CloseHandle( AapContext->EventHandle );
|
|
|
|
FatalExit2:
|
|
|
|
closesocket( AapContext->ListeningSocket );
|
|
|
|
FatalExit1:
|
|
|
|
TCP_FREE( AapContext );
|
|
|
|
FatalExit0:
|
|
|
|
return NULL;
|
|
|
|
} // AappCreateContext
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: AappFreeResources
|
|
|
|
SYNOPSIS: Frees the system resources associated with a given
|
|
AAP_CONTEXT structure, then frees the structure
|
|
itself.
|
|
|
|
NOTE: This routine MUST be called with the list lock
|
|
held!
|
|
|
|
ENTRY: AapContext - The AAP_CONTEXT structure to free.
|
|
|
|
HISTORY:
|
|
KeithMo 01-Mar-1995 Created.
|
|
|
|
********************************************************************/
|
|
VOID
|
|
AappFreeResources(
|
|
LPAAP_CONTEXT AapContext
|
|
)
|
|
{
|
|
//
|
|
// Sanity check.
|
|
//
|
|
|
|
DBG_ASSERT( IS_VALID_AAP_CONTEXT( AapContext ) );
|
|
|
|
IF_DEBUG( AAP )
|
|
{
|
|
DBGWARN(( DBG_CONTEXT,
|
|
"AappFreeResource: context @ %08lX\n",
|
|
AapContext ));
|
|
}
|
|
|
|
//
|
|
// Close the thread handle if open.
|
|
//
|
|
|
|
if( AapContext->ThreadHandle != NULL )
|
|
{
|
|
CloseHandle( AapContext->ThreadHandle );
|
|
}
|
|
|
|
//
|
|
// Remove this structure from the list.
|
|
//
|
|
|
|
RemoveEntryList( &AapContext->ContextList );
|
|
|
|
//
|
|
// Free the structure.
|
|
//
|
|
|
|
KILL_AAP_SIG( AapContext );
|
|
TCP_FREE( AapContext );
|
|
|
|
} // AappFreeResources
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: AappWorkerThread
|
|
|
|
SYNOPSIS: Worker thread for accept()ing incoming connections.
|
|
|
|
ENTRY: Param - Actually the LPAAP_CONTEXT structure for this
|
|
thread.
|
|
|
|
RETURNS: DWORD - Thread exit code (ignored).
|
|
|
|
HISTORY:
|
|
KeithMo 01-Mar-1995 Created.
|
|
|
|
********************************************************************/
|
|
DWORD
|
|
AappWorkerThread(
|
|
LPVOID Param
|
|
)
|
|
{
|
|
LPAAP_CONTEXT AapContext;
|
|
AAP_STATE AapState;
|
|
LPAAP_CALLBACK AapCallback;
|
|
LPVOID UserContext;
|
|
DWORD WaitResult;
|
|
BOOL CallbackResult;
|
|
SOCKET ListeningSocket;
|
|
SOCKET AcceptedSocket;
|
|
SOCKERR SocketStatus;
|
|
INT RemoteAddressLength;
|
|
SOCKADDR_IN RemoteAddress;
|
|
|
|
//
|
|
// Grab the context structure.
|
|
//
|
|
|
|
AapContext = (LPAAP_CONTEXT)Param;
|
|
DBG_ASSERT( IS_VALID_AAP_CONTEXT( AapContext ) );
|
|
|
|
IF_DEBUG( AAP )
|
|
{
|
|
DBGPRINTF(( DBG_CONTEXT,
|
|
"AappWorkerThread: starting, context @ %08lX\n",
|
|
AapContext ));
|
|
}
|
|
|
|
//
|
|
// Capture some fields from the structure.
|
|
//
|
|
|
|
AapCallback = AapContext->AapCallback;
|
|
UserContext = AapContext->UserContext;
|
|
ListeningSocket = AapContext->ListeningSocket;
|
|
|
|
//
|
|
// Loop forever, or at least until we're told to shutdown.
|
|
//
|
|
|
|
for( ; ; )
|
|
{
|
|
//
|
|
// Wait for a request.
|
|
//
|
|
|
|
WaitResult = WaitForSingleObject( AapContext->EventHandle,
|
|
INFINITE );
|
|
|
|
if( WaitResult != WAIT_OBJECT_0 )
|
|
{
|
|
DBGWARN(( DBG_CONTEXT,
|
|
"AappWorkerThread: wait failure %lu : %d\n",
|
|
WaitResult,
|
|
GetLastError() ));
|
|
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Check our state.
|
|
//
|
|
|
|
AapLockLists();
|
|
AapState = AapContext->State;
|
|
AapUnlockLists();
|
|
|
|
if( AapState == AapStateShutdown )
|
|
{
|
|
IF_DEBUG( AAP )
|
|
{
|
|
DBGPRINTF(( DBG_CONTEXT,
|
|
"AappWorkerThread: context @ %08lX state == %d, exiting\n",
|
|
AapContext,
|
|
AapState ));
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
for( ; ; )
|
|
{
|
|
//
|
|
// Wait for an incoming connection.
|
|
//
|
|
|
|
RemoteAddressLength = sizeof(RemoteAddress);
|
|
|
|
AcceptedSocket = accept( ListeningSocket,
|
|
(LPSOCKADDR)&RemoteAddress,
|
|
&RemoteAddressLength );
|
|
|
|
SocketStatus = ( AcceptedSocket == INVALID_SOCKET )
|
|
? WSAGetLastError()
|
|
: 0;
|
|
|
|
IF_DEBUG( AAP )
|
|
{
|
|
if( SocketStatus != 0 )
|
|
{
|
|
DBGERROR(( DBG_CONTEXT,
|
|
"AappWorkerThread: accept() failure %d\n",
|
|
SocketStatus ));
|
|
}
|
|
}
|
|
|
|
//
|
|
// Invoke the callback.
|
|
//
|
|
|
|
IF_DEBUG( AAP )
|
|
{
|
|
DBGPRINTF(( DBG_CONTEXT,
|
|
"AappWorkerThread: context @ %08lX calling %08lX[%08lX]\n",
|
|
AapContext,
|
|
AapCallback,
|
|
UserContext ));
|
|
}
|
|
|
|
CallbackResult = AapCallback( UserContext,
|
|
SocketStatus,
|
|
AcceptedSocket,
|
|
(LPSOCKADDR)&RemoteAddress,
|
|
RemoteAddressLength );
|
|
|
|
//
|
|
// If the callback returned FALSE (indicating that it wants no
|
|
// further callbacks) OR if the accept() failed for any reason,
|
|
// then exit the accept() loop.
|
|
//
|
|
|
|
if( !CallbackResult || ( SocketStatus != 0 ) )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
// If we hit a socket error, then bail.
|
|
//
|
|
|
|
if( SocketStatus != 0 )
|
|
{
|
|
IF_DEBUG( AAP )
|
|
{
|
|
DBGWARN(( DBG_CONTEXT,
|
|
"AappWorkerThread: context @ %08lX, exiting\n",
|
|
AapContext ));
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
//
|
|
// If we haven't exhausted the idle thread quota, then add
|
|
// ourselves to the idle list. Otherwise, exit the main
|
|
// processing loop & terminate this thread.
|
|
//
|
|
|
|
AapLockLists();
|
|
|
|
if( ( AapContext->State == AapStateShutdown ) ||
|
|
( p_AapIdleCount >= MAX_IDLE_THREADS ) )
|
|
{
|
|
AapUnlockLists();
|
|
break;
|
|
}
|
|
|
|
RemoveEntryList( &AapContext->ContextList );
|
|
|
|
AapContext->State = AapStateIdle;
|
|
InsertHeadList( &p_AapIdleList, &AapContext->ContextList );
|
|
p_AapIdleCount++;
|
|
|
|
|
|
IF_DEBUG( AAP )
|
|
{
|
|
DBGPRINTF(( DBG_CONTEXT,
|
|
"AappWorkerThread: context @ %08lX put on idle list\n",
|
|
AapContext ));
|
|
}
|
|
|
|
AapUnlockLists();
|
|
}
|
|
|
|
//
|
|
// We only make it this far if it's time to die.
|
|
//
|
|
|
|
AapLockLists();
|
|
|
|
if( AapContext->State != AapStateShutdown )
|
|
{
|
|
TCP_REQUIRE( CloseHandle( AapContext->EventHandle ) );
|
|
TCP_REQUIRE( CloseHandle( AapContext->ThreadHandle ) );
|
|
TCP_REQUIRE( closesocket( AapContext->ListeningSocket ) == 0 );
|
|
|
|
AappFreeResources( AapContext );
|
|
}
|
|
|
|
AapUnlockLists();
|
|
|
|
return 0;
|
|
|
|
} // AappWorkerThread
|
|
|