/*==========================================================================
 *
 *  Copyright (C) 2000-2000 Microsoft Corporation.  All Rights Reserved.
 *
 *  File:       Pools.cpp
 *  Content:	Pool utility functions
 *
 *
 *  History:
 *   Date		By		Reason
 *   ====		==		======
 *	01/20/2000	jtk		Derived from Utils.h
 ***************************************************************************/

#include "dnwsocki.h"


#undef DPF_SUBCOMP
#define DPF_SUBCOMP DN_SUBCOMP_WSOCK

//**********************************************************************
// Constant definitions
//**********************************************************************

//**********************************************************************
// Macro definitions
//**********************************************************************

//**********************************************************************
// Structure definitions
//**********************************************************************

//**********************************************************************
// Variable definitions
//**********************************************************************

#ifdef USE_THREADLOCALPOOLS
//
// implement the thread local pools
//
IMPL_THREADLOCALPTRS(WSockThreadLocalPools);

//
// global backup pools for thread-local pools
//
CFixedTLPool< CIPAddress > *										g_pGlobalIPAddressPool = NULL;
CFixedTLPool< CIPXAddress > *										g_pGlobalIPXAddressPool = NULL;
CContextFixedTLPool< CReadIOData, READ_IO_DATA_POOL_CONTEXT > *		g_pGlobalIPReadIODataPool = NULL;
CContextFixedTLPool< CReadIOData, READ_IO_DATA_POOL_CONTEXT > *		g_pGlobalIPXReadIODataPool = NULL;
CLockedTLPool< CCommandData > *										g_pGlobalCommandDataPool = NULL;
CContextFixedTLPool< CWriteIOData, WRITE_IO_DATA_POOL_CONTEXT > *	g_pGlobalWriteIODataPool = NULL;

//
// boolean that gets set when pools are being cleaned up (inside DllMain
// PROCESS_DETACH).
//
static BOOL		g_fShuttingDown = FALSE;
#endif // USE_THREADLOCALPOOLS



//
// pool for adapter entries
//
static	CLockedPool< CAdapterEntry >	*g_pAdapterEntryPool = NULL;


#ifndef USE_THREADLOCALPOOLS
//
// pool for command data
//
static	CLockedPool< CCommandData >	*g_pCommandDataPool = NULL;


//
// Pools for addresses.  Since these pools don't
// see a lot of action, they share one lock
//
static	DNCRITICAL_SECTION	g_AddressLock;
static	CFixedPool< CIPAddress >	*g_pIPAddressPool = NULL;
static	CFixedPool< CIPXAddress >	*g_pIPXAddressPool = NULL;
#endif // ! USE_THREADLOCALPOOLS


//
// pools for endpoints
//
static	CLockedContextFixedPool< CIPEndpoint, ENDPOINT_POOL_CONTEXT* >	*g_pIPEndpointPool = NULL;
static	CLockedContextFixedPool< CIPXEndpoint, ENDPOINT_POOL_CONTEXT* >	*g_pIPXEndpointPool = NULL;
static	CLockedFixedPool< ENDPOINT_COMMAND_PARAMETERS >	*g_pEndpointCommandParameterPool = NULL;

//
// pool for socket ports
//
static	CLockedFixedPool< CSocketPort >	*g_pSocketPortPool = NULL;

//
// pool for thread pools
//
static	CLockedFixedPool< CThreadPool >	*g_pThreadPoolPool = NULL;



//**********************************************************************
// Function prototypes
//**********************************************************************

//**********************************************************************
// Function definitions
//**********************************************************************


//**********************************************************************
// ------------------------------
// InitializePools - initialize pools
//
// Entry:		Nothing
//
// Exit:		Boolean indicating success
//				TRUE = success
//				FALSE = failure
// ------------------------------
#undef DPF_MODNAME
#define	DPF_MODNAME "InitializePools"

BOOL	InitializePools( void )
{
	BOOL	fReturn;


	//
	// initialize
	//
	fReturn = TRUE;


	//
	// AdapterEntry object pool
	//
	DNASSERT( g_pAdapterEntryPool == NULL );
	g_pAdapterEntryPool = new CLockedPool< CAdapterEntry >;
	if ( g_pAdapterEntryPool != NULL )
	{
		if ( g_pAdapterEntryPool->Initialize() == FALSE )
		{
			delete	g_pAdapterEntryPool;
			g_pAdapterEntryPool = NULL;
			goto Failure;
		}
	}
	else
	{
		goto Failure;
	}
	
	
#ifndef USE_THREADLOCALPOOLS
	//
	// command data pool
	//
	DNASSERT( g_pCommandDataPool == NULL );
	g_pCommandDataPool = new CLockedPool< CCommandData >;
	if ( g_pCommandDataPool != NULL )
	{
		if ( g_pCommandDataPool->Initialize() == FALSE )
		{
			delete	g_pCommandDataPool;
			g_pCommandDataPool = NULL;
			goto Failure;
		}
	}
	else
	{
		goto Failure;
	}


	//
	// initialize lock for address and endpoint pools
	//
	if ( DNInitializeCriticalSection( &g_AddressLock ) == FALSE )
	{
		goto Failure;
	}
	DebugSetCriticalSectionRecursionCount( &g_AddressLock, 0 );

	//
	// address pools
	//
	DNASSERT( g_pIPAddressPool == NULL );
	g_pIPAddressPool = new CFixedPool< CIPAddress >;
	if ( g_pIPAddressPool == NULL )
	{
		goto Failure;
	}

	DNASSERT( g_pIPXAddressPool == NULL );
	g_pIPXAddressPool = new CFixedPool< CIPXAddress >;
	if ( g_pIPXAddressPool == NULL )
	{
		goto Failure;
	}
#endif // ! USE_THREADLOCALPOOLS


	//
	// endpoint pools
	//
	DNASSERT( g_pIPEndpointPool == NULL );
	g_pIPEndpointPool = new CLockedContextFixedPool< CIPEndpoint, ENDPOINT_POOL_CONTEXT* >;
	if ( g_pIPEndpointPool != NULL )
	{
		if ( g_pIPEndpointPool->Initialize() == FALSE )
		{
			delete	g_pIPEndpointPool;
			g_pIPEndpointPool = NULL;
			goto Failure;
		}
	}
	else
	{
		goto Failure;
	}

	DNASSERT( g_pIPXEndpointPool == NULL );
	g_pIPXEndpointPool = new CLockedContextFixedPool< CIPXEndpoint, ENDPOINT_POOL_CONTEXT* >;
	if ( g_pIPXEndpointPool != NULL )
	{
		if ( g_pIPXEndpointPool->Initialize() == FALSE )
		{
			delete	g_pIPXEndpointPool;
			g_pIPXEndpointPool = NULL;
			goto Failure;
		}
	}
	else
	{
		goto Failure;
	}

	//
	// endpoint command parameter pools
	//
	DNASSERT( g_pEndpointCommandParameterPool == NULL );
	g_pEndpointCommandParameterPool = new CLockedFixedPool< ENDPOINT_COMMAND_PARAMETERS >;
	if ( g_pEndpointCommandParameterPool != NULL )
	{
		if ( g_pEndpointCommandParameterPool->Initialize() == FALSE )
		{
			delete	g_pEndpointCommandParameterPool;
			g_pEndpointCommandParameterPool = NULL;
			goto Failure;
		}
	}
	else
	{
		goto Failure;
	}


	//
	// socket port pool
	//
	DNASSERT( g_pSocketPortPool == NULL );
	g_pSocketPortPool = new CLockedFixedPool< CSocketPort >;
	if ( g_pSocketPortPool != NULL )
	{
		if ( g_pSocketPortPool->Initialize() == FALSE )
		{
			delete	g_pSocketPortPool;
			g_pSocketPortPool = NULL;
			goto Failure;
		}
	}
	else
	{
		goto Failure;
	}


	//
	// thread pool pool
	//
	DNASSERT( g_pThreadPoolPool == NULL );
	g_pThreadPoolPool = new CLockedFixedPool< CThreadPool >;
	if ( g_pThreadPoolPool != NULL )
	{
		if ( g_pThreadPoolPool->Initialize() == FALSE )
		{
			delete	g_pThreadPoolPool;
			g_pThreadPoolPool = NULL;
			goto Failure;
		}
	}
	else
	{
		goto Failure;
	}


#ifdef USE_THREADLOCALPOOLS
	//
	// global IP address pool that backs up the thread-local ones.
	//
	DNASSERT( g_pGlobalIPAddressPool == NULL );
	g_pGlobalIPAddressPool = new CFixedTLPool< CIPAddress > ( NULL );
	if ( g_pGlobalIPAddressPool == NULL )
	{
		goto Failure;
	}


	//
	// global IPX address pool that backs up the thread-local ones.
	//
	DNASSERT( g_pGlobalIPXAddressPool == NULL );
	g_pGlobalIPXAddressPool = new CFixedTLPool< CIPXAddress > ( NULL );
	if ( g_pGlobalIPXAddressPool == NULL )
	{
		goto Failure;
	}


	//
	// global IP read data pool that backs up the thread-local ones.
	//
	DNASSERT( g_pGlobalIPReadIODataPool == NULL );
	g_pGlobalIPReadIODataPool = new CContextFixedTLPool< CReadIOData, READ_IO_DATA_POOL_CONTEXT >;
	if ( g_pGlobalIPReadIODataPool != NULL )
	{
		if (! g_pGlobalIPReadIODataPool->Initialize( NULL,
													CReadIOData::ReadIOData_Alloc,
													CReadIOData::ReadIOData_Get,
													CReadIOData::ReadIOData_Release,
													CReadIOData::ReadIOData_Dealloc
													))
		{
			delete	g_pGlobalIPReadIODataPool;
			g_pGlobalIPReadIODataPool = NULL;
			goto Failure;
		}
	}
	else
	{
		goto Failure;
	}


	//
	// global IPX read data pool that backs up the thread-local ones.
	//
	DNASSERT( g_pGlobalIPXReadIODataPool == NULL );
	g_pGlobalIPXReadIODataPool = new CContextFixedTLPool< CReadIOData, READ_IO_DATA_POOL_CONTEXT >;
	if ( g_pGlobalIPXReadIODataPool != NULL )
	{
		if (! g_pGlobalIPXReadIODataPool->Initialize( NULL,
													CReadIOData::ReadIOData_Alloc,
													CReadIOData::ReadIOData_Get,
													CReadIOData::ReadIOData_Release,
													CReadIOData::ReadIOData_Dealloc
													))
		{
			delete	g_pGlobalIPXReadIODataPool;
			g_pGlobalIPXReadIODataPool = NULL;
			goto Failure;
		}
	}
	else
	{
		goto Failure;
	}


	//
	// global command data pool that backs up the thread-local ones.
	//
	DNASSERT( g_pGlobalCommandDataPool == NULL );
	g_pGlobalCommandDataPool = new CLockedTLPool< CCommandData >;
	if ( g_pGlobalCommandDataPool != NULL )
	{
		if ( g_pGlobalCommandDataPool->Initialize( NULL ) == FALSE )
		{
			delete	g_pGlobalCommandDataPool;
			g_pGlobalCommandDataPool = NULL;
			goto Failure;
		}
	}
	else
	{
		goto Failure;
	}


	//
	// global write data pool that backs up the thread-local ones.
	//
	DNASSERT( g_pGlobalWriteIODataPool == NULL );
	g_pGlobalWriteIODataPool = new CContextFixedTLPool< CWriteIOData, WRITE_IO_DATA_POOL_CONTEXT >;
	if ( g_pGlobalWriteIODataPool != NULL )
	{
		if (! g_pGlobalWriteIODataPool->Initialize( NULL,
													CWriteIOData::WriteIOData_Alloc,
													CWriteIOData::WriteIOData_Get,
													CWriteIOData::WriteIOData_Release,
													CWriteIOData::WriteIOData_Dealloc
													))
		{
			delete	g_pGlobalWriteIODataPool;
			g_pGlobalWriteIODataPool = NULL;
			goto Failure;
		}
	}
	else
	{
		goto Failure;
	}


	//
	// prepare thread local pool pointers
	//
	if ( INIT_THREADLOCALPTRS(WSockThreadLocalPools) == FALSE )
	{
		goto Failure;
	}
#endif // USE_THREADLOCALPOOLS


Exit:
	return	fReturn;

Failure:
	fReturn = FALSE;
	DeinitializePools();

	goto Exit;
}
//**********************************************************************




#ifdef USE_THREADLOCALPOOLS
//**********************************************************************
// ------------------------------
// CleanupThreadLocalPools - cleans up the thread local pool entries
//
// Entry:		pointer to structure to cleanup
//				thread ID that owned the structure (may not exist any more)
//
// Exit:		Nothing
// ------------------------------
#undef DPF_MODNAME
#define	DPF_MODNAME "CleanupThreadLocalPools"

void	CleanupThreadLocalPools( WSockThreadLocalPools * pThreadLocalPools, DWORD dwThreadID )
{
	if (pThreadLocalPools->pWriteIODataPool != NULL)
	{
		DPFX(DPFPREP, 8, "Cleaning up thread %u/0x%x's write I/O data pool 0x%p.",
			dwThreadID, dwThreadID, pThreadLocalPools->pWriteIODataPool);
		pThreadLocalPools->pWriteIODataPool->Deinitialize();
		delete pThreadLocalPools->pWriteIODataPool;
	}

	if (pThreadLocalPools->pCommandDataPool != NULL)
	{
		DPFX(DPFPREP, 8, "Cleaning up thread %u/0x%x's command data pool 0x%p.",
			dwThreadID, dwThreadID, pThreadLocalPools->pCommandDataPool);
		pThreadLocalPools->pCommandDataPool->Deinitialize();
		delete pThreadLocalPools->pCommandDataPool;
	}

	if (pThreadLocalPools->pIPXReadIODataPool != NULL)
	{
		DPFX(DPFPREP, 8, "Cleaning up thread %u/0x%x's IPX read I/O data pool 0x%p.",
			dwThreadID, dwThreadID, pThreadLocalPools->pIPXReadIODataPool);
		pThreadLocalPools->pIPXReadIODataPool->Deinitialize();
		delete pThreadLocalPools->pIPXReadIODataPool;
	}

	if (pThreadLocalPools->pIPReadIODataPool != NULL)
	{
		DPFX(DPFPREP, 8, "Cleaning up thread %u/0x%x's IP read I/O data pool 0x%p.",
			dwThreadID, dwThreadID, pThreadLocalPools->pIPReadIODataPool);
		pThreadLocalPools->pIPReadIODataPool->Deinitialize();
		delete pThreadLocalPools->pIPReadIODataPool;
	}

	if ( pThreadLocalPools->pIPXAddressPool != NULL )
	{
		DPFX(DPFPREP, 8, "Cleaning up thread %u/0x%x's IPX address pool 0x%p.",
			dwThreadID, dwThreadID, pThreadLocalPools->pIPXAddressPool);
		delete pThreadLocalPools->pIPXAddressPool;
	}

	if ( pThreadLocalPools->pIPAddressPool != NULL )
	{
		DPFX(DPFPREP, 8, "Cleaning up thread %u/0x%x's IP address pool 0x%p.",
			dwThreadID, dwThreadID, pThreadLocalPools->pIPAddressPool);
		delete pThreadLocalPools->pIPAddressPool;
	}
}
//**********************************************************************
#endif // USE_THREADLOCALPOOLS





//**********************************************************************
// ------------------------------
// DeinitializePools - deinitialize the pools
//
// Entry:		Nothing
//
// Exit:		Nothing
// ------------------------------
#undef DPF_MODNAME
#define	DPF_MODNAME "DeinitializePools"

void	DeinitializePools( void )
{
#ifdef USE_THREADLOCALPOOLS
	//
	// Note that we are shutting down.
	//
	g_fShuttingDown = TRUE;


	DEINIT_THREADLOCALPTRS(WSockThreadLocalPools, CleanupThreadLocalPools);


	//
	// global write data pool that backs up the thread-local ones.
	//
	if ( g_pGlobalWriteIODataPool != NULL )
	{
		g_pGlobalWriteIODataPool->Deinitialize();
		delete	g_pGlobalWriteIODataPool;
		g_pGlobalWriteIODataPool = NULL;
	}


	//
	// global command data pool that backs up the thread-local ones.
	//
	if ( g_pGlobalCommandDataPool != NULL )
	{
		g_pGlobalCommandDataPool->Deinitialize();
		delete	g_pGlobalCommandDataPool;
		g_pGlobalCommandDataPool = NULL;
	}


	//
	// global IPX read data pool that backs up the thread-local ones.
	//
	if ( g_pGlobalIPXReadIODataPool != NULL )
	{
		g_pGlobalIPXReadIODataPool->Deinitialize();
		delete	g_pGlobalIPXReadIODataPool;
		g_pGlobalIPXReadIODataPool = NULL;
	}


	//
	// global IP read data pool that backs up the thread-local ones.
	//
	if ( g_pGlobalIPReadIODataPool != NULL )
	{
		g_pGlobalIPReadIODataPool->Deinitialize();
		delete	g_pGlobalIPReadIODataPool;
		g_pGlobalIPReadIODataPool = NULL;
	}


	//
	// global IPX address pool that backs up the thread-local ones.
	//
	if ( g_pGlobalIPXAddressPool != NULL )
	{
		delete	g_pGlobalIPXAddressPool;
		g_pGlobalIPXAddressPool = NULL;
	}


	//
	// global IP address pool that backs up the thread-local ones.
	//
	if ( g_pGlobalIPAddressPool != NULL )
	{
		delete	g_pGlobalIPAddressPool;
		g_pGlobalIPAddressPool = NULL;
	}
#endif // USE_THREADLOCALPOOLS


	//
	// thread pool pool
	//
	if ( g_pThreadPoolPool != NULL )
	{
		g_pThreadPoolPool->Deinitialize();
		delete	g_pThreadPoolPool;
		g_pThreadPoolPool = NULL;
	}

	//
	// socket port pool
	//
	if ( g_pSocketPortPool != NULL )
	{
		g_pSocketPortPool->Deinitialize();
		delete	g_pSocketPortPool;
		g_pSocketPortPool = NULL;
	}

	//
	// endpoint command parameter pool
	//
	if ( g_pEndpointCommandParameterPool != NULL )
	{
		g_pEndpointCommandParameterPool->Deinitialize();
		delete	g_pEndpointCommandParameterPool;
		g_pEndpointCommandParameterPool = NULL;
	}

	//
	// endpoint pools
	//
	if ( g_pIPXEndpointPool != NULL )
	{
		g_pIPXEndpointPool->Deinitialize();
		delete	g_pIPXEndpointPool;
		g_pIPXEndpointPool = NULL;
	}

	if ( g_pIPEndpointPool != NULL )
	{
		g_pIPEndpointPool->Deinitialize();
		delete	g_pIPEndpointPool;
		g_pIPEndpointPool = NULL;
	}


#ifndef USE_THREADLOCALPOOLS
	//
	// address pools
	//
	if ( g_pIPXAddressPool != NULL )
	{
		delete	g_pIPXAddressPool;
		g_pIPXAddressPool = NULL;
	}

	if ( g_pIPAddressPool != NULL )
	{
		delete	g_pIPAddressPool;
		g_pIPAddressPool = NULL;
	}

	//
	// remove lock for endpoint and address pools
	//
	DNDeleteCriticalSection( &g_AddressLock );
	


	//
	// command data pool
	//
	if ( g_pCommandDataPool != NULL )
	{
		g_pCommandDataPool->Deinitialize();
		delete	g_pCommandDataPool;
		g_pCommandDataPool = NULL;
	}
#endif // ! USE_THREADLOCALPOOLS

	
	//
	// AdapterEntry pool
	//
	if ( g_pAdapterEntryPool != NULL )
	{
		g_pAdapterEntryPool->Deinitialize();
		delete	g_pAdapterEntryPool;
		g_pAdapterEntryPool = NULL;
	}
}
//**********************************************************************


//**********************************************************************
// ------------------------------
// CreateAdapterEntry - create an adapter entry
//
// Entry:		Nothing
//
// Exit:		Poiner to entry (NULL = out of memory)
// ------------------------------
#undef DPF_MODNAME
#define	DPF_MODNAME "CreateAdapterEntry"

CAdapterEntry	*CreateAdapterEntry( void )
{
	DNASSERT( g_pAdapterEntryPool != NULL );
	return	g_pAdapterEntryPool->Get();
}
//**********************************************************************


//**********************************************************************
// ------------------------------
// ReturnAdapterEntry - return an adapter entry to the pool
//
// Entry:		Pointer to entry
//
// Exit:		Nothing
// ------------------------------
#undef DPF_MODNAME
#define	DPF_MODNAME "ReturnAdapterEntry"

void	ReturnAdapterEntry( CAdapterEntry *const pAdapterEntry )
{
	DNASSERT( FALSE );
	DNASSERT( pAdapterEntry != NULL );
	DNASSERT( g_pAdapterEntryPool != NULL );
	g_pAdapterEntryPool->Release( pAdapterEntry );
}
//**********************************************************************


//**********************************************************************
// ------------------------------
// CreateCommand - create command
//
// Entry:		Nothing
//
// Exit:		Nothing
// ------------------------------
#undef DPF_MODNAME
#define	DPF_MODNAME "CreateCommand"

CCommandData	*CreateCommand( void )
{
#ifdef USE_THREADLOCALPOOLS
	CLockedTLPool< CCommandData > *		pPool;
	BOOL								fResult;
	CCommandData *						pCommandData;

	//
	// Get the pool pointer.
	//
	GET_THREADLOCALPTR(WSockThreadLocalPools,
						pCommandDataPool,
						&pPool);

	//
	// Create the pool if it didn't exist.
	//
	if (pPool == NULL)
	{
		pPool = new CLockedTLPool<CCommandData>;
		if (pPool == NULL)
		{
			pCommandData = NULL;
			goto Exit;
		}


		//
		// Try to initialize the pool.
		//
		if ( pPool->Initialize(g_pGlobalCommandDataPool) == FALSE )
		{
			//
			// Initializing pool failed, delete it and abort.
			//
			delete	pPool;
			pCommandData = NULL;
			goto Exit;
		}


		//
		// Associate the pool with this thread.
		//
		SET_THREADLOCALPTR(WSockThreadLocalPools,
							pCommandDataPool,
							pPool,
							&fResult);

		if (! fResult)
		{
			//
			// Associating pool with thread failed, de-initialize it, delete it,
			// and abort.
			//
			pPool->Deinitialize();
			delete pPool;
			pCommandData = NULL;
			goto Exit;
		}
	}

	//
	// Get an item out of the pool.
	//
	pCommandData = pPool->Get();


Exit:
	
	return	pCommandData;
#else // ! USE_THREADLOCALPOOLS
	DNASSERT( g_pCommandDataPool != NULL );
	return	g_pCommandDataPool->Get();
#endif // ! USE_THREADLOCALPOOLS
}
//**********************************************************************


//**********************************************************************
// ------------------------------
// ReturnCommand - return a command
//
// Entry:		Pointer to command
//
// Exit:		Nothing
// ------------------------------
#undef DPF_MODNAME
#define	DPF_MODNAME "ReturnCommand"

void	ReturnCommand( CCommandData *const pCommand )
{
#ifdef USE_THREADLOCALPOOLS
	CLockedTLPool< CCommandData > *		pPool;
	BOOL								fResult;


	DNASSERT( pCommand != NULL );


	//
	// Get the pool pointer.
	//
	GET_THREADLOCALPTR(WSockThreadLocalPools,
						pCommandDataPool,
						&pPool);


	//
	// Create the pool if it didn't exist.
	//
	if (pPool == NULL)
	{
		if (g_fShuttingDown)
		{
			//
			// Don't try to allocate the pool, just release the item.
			//
			CLockedTLPool<CCommandData>::ReleaseWithoutPool(pCommand);

			return;
		}

		
		pPool = new CLockedTLPool<CCommandData>;
		if (pPool == NULL)
		{
			//
			// Couldn't create this thread's pool, just release the item
			// without the pool.
			//
			CLockedTLPool<CCommandData>::ReleaseWithoutPool(pCommand);

			return;
		}


		//
		// Try to initialize the pool.
		//
		if ( pPool->Initialize(g_pGlobalCommandDataPool) == FALSE )
		{
			//
			// Initializing this thread's pool failed, just release the
			// item without the pool, and destroy the pool object that
			// couldn't be used.
			//
			CLockedTLPool<CCommandData>::ReleaseWithoutPool(pCommand);
			delete pPool;

			return;
		}

		SET_THREADLOCALPTR(WSockThreadLocalPools,
							pCommandDataPool,
							pPool,
							&fResult);
		if (! fResult)
		{
			//
			// Couldn't store this thread's pool, just release the item
			// without the pool, plus de-initialize and destroy the pool
			// object that couldn't be used.
			//
			CLockedTLPool<CCommandData>::ReleaseWithoutPool(pCommand);
			pPool->Deinitialize();
			delete pPool;
			return;
		}
	}

	pPool->Release(pCommand);
#else // ! USE_THREADLOCALPOOLS
	DNASSERT( pCommand != NULL );
	DNASSERT( g_pCommandDataPool != NULL );
	g_pCommandDataPool->Release( pCommand );
#endif // ! USE_THREADLOCALPOOLS
}
//**********************************************************************


//**********************************************************************
// ------------------------------
// CreateEndpointCommandParameter - create an endpoint command parameter
//
// Entry:		Nothing
//
// Exit:		Pointer endpoint command parameter
// ------------------------------
#undef DPF_MODNAME
#define	DPF_MODNAME "CreateEndpointCommandParameters"

ENDPOINT_COMMAND_PARAMETERS	*CreateEndpointCommandParameters( void )
{
	ENDPOINT_COMMAND_PARAMETERS	*pReturn;

	
	DNASSERT( g_pEndpointCommandParameterPool != NULL );
	pReturn = g_pEndpointCommandParameterPool->Get();
	if ( pReturn != NULL )
	{
		memset( pReturn, 0x00, sizeof( *pReturn ) );
	}

	return	pReturn;
}
//**********************************************************************


//**********************************************************************
// ------------------------------
// ReturnEndpointCommandParameter - return an endpoint command parameter
//
// Entry:		Nothing
//
// Exit:		Pointer to endpoint command parameter
// ------------------------------
#undef DPF_MODNAME
#define	DPF_MODNAME "ReturnEndpointCommandParameters"

void	ReturnEndpointCommandParameters( ENDPOINT_COMMAND_PARAMETERS *const pCommandParameters )
{
	DNASSERT( pCommandParameters != NULL );
	DNASSERT( g_pEndpointCommandParameterPool != NULL );
	g_pEndpointCommandParameterPool->Release( pCommandParameters );
}
//**********************************************************************


//**********************************************************************
// ------------------------------
// CreateIPAddress - create IP address
//
// Entry:		Nothing
//
// Exit:		Pointer to IP address
// ------------------------------
#undef DPF_MODNAME
#define	DPF_MODNAME "CreateIPAddress"

CIPAddress	*CreateIPAddress( void )
{
#ifdef USE_THREADLOCALPOOLS
	CFixedTLPool< CIPAddress > *	pPool;
	BOOL							fResult;
	CIPAddress *					pReturnAddress;

	//
	// Get the pool pointer.
	//
	GET_THREADLOCALPTR(WSockThreadLocalPools,
						pIPAddressPool,
						&pPool);

	//
	// Create the pool if it didn't exist.
	//
	if (pPool == NULL)
	{
		pPool = new CFixedTLPool<CIPAddress>(g_pGlobalIPAddressPool);
		if (pPool == NULL)
		{
			pReturnAddress = NULL;
			goto Exit;
		}

		//
		// Associate the pool with this thread.
		//
		SET_THREADLOCALPTR(WSockThreadLocalPools,
							pIPAddressPool,
							pPool,
							&fResult);

		if (! fResult)
		{
			delete pPool;
			pReturnAddress = NULL;
			goto Exit;
		}
	}

	//
	// Get an item out of the pool.
	//
	pReturnAddress = pPool->Get();


Exit:
	
	return	pReturnAddress;
#else // ! USE_THREADLOCALPOOLS
	CIPAddress	*pReturnAddress;


	DNASSERT( g_pIPAddressPool != NULL );

	DNEnterCriticalSection( &g_AddressLock );
	pReturnAddress = g_pIPAddressPool->Get();
	DNLeaveCriticalSection( &g_AddressLock );
	
	return	pReturnAddress;
#endif // ! USE_THREADLOCALPOOLS
}
//**********************************************************************


//**********************************************************************
// ------------------------------
// ReturnIPAddress - return an IP address
//
// Entry:		Pointer to IP address
//
// Exit:		Nothing
// ------------------------------
#undef DPF_MODNAME
#define	DPF_MODNAME "ReturnIPAddress"

void	ReturnIPAddress( CIPAddress *const pIPAddress )
{
#ifdef USE_THREADLOCALPOOLS
	CFixedTLPool< CIPAddress > *	pPool;
	BOOL							fResult;


	DNASSERT( pIPAddress != NULL );

	//
	// Get the pool pointer.
	//
	GET_THREADLOCALPTR(WSockThreadLocalPools,
						pIPAddressPool,
						&pPool);


	//
	// Create the pool if it didn't exist, unless we're shutting down.
	//
	if (pPool == NULL)
	{
		if (g_fShuttingDown)
		{
			//
			// Don't try to allocate the pool, just release the item.
			//
			CFixedTLPool<CIPAddress>::ReleaseWithoutPool(pIPAddress);

			return;
		}

		pPool = new CFixedTLPool<CIPAddress>(g_pGlobalIPAddressPool);
		if (pPool == NULL)
		{
			//
			// Couldn't create this thread's pool, just release the item
			// without the pool.
			//
			CFixedTLPool<CIPAddress>::ReleaseWithoutPool(pIPAddress);

			return;
		}

		SET_THREADLOCALPTR(WSockThreadLocalPools,
							pIPAddressPool,
							pPool,
							&fResult);
		if (! fResult)
		{
			//
			// Couldn't store this thread's pool, just release the item
			// without the pool, and destroy the pool object that
			// couldn't be used.
			//
			CFixedTLPool<CIPAddress>::ReleaseWithoutPool(pIPAddress);
			delete pPool;
			return;
		}
	}

	pPool->Release(pIPAddress);
#else // ! USE_THREADLOCALPOOLS
	DNASSERT( pIPAddress != NULL );
	DNASSERT( g_pIPAddressPool != NULL );
	DNEnterCriticalSection( &g_AddressLock );
	g_pIPAddressPool->Release( pIPAddress );
	DNLeaveCriticalSection( &g_AddressLock );
#endif // ! USE_THREADLOCALPOOLS
}
//**********************************************************************


//**********************************************************************
// ------------------------------
// CreateIPXAddress - create IPX address
//
// Entry:		Nothing
//
// Exit:		Pointer to IPX address
// ------------------------------
#undef DPF_MODNAME
#define	DPF_MODNAME "CreateIPXAddress"

CIPXAddress	*CreateIPXAddress( void )
{
#ifdef USE_THREADLOCALPOOLS
	CFixedTLPool< CIPXAddress > *	pPool;
	BOOL							fResult;
	CIPXAddress *					pReturnAddress;


	//
	// Get the pool pointer.
	//
	GET_THREADLOCALPTR(WSockThreadLocalPools,
						pIPXAddressPool,
						&pPool);

	//
	// Create the pool if it didn't exist.
	//
	if (pPool == NULL)
	{
		pPool = new CFixedTLPool<CIPXAddress>(g_pGlobalIPXAddressPool);
		if (pPool == NULL)
		{
			pReturnAddress = NULL;
			goto Exit;
		}

		//
		// Associate the pool with this thread.
		//
		SET_THREADLOCALPTR(WSockThreadLocalPools,
							pIPXAddressPool,
							pPool,
							&fResult);

		if (! fResult)
		{
			delete pPool;
			pReturnAddress = NULL;
			goto Exit;
		}
	}

	//
	// Get an item out of the pool.
	//
	pReturnAddress = pPool->Get();


Exit:
	
	return	pReturnAddress;
#else // ! USE_THREADLOCALPOOLS
	CIPXAddress	*pReturnAddress;


	DNASSERT( g_pIPXAddressPool != NULL );

	DNEnterCriticalSection( &g_AddressLock );
	pReturnAddress = g_pIPXAddressPool->Get();
	DNLeaveCriticalSection( &g_AddressLock );
	
	return	pReturnAddress;
#endif // ! USE_THREADLOCALPOOLS
}
//**********************************************************************


//**********************************************************************
// ------------------------------
// ReturnIPXAddress - return an IPX address
//
// Entry:		Pointer to IPX address
//
// Exit:		Nothing
// ------------------------------
#undef DPF_MODNAME
#define	DPF_MODNAME "ReturnIPXAddress"

void	ReturnIPXAddress( CIPXAddress *const pIPXAddress )
{
#ifdef USE_THREADLOCALPOOLS
	CFixedTLPool< CIPXAddress > *	pPool;
	BOOL							fResult;


	DNASSERT( pIPXAddress != NULL );


	//
	// Get the pool pointer.
	//
	GET_THREADLOCALPTR(WSockThreadLocalPools,
						pIPXAddressPool,
						&pPool);


	//
	// Create the pool if it didn't exist.
	//
	if (pPool == NULL)
	{
		if (g_fShuttingDown)
		{
			//
			// Don't try to allocate the pool, just release the item.
			//
			CFixedTLPool<CIPXAddress>::ReleaseWithoutPool(pIPXAddress);

			return;
		}

		
		pPool = new CFixedTLPool<CIPXAddress>(g_pGlobalIPXAddressPool);
		if (pPool == NULL)
		{
			//
			// Couldn't create this thread's pool, just release the item
			// without the pool.
			//
			CFixedTLPool<CIPXAddress>::ReleaseWithoutPool(pIPXAddress);

			return;
		}

		SET_THREADLOCALPTR(WSockThreadLocalPools,
							pIPXAddressPool,
							pPool,
							&fResult);
		if (! fResult)
		{
			//
			// Couldn't store this thread's pool, just release the item
			// without the pool, and destroy the pool object that
			// couldn't be used.
			//
			CFixedTLPool<CIPXAddress>::ReleaseWithoutPool(pIPXAddress);
			delete pPool;
			return;
		}
	}

	pPool->Release(pIPXAddress);
#else // ! USE_THREADLOCALPOOLS
	DNASSERT( pIPXAddress != NULL );
	DNASSERT( g_pIPXAddressPool != NULL );
	DNEnterCriticalSection( &g_AddressLock );
	g_pIPXAddressPool->Release( pIPXAddress );
	DNLeaveCriticalSection( &g_AddressLock );
#endif // ! USE_THREADLOCALPOOLS
}
//**********************************************************************


//**********************************************************************
// ------------------------------
// CreateIPEndpoint - create IP endpoint
//
// Entry:		Pointer to context
//
// Exit:		Pointer to IP endpoint
// ------------------------------
#undef DPF_MODNAME
#define	DPF_MODNAME "CreateEndpoint"

CIPEndpoint	*CreateIPEndpoint( ENDPOINT_POOL_CONTEXT *const pContext )
{
	DNASSERT( g_pIPEndpointPool != NULL );
	return	g_pIPEndpointPool->Get( pContext );
}
//**********************************************************************


//**********************************************************************
// ------------------------------
// CreateIPXEndpoint - create IPX endpoint
//
// Entry:		Pointer to context
//
// Exit:		Pointer to IPX endpoint
// ------------------------------
#undef DPF_MODNAME
#define	DPF_MODNAME "CreateIPXEndpoint"

CIPXEndpoint	*CreateIPXEndpoint( ENDPOINT_POOL_CONTEXT *const pContext )
{
	DNASSERT( g_pIPXEndpointPool != NULL );
	return	g_pIPXEndpointPool->Get( pContext );
}
//**********************************************************************


//**********************************************************************
// ------------------------------
// CreateSocketPort - create a socket port
//
// Entry:		Nothing
//
// Exit:		Pointer to socket port
// ------------------------------
#undef DPF_MODNAME
#define	DPF_MODNAME "CreateSocketPort"

CSocketPort	*CreateSocketPort( void )
{
	CSocketPort	*pReturn;


	DNASSERT( g_pSocketPortPool != NULL );

	pReturn = g_pSocketPortPool->Get();
	if ( pReturn != NULL )
	{
		pReturn->AddRef();
	}
	
	return	pReturn;
}
//**********************************************************************


//**********************************************************************
// ------------------------------
// ReturnSocketPort - return socket port to pool
//
// Entry:		Pointer to socket port
//
// Exit:		Nothing
// ------------------------------
#undef DPF_MODNAME
#define	DPF_MODNAME "ReturnSocketPort"

void	ReturnSocketPort( CSocketPort *const pSocketPort )
{
	DNASSERT( pSocketPort != NULL );
	DNASSERT( g_pSocketPortPool != NULL );
	g_pSocketPortPool->Release( pSocketPort );
}
//**********************************************************************


//**********************************************************************
// ------------------------------
// CreateThreadPool - create a thread pool
//
// Entry:		Nothing
//
// Exit:		Pointer to thread pool
// ------------------------------
#undef DPF_MODNAME
#define	DPF_MODNAME "CreateThreadPool"

CThreadPool	*CreateThreadPool( void )
{
	CThreadPool	*pReturn;


	DNASSERT( g_pThreadPoolPool != NULL );
	pReturn = g_pThreadPoolPool->Get();
	if ( pReturn != NULL )
	{
		pReturn->AddRef();
	}

	return	pReturn;
}
//**********************************************************************


//**********************************************************************
// ------------------------------
// ReturnThreadPool - return a thread pool
//
// Entry:		Pointer to thread pool
//
// Exit:		Nothing
// ------------------------------
#undef DPF_MODNAME
#define	DPF_MODNAME "ReturnThreadPool"

void	ReturnThreadPool( CThreadPool *const pThreadPool )
{
	DNASSERT( pThreadPool != NULL );
	DNASSERT( g_pThreadPoolPool != NULL );
	g_pThreadPoolPool->Release( pThreadPool );
}
//**********************************************************************