/************************************************************************
*																		*
*	INTEL CORPORATION PROPRIETARY INFORMATION							*
*																		*
*	This software is supplied under the terms of a license			   	*
*	agreement or non-disclosure agreement with Intel Corporation		*
*	and may not be copied or disclosed except in accordance	   			*
*	with the terms of that agreement.									*
*																		*
*	Copyright (C) 1997 Intel Corp.	All Rights Reserved					*
*																		*
*	$Archive:   S:\sturgeon\src\gki\vcs\gkreg.cpv  $
*																		*
*	$Revision:   1.6  $
*	$Date:   26 Feb 1997 15:33:34  $
*																		*
*	$Author:   CHULME  $
*																		*
*   $Log:   S:\sturgeon\src\gki\vcs\gkreg.cpv  $
//
//    Rev 1.6   26 Feb 1997 15:33:34   CHULME
// Call Coder.Free in case of error - potential memory leak plugged
//
//    Rev 1.5   14 Feb 1997 16:43:06   CHULME
// Updated comments and removed inaccurate comments
//
//    Rev 1.4   12 Feb 1997 01:12:52   CHULME
// Redid thread synchronization to use Gatekeeper.Lock
//
//    Rev 1.3   08 Feb 1997 12:15:48   CHULME
// Terminate retry thread in destructor via semaphore
//
//    Rev 1.2   21 Jan 1997 17:24:06   CHULME
// Removed gatekeeper identifier from gatekeeper request
//
//    Rev 1.1   17 Jan 1997 09:02:22   CHULME
// Changed reg.h to gkreg.h to avoid name conflict with inc directory
//
//    Rev 1.0   17 Jan 1997 08:48:08   CHULME
// Initial revision.
//
//    Rev 1.7   10 Jan 1997 16:15:58   CHULME
// Removed MFC dependency
//
//    Rev 1.6   20 Dec 1996 16:39:14   CHULME
// Removed extraneous debug statements
//
//    Rev 1.5   20 Dec 1996 01:27:24   CHULME
// Fixed memory leak with gatekeeper identifier
//
//    Rev 1.4   10 Dec 1996 11:26:36   CHULME
// Fixed handling of IRQ to not require response address in PDU
//
//    Rev 1.3   02 Dec 1996 23:49:58   CHULME
// Added premptive synchronization code
//
//    Rev 1.2   22 Nov 1996 15:22:16   CHULME
// Added VCS log to the header
*************************************************************************/

// registration.cpp : Provides the implementation for the CRegistration class
//
#include "precomp.h"

#include <process.h>
#include <stdlib.h>
#include <time.h>
#include "GKICOM.H"
#include "dspider.h"
#include "dgkilit.h"
#include "DGKIPROT.H"
#include "gksocket.h"
#include "GKREG.H"
#include "GATEKPR.H"
#include "h225asn.h"
#include "coder.hpp"
#include "dgkiext.h"
#include "ccerror.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CLinkedList Implementation

template <class T> CLinkedList<T>::CLinkedList()
{
	pTail = NULL;
	iCount = 0;
}

template <class T> CLinkedList<T>::~CLinkedList()
{
	RemoveAll();
}

template <class T> void CLinkedList<T>::AddTail (const T& NewItem)
{
	AddTailPriv(new TItem<T>(NewItem));
}

template <class T> void CLinkedList<T>::AddTailPriv(TItem<T> *pNewItem)
{
	if (pTail) // if the list is non-empty - add to tail
	{
		pNewItem->pPrev = pTail;
		pNewItem->pNext = pTail->pNext;			// preserve the pointer to the head.
		pTail->pNext->pPrev = pNewItem;
		pTail->pNext = pNewItem;				// insert the new element
	}
	else										// insert first element
	{											// new element is the tail
		pNewItem->pPrev = pNewItem->pNext = pNewItem;	
	}

	pTail = pNewItem;							// move tail to the new item
	iCount++;
}

template <class T> BOOL CLinkedList<T>::IsEmpty(void)
{
	if (pTail == NULL)
	{ return TRUE; }
	else
	{ return FALSE; }
}

template <class T> POS CLinkedList<T>::GetFirstPos (void)
{
	if (pTail)
	{	return (POS) pTail->pNext;
	}
	else
	{	return NULL;
	}
}

template <class T> T CLinkedList<T>::GetNext (POS &Position)
{
	TItem<T> *pCurItem = (TItem<T> *)Position;
	T RetValue = NULL;              // Prefast warns for uninitialized
	                                // data when T is a pointer type and
	                                // Position is NULL. Need to "initialize"
                                    // RetValue so "something"

	if (Position)
	{
		RetValue = pCurItem->Value;
		if (pCurItem == pTail)		// we are at the end of the list
		{	Position = NULL;
		}
		else						// move to the next position
		{	Position = (POS)(pCurItem->pNext);
		}
	}
	return RetValue;
}

template <class T> POS CLinkedList<T>::Find (const T& Item)
{
	TItem<T> *pCurItem;
	
	if (!pTail)
	{	return NULL;
	}
	else
	{	
		pCurItem = pTail;
		do
		{
			pCurItem = pCurItem->pNext;	// starting with the head
			if (pCurItem->Value == Item)
			{	return ((POS) pCurItem); }
		}
		while (pCurItem != pTail);
	}
	return NULL;
}

// It moves Position to the next item after removint the current one.
template <class T> BOOL CLinkedList<T>::RemoveAt (POS &Position)
{
	TItem<T> *pCurItem = (TItem<T> *)Position;

	if (!pCurItem)
	{	return FALSE; }
	else if (pCurItem == pCurItem->pNext)		// The only element
	{
		Position = NULL;
		pTail = NULL;
		delete pCurItem;
	}
	else
	{
		Position = (POS) pCurItem->pNext;
		pCurItem->pPrev->pNext = pCurItem->pNext;
		pCurItem->pNext->pPrev = pCurItem->pPrev;
		if (pCurItem == pTail)
		{
			pTail = pCurItem->pPrev;
		}
		delete pCurItem;
	}
	iCount--;
	return TRUE;
}

template <class T> T CLinkedList<T>::GetAt(const POS Position)
{
	TItem<T> *pCurItem = (TItem<T> *)Position;
	T RetValue = NULL;              // Prefast warns for uninitialized
	                                // data when T is a pointer type and
	                                // Position is NULL. Need to "initialize"
                                    // RetValue so "something"

	if (Position)
	{	RetValue = pCurItem->Value;
	}

	return RetValue;
}

template <class T> void CLinkedList<T>::RemoveAll(void)
{
	TItem<T> *pCurItem;
	TItem<T> *pNextItem;

	if (pTail)
	{	
		pCurItem = pTail->pNext;			// Start with the head.
		pTail->pNext = NULL;

		while (pCurItem != NULL)
		{
			pNextItem = pCurItem->pNext;
			delete pCurItem;
			pCurItem = pNextItem;
		}
	}
	pTail = NULL;
	iCount = 0;
}

template <class T> int CLinkedList<T>::GetCount(void)
{
	return iCount;
}


VOID CALLBACK RetryTimerProc(HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)
{

#ifdef _DEBUG
	char			szGKDebug[80];
#endif
	HRESULT			hResult = GKI_OK;
	
	ASSERT(g_pGatekeeper);
	if(g_pGatekeeper == NULL)
		return;
		
	g_pGatekeeper->Lock();
	if(g_pReg)
	{
		hResult = g_pReg->Retry();
	}

	if(hResult != GKI_OK)
	{
		SPIDER_TRACE(SP_NEWDEL, "del g_pReg = %X\n", g_pReg);
		delete g_pReg;
		g_pReg = 0;
	}
	g_pGatekeeper->Unlock();
}



/////////////////////////////////////////////////////////////////////////////
// CRegistration construction

CRegistration::CRegistration()
{
	// ABSTRACT:  The constructor for the CRegistration class will initialize
	//            the member variables.  Notably missing is the construction
	//            of the pointed to socket object.  This must be done after
	//            constructing this object to allow for checking the error code.
	// AUTHOR:    Colin Hulme

#ifdef _DEBUG
	char			szGKDebug[80];
#endif

	SPIDER_TRACE(SP_CONDES, "CRegistration::CRegistration()\n", 0);
	m_pVendorInfo = NULL;
	m_pCallSignalAddress = 0;
	memset(&m_terminalType, 0, sizeof(EndpointType));
	m_pRgstrtnRqst_trmnlAls = 0;
	m_hWnd = 0;
	m_wBaseMessage = 0;
	m_usRegistrationTransport = 0;

	m_pLocationInfo = 0;
	memset(&m_Location[0], 0, sizeof(TransportAddress) * 2);

	memset(&m_RCm_gtkprIdntfr, 0, sizeof(GatekeeperIdentifier));
	memset(&m_endpointID, 0, sizeof(EndpointIdentifier));

	m_requestSeqNum = 0;
	m_pRASAddress = 0;

	m_State = GK_REG_PENDING;
	SPIDER_TRACE(SP_STATE, "m_State = GK_REG_PENDING (%X)\n", this);

	m_pRasMessage = 0;
	m_pSocket = 0;
	m_hRcvThread = 0;
//	m_hRetryThread = 0;

	m_uTimer = 0;
	m_uRetryResetCount = GKR_RETRY_INTERVAL_SECONDS * (1000/GKR_RETRY_TICK_MS);
	m_uRetryCountdown = GKR_RETRY_INTERVAL_SECONDS;
	m_uMaxRetryCount = GKR_RETRY_MAX;
	m_usRetryCount = 0;
	InitializeCriticalSection(&m_SocketCRS);

#ifdef BROADCAST_DISCOVERY	
	m_hDiscThread = 0;
#endif
//	m_dwLockingThread = 0;
//	m_hRetrySemaphore = NULL;

//	InitializeCriticalSection(&m_CriticalSection);

	// Initialize the base call reference value to a random number
	srand( (unsigned)time( NULL ) );
	m_usCallReferenceValue = (unsigned short)rand();
}

/////////////////////////////////////////////////////////////////////////////
// CRegistration destruction

CRegistration::~CRegistration()
{
	// ABSTRACT:  The destructor for the CRegistration class must free the
	//            memory allocated for the Transport addresses and Alias
	//            addresses.  It does this by deleting the structures and
	//            walking the link list.
	// AUTHOR:    Colin Hulme

	SeqTransportAddr	*pTA1, *pTA2;
	SeqAliasAddr		*pAA1, *pAA2;
	DWORD				dwErrorCode;
#ifdef _DEBUG
	char				szGKDebug[80];
#endif

	SPIDER_TRACE(SP_CONDES, "CRegistration::~CRegistration()\n", 0);

#if(0)
	// Terminate the Retry Thread
	if(m_hRetryThread)
	{
		if(m_hRetrySemaphore)
		{
			SPIDER_TRACE(SP_THREAD, "Release retry thread %X\n", m_hRetryThread);
			// Signal the thread to shutdown
			ReleaseSemaphore(m_hRetrySemaphore,1,NULL);

			// Wait for the thread to terminate
			dwErrorCode = WaitForSingleObject(m_hRetryThread, TIMEOUT_THREAD);
			m_hRetryThread = NULL;
		}
	}
#else

	// Stop retry timer
	if(m_uTimer)
	{
		KillTimer(m_hWnd, m_uTimer);
	}
#endif
	if(m_pVendorInfo)
		FreeVendorInfo(m_pVendorInfo);
		
	// Delete allocated memory for sequence of call signal addresses
	pTA1 = m_pCallSignalAddress;
	while (pTA1 != 0)
	{
		pTA2 = pTA1->next;
		SPIDER_TRACE(SP_NEWDEL, "del pTA1 = %X\n", pTA1);
		delete pTA1;
		pTA1 = pTA2;
	}

	// Delete allocated memory for sequence of alias addresses
	pAA1 = m_pRgstrtnRqst_trmnlAls;
	while (pAA1 != 0)
	{
		pAA2 = pAA1->next;
		if (pAA1->value.choice == h323_ID_chosen)
		{
			SPIDER_TRACE(SP_NEWDEL, "del pAA1->value.u.h323_ID.value = %X\n", pAA1->value.u.h323_ID.value);
			delete pAA1->value.u.h323_ID.value;
		}
		SPIDER_TRACE(SP_NEWDEL, "del pAA1 = %X\n", pAA1);
		delete pAA1;
		pAA1 = pAA2;
	}

	// Delete allocated memory for sequence of location alias addresses
	pAA1 = m_pLocationInfo;
	while (pAA1 != 0)
	{
		pAA2 = pAA1->next;
		if (pAA1->value.choice == h323_ID_chosen)
		{
			SPIDER_TRACE(SP_NEWDEL, "del pAA1->value.u.h323_ID.value = %X\n", pAA1->value.u.h323_ID.value);
			delete pAA1->value.u.h323_ID.value;
		}
		SPIDER_TRACE(SP_NEWDEL, "del pAA1 = %X\n", pAA1);
		delete pAA1;
		pAA1 = pAA2;
	}

	// Delete allocated memory for identifiers
	if (m_RCm_gtkprIdntfr.length)
	{
		SPIDER_TRACE(SP_NEWDEL, "del m_RCm_gtkprIdntfr.value = %X\n", m_RCm_gtkprIdntfr.value);
		delete m_RCm_gtkprIdntfr.value;
	}
	if (m_endpointID.length)
	{
		SPIDER_TRACE(SP_NEWDEL, "del m_endpointID.value = %X\n", m_endpointID.value);
		delete m_endpointID.value;
	}

	// Delete allocated memory for sequence of RAS addresses
	pTA1 = m_pRASAddress;
	while (pTA1 != 0)
	{
		pTA2 = pTA1->next;
		SPIDER_TRACE(SP_NEWDEL, "del pTA1 = %X\n", pTA1);
		delete pTA1;
		pTA1 = pTA2;
	}

	if (!m_Calls.IsEmpty())
	{
		// Free up any call objects
		// on this registration object
		POS pos;
		for( pos = m_Calls.GetFirstPos(); pos != NULL; )
		{
			// Delete the call object
			CCall *pCall = m_Calls.GetNext(pos);
			SPIDER_TRACE(SP_NEWDEL, "del pCall = %X\n", pCall);
			delete pCall;
		}
		// Now remove all pointers from the list
		m_Calls.RemoveAll();
	}

	// Delete memory for last RAS message if still allocated
	if (m_pRasMessage)
	{
		SPIDER_TRACE(SP_NEWDEL, "del m_pRasMessage = %X\n", m_pRasMessage);
		delete m_pRasMessage;
	}

//	if (m_dwLockingThread)
//		Unlock();
//	DeleteCriticalSection(&m_CriticalSection);
#if(0)
	if(m_hRetrySemaphore)
	{
		CloseHandle(m_hRetrySemaphore);
		m_hRetrySemaphore = NULL;
	}
#endif

	
	m_pSocket->Close();
	
	LockSocket();
	// Close the socket and delete the socket object
	SPIDER_TRACE(SP_NEWDEL, "del m_pSocket = %X\n", m_pSocket);
	delete m_pSocket;
	UnlockSocket();

	DeleteCriticalSection(&m_SocketCRS);
}

UINT_PTR CRegistration::StartRetryTimer(void)
{
	if(m_uTimer)
	{
		KillTimer(m_hWnd, m_uTimer);
		m_uTimer = 0;
	}
	m_uRetryResetCount = GKR_RETRY_INTERVAL_SECONDS * (1000/GKR_RETRY_TICK_MS);
	m_uRetryCountdown = GKR_RETRY_INTERVAL_SECONDS;
	m_uMaxRetryCount = GKR_RETRY_MAX;
	m_usRetryCount = 0;

	m_uTimer = SetTimer(NULL, NULL, GKR_RETRY_TICK_MS, RetryTimerProc);
	//m_uTimer = SetTimer(hWnd, GKREG_TIMER_ID, GKR_RETRY_TICK_MS, RetryTimerProc);
	return m_uTimer;
}

HRESULT
CRegistration::AddVendorInfo(PCC_VENDORINFO pVendorInfo)
{
	HRESULT hr = GKI_OK;
	if(m_pVendorInfo)
	{
		FreeVendorInfo(m_pVendorInfo);
		m_pVendorInfo = NULL;
	}
	if(pVendorInfo)
	{
		hr = CopyVendorInfo(&m_pVendorInfo, pVendorInfo);
		if(hr != CC_OK)
		{
			m_pVendorInfo = NULL;
		}
	}
	return hr;
}

HRESULT
CRegistration::AddCallSignalAddr(TransportAddress& rvalue)
{
	// ABSTRACT:  This procedure is called to add a call signal address
	//            to the link list of call signal addresses.  This will
	//            be called for each transport on receiving a GKI_RegistrationRequest.
	//            A local copy is made to avoid reliance on the client
	//            keeping the memory valid.  This procedure returns 0 if
	//            successful and non-zero for a failure.
	// AUTHOR:    Colin Hulme

	SeqTransportAddr			*pCSA;
#ifdef _DEBUG
	char						szGKDebug[80];
#endif

	SPIDER_TRACE(SP_FUNC, "CRegistration::AddCallSignalAddr(%X)\n", rvalue.choice);

	if (m_pCallSignalAddress == 0)	// First one in the list
	{
		m_pCallSignalAddress = new SeqTransportAddr;
		SPIDER_TRACE(SP_NEWDEL, "new m_pCallSignalAddress = %X\n", m_pCallSignalAddress);
		if (m_pCallSignalAddress == 0)
			return (GKI_NO_MEMORY);
		memset(m_pCallSignalAddress, 0, sizeof(SeqTransportAddr));
		pCSA = m_pCallSignalAddress;
	}
	else
	{
		for (pCSA = m_pCallSignalAddress; pCSA->next != 0; pCSA = pCSA->next)
			;						// walk the list til last entry
		pCSA->next = new SeqTransportAddr;
		SPIDER_TRACE(SP_NEWDEL, "new pCSA->next = %X\n", pCSA->next);
		if (pCSA->next == 0)
			return (GKI_NO_MEMORY);
		memset(pCSA->next, 0, sizeof(SeqTransportAddr));
		pCSA = pCSA->next;
	}
	pCSA->next = 0;					// initialize new structure fields
	pCSA->value = rvalue;
	return (GKI_OK);
}

HRESULT
CRegistration::AddRASAddr(TransportAddress& rvalue, unsigned short usPort)
{
	// ABSTRACT:  This procedure is called to add a RAS address
	//            to the link list of RAS addresses.  This will
	//            be called only for the transport used for the registration
	//            request.  This procedure returns 0 if successful and non-zero
	//            for a failure.
	// AUTHOR:    Colin Hulme

#ifdef _DEBUG
	char			szGKDebug[80];
#endif

	SPIDER_TRACE(SP_FUNC, "CRegistration::AddRASAddr(%X, usPort)\n", rvalue.choice);

	m_pRASAddress = new SeqTransportAddr;
	SPIDER_TRACE(SP_NEWDEL, "new m_pRASAddress = %X\n", m_pRASAddress);
	if (m_pRASAddress == 0)
		return (GKI_NO_MEMORY);
	memset(m_pRASAddress, 0, sizeof(SeqTransportAddr));
	m_pRASAddress->next = 0;					// initialize new structure fields
	m_pRASAddress->value = rvalue;

	// Add actual RAS port to RAS address
	switch (m_pRASAddress->value.choice)
	{
	case ipAddress_chosen:
		m_pRASAddress->value.u.ipAddress.port = usPort;
		break;
	case ipxAddress_chosen:
		m_pRASAddress->value.u.ipxAddress.port.value[0] = HIBYTE(usPort);
		m_pRASAddress->value.u.ipxAddress.port.value[1] = LOBYTE(usPort);
		break;
	}
	return (GKI_OK);
}

HRESULT
CRegistration::AddAliasAddr(AliasAddress& rvalue)
{
	// ABSTRACT:  This procedure is called to add an alias address
	//            to the link list of alias addresses.  This will
	//            be called for each alias on receiving a GKI_RegistrationRequest.
	//            A local copy is made to avoid reliance on the client
	//            keeping the memory valid.
	//            In the eventuality that the gatekeeper assigns alias
	//            addresses, this procedure will be called for each alias
	//            contained in the registrationConfirm message.
	//            This procedure returns 0 if successful and non-zero
	//            for a failure.
	// AUTHOR:    Colin Hulme

	SeqAliasAddr	*p1;
	unsigned short	uIdx;
	unsigned short	*pus;
#ifdef _DEBUG
	char			szGKDebug[80];
#endif

	SPIDER_TRACE(SP_FUNC, "CRegistration::AddAliasAddr(%X)\n", rvalue.choice);

	if (m_pRgstrtnRqst_trmnlAls == 0)	// First one in the list
	{
		m_pRgstrtnRqst_trmnlAls = new SeqAliasAddr;
		SPIDER_TRACE(SP_NEWDEL, "new m_pRgstrtnRqst_trmnlAls = %X\n", m_pRgstrtnRqst_trmnlAls);
		if (m_pRgstrtnRqst_trmnlAls == 0)
			return (GKI_NO_MEMORY);
		memset(m_pRgstrtnRqst_trmnlAls, 0, sizeof(SeqAliasAddr));
		p1 = m_pRgstrtnRqst_trmnlAls;
	}
	else
	{
		for (p1 = m_pRgstrtnRqst_trmnlAls; p1->next != 0; p1 = p1->next)
			;						// walk the list til last entry
		p1->next = new SeqAliasAddr;
		SPIDER_TRACE(SP_NEWDEL, "new p1->next = %X\n", p1->next);
		if (p1->next == 0)
			return (GKI_NO_MEMORY);
		memset(p1->next, 0, sizeof(SeqAliasAddr));
		p1 = p1->next;
	}
	p1->next = 0;					// initialize new structure fields
	p1->value = rvalue;
	if (p1->value.choice == h323_ID_chosen)
	{
		pus = new unsigned short[p1->value.u.h323_ID.length];
		SPIDER_TRACE(SP_NEWDEL, "new pus = %X\n", pus);
		if (pus == 0)
			return (GKI_NO_MEMORY);
		memset(pus, 0, sizeof(unsigned short) * p1->value.u.h323_ID.length);
		for (uIdx = 0; uIdx < p1->value.u.h323_ID.length; uIdx++)
			*(pus + uIdx) = *(p1->value.u.h323_ID.value + uIdx);
		p1->value.u.h323_ID.value = pus;
	}
	return (GKI_OK);
}

HRESULT
CRegistration::AddLocationInfo(AliasAddress& rvalue)
{
	// ABSTRACT:  This procedure is called to add an alias address
	//            to the link list of alias addresses.  This will
	//            be called for each alias on receiving a GKI_RegistrationRequest.
	//            A local copy is made to avoid reliance on the client
	//            keeping the memory valid.
	//            In the eventuality that the gatekeeper assigns alias
	//            addresses, this procedure will be called for each alias
	//            contained in the registrationConfirm message.
	//            This procedure returns 0 if successful and non-zero
	//            for a failure.
	// AUTHOR:    Colin Hulme

	SeqAliasAddr	*p1;
	unsigned short	uIdx;
	unsigned short	*pus;
#ifdef _DEBUG
	char			szGKDebug[80];
#endif

	SPIDER_TRACE(SP_FUNC, "CRegistration::AddLocationInfo(%X)\n", rvalue.choice);

	if (m_pLocationInfo == 0)	// First one in the list
	{
		m_pLocationInfo = new SeqAliasAddr;
		SPIDER_TRACE(SP_NEWDEL, "new m_pLocationInfo = %X\n", m_pLocationInfo);
		if (m_pLocationInfo == 0)
			return (GKI_NO_MEMORY);
		memset(m_pLocationInfo, 0, sizeof(SeqAliasAddr));
		p1 = m_pLocationInfo;
	}
	else
	{
		for (p1 = m_pLocationInfo; p1->next != 0; p1 = p1->next)
			;						// walk the list til last entry
		p1->next = new SeqAliasAddr;
		SPIDER_TRACE(SP_NEWDEL, "new p1->next = %X\n", p1->next);
		if (p1->next == 0)
			return (GKI_NO_MEMORY);
		memset(p1->next, 0, sizeof(SeqAliasAddr));
		p1 = p1->next;
	}
	p1->next = 0;					// initialize new structure fields
	p1->value = rvalue;
	if (p1->value.choice == h323_ID_chosen)
	{
		pus = new unsigned short[p1->value.u.h323_ID.length];
		SPIDER_TRACE(SP_NEWDEL, "new pus = %X\n", pus);
		if (pus == 0)
			return (GKI_NO_MEMORY);
		memset(pus, 0, sizeof(unsigned short) * p1->value.u.h323_ID.length);
		for (uIdx = 0; uIdx < p1->value.u.h323_ID.length; uIdx++)
			*(pus + uIdx) = *(p1->value.u.h323_ID.value + uIdx);
		p1->value.u.h323_ID.value = pus;
	}
	return (GKI_OK);
}

TransportAddress *
CRegistration::GetTransportAddress(unsigned short usCallTransport)
{
	SeqTransportAddr			*pCSA;

	for (pCSA = m_pCallSignalAddress; pCSA != 0; pCSA = pCSA->next)
	{
		if (pCSA->value.choice == usCallTransport)
			return (&pCSA->value);
	}
	return (NULL);	// Didn't find it
}

HRESULT
CRegistration::RegistrationRequest(BOOL fDiscovery)
{
	// ABSTRACT:  This procedure will create a RegistrationRequest structure
	//            call the encoder and send the PDU.  If it is successful, it
	//            will return 0, else it will return an error code.  Note:  The
	//            memory allocated for the RAS Message is not freed until either
	//            a response from the gatekeeper or it times out.  This allows
	//            for retransmission without having to rebuild this message.
	// AUTHOR:    Colin Hulme

	ASN1_BUF		Asn1Buf;
	DWORD			dwErrorCode;
#ifdef _DEBUG
	char			szGKDebug[80];
#endif

	SPIDER_TRACE(SP_FUNC, "CRegistration::RegistrationRequest()\n", 0);
	ASSERT(g_pCoder);
	if (g_pCoder == NULL)
		return (GKI_NOT_INITIALIZED);	

	// Allocate a RasMessage structure and initialized to 0
	m_usRetryCount = 0;
	m_uRetryCountdown = m_uRetryResetCount;
	
	m_pRasMessage = new RasMessage;
	SPIDER_TRACE(SP_NEWDEL, "new m_pRasMessage = %X\n", m_pRasMessage);
	if (m_pRasMessage == 0)
		return (GKI_NO_MEMORY);
	memset(m_pRasMessage, 0, sizeof(RasMessage));

	// Setup structure fields for RegistrationRequest
	m_pRasMessage->choice = registrationRequest_chosen;
	if (m_pRgstrtnRqst_trmnlAls != 0)
		m_pRasMessage->u.registrationRequest.bit_mask |= RgstrtnRqst_trmnlAls_present;
	if (m_RCm_gtkprIdntfr.length != 0)
		m_pRasMessage->u.registrationRequest.bit_mask |= RgstrtnRqst_gtkprIdntfr_present;

	m_pRasMessage->u.registrationRequest.requestSeqNum = ++m_requestSeqNum;

	// discoveryComplete is a ASN1_BOOL (char) and fDiscovery is a BOOL (int) so the
	// cast was added to remove a compiler warning.  Since the value of fDiscovery
	// is always 0 or 1, no loss occurs in the cast. -- DLD
	m_pRasMessage->u.registrationRequest.discoveryComplete = (ASN1_BOOL)fDiscovery;
	m_pRasMessage->u.registrationRequest.callSignalAddress = (PRegistrationRequest_callSignalAddress)m_pCallSignalAddress;
	m_pRasMessage->u.registrationRequest.rasAddress = (PRegistrationRequest_rasAddress)m_pRASAddress;
	m_pRasMessage->u.registrationRequest.terminalType = m_terminalType;
	m_pRasMessage->u.registrationRequest.RgstrtnRqst_trmnlAls = (PRegistrationRequest_terminalAlias)m_pRgstrtnRqst_trmnlAls;
	m_pRasMessage->u.registrationRequest.RgstrtnRqst_gtkprIdntfr = m_RCm_gtkprIdntfr;
	m_pRasMessage->u.registrationRequest.endpointVendor.bit_mask = 0;

	if(m_pVendorInfo)
	{
		m_pRasMessage->u.registrationRequest.endpointVendor.vendor.t35CountryCode
			= m_pVendorInfo->bCountryCode;

		m_pRasMessage->u.registrationRequest.endpointVendor.vendor.t35Extension
			= m_pVendorInfo->bExtension;
		m_pRasMessage->u.registrationRequest.endpointVendor.vendor.manufacturerCode
			= m_pVendorInfo->wManufacturerCode;

		if(m_pVendorInfo->pProductNumber
			&& m_pVendorInfo->pProductNumber->pOctetString
			&& m_pVendorInfo->pProductNumber->wOctetStringLength)
		{
			UINT uSize = min(m_pVendorInfo->pProductNumber->wOctetStringLength,
				  	sizeof(m_pRasMessage->u.registrationRequest.endpointVendor.productId.value));
					
			m_pRasMessage->u.registrationRequest.endpointVendor.bit_mask |= productId_present;
			// truncate to fit size of registrationRequest.endpointVendor.productId.value
			m_pRasMessage->u.registrationRequest.endpointVendor.productId.length = uSize;
			memcpy(&m_pRasMessage->u.registrationRequest.endpointVendor.productId.value,
				m_pVendorInfo->pProductNumber->pOctetString, uSize);
		}

		if(m_pVendorInfo->pVersionNumber
			&& m_pVendorInfo->pVersionNumber->pOctetString
			&& m_pVendorInfo->pVersionNumber->wOctetStringLength)
		{
			UINT uSize = min(m_pVendorInfo->pVersionNumber->wOctetStringLength,
				  	sizeof(m_pRasMessage->u.registrationRequest.endpointVendor.versionId.value));
			m_pRasMessage->u.registrationRequest.endpointVendor.bit_mask |= versionId_present;
			// truncate to fit size of registrationRequest.endpointVendor.versionId.value
			m_pRasMessage->u.registrationRequest.endpointVendor.versionId.length = uSize;
			memcpy(&m_pRasMessage->u.registrationRequest.endpointVendor.versionId.value,
				m_pVendorInfo->pVersionNumber->pOctetString, uSize);
		}
	}		
#ifdef _DEBUG
	if (dwGKIDLLFlags & SP_DUMPMEM)
		DumpMem(m_pRasMessage, sizeof(RasMessage));
#endif

	// Assign ProtocolIdentifier
	g_pCoder->SetProtocolIdentifier(*m_pRasMessage);

	// Encode the PDU & send it
	dwErrorCode = g_pCoder->Encode(m_pRasMessage, &Asn1Buf);
	if (dwErrorCode)
		return (GKI_ENCODER_ERROR);

	// Create a backup copy of the encoded PDU if using debug echo support
	if (fGKIEcho)
	{
		pEchoBuff = new char[Asn1Buf.length];
		SPIDER_TRACE(SP_NEWDEL, "new pEchoBuff = %X\n", pEchoBuff);
		if (pEchoBuff == 0)
			return (GKI_NO_MEMORY);
		memcpy(pEchoBuff, (char *)Asn1Buf.value, Asn1Buf.length);
		nEchoLen = Asn1Buf.length;
	}

	SPIDER_TRACE(SP_PDU, "Send RRQ; g_pReg = %X\n", this);
	if (fGKIDontSend == FALSE)
		if (m_pSocket->Send((char *)Asn1Buf.value, Asn1Buf.length) == SOCKET_ERROR)
			return (GKI_WINSOCK2_ERROR(SOCKET_ERROR));

	// Free the encoder memory
	g_pCoder->Free(Asn1Buf);

	return (GKI_OK);
}

HRESULT
CRegistration::UnregistrationRequest(void)
{
	// ABSTRACT:  This procedure will create an UnregistrationRequest structure
	//            call the encoder and send the PDU.  If it is successful, it
	//            will return 0, else it will return an error code.
	// AUTHOR:    Colin Hulme

	ASN1_BUF		Asn1Buf;
	DWORD			dwErrorCode;
#ifdef _DEBUG
	char			szGKDebug[80];
#endif

	SPIDER_TRACE(SP_FUNC, "CRegistration::UnregistrationRequest()\n", 0);
	ASSERT(g_pCoder);
	if (g_pCoder == NULL)
		return (GKI_NOT_INITIALIZED);	
		
	// Allocate a RasMessage structure and initialized to 0
	m_usRetryCount = 0;
	m_uRetryCountdown = m_uRetryResetCount;
	
	m_pRasMessage = new RasMessage;
	SPIDER_TRACE(SP_NEWDEL, "new m_pRasMessage = %X\n", m_pRasMessage);
	if (m_pRasMessage == 0)
		return (GKI_NO_MEMORY);
	memset(m_pRasMessage, 0, sizeof(RasMessage));

	// Setup structure fields for UnregistrationRequest
	m_pRasMessage->choice = unregistrationRequest_chosen;
	if (m_pRgstrtnRqst_trmnlAls != 0)
		m_pRasMessage->u.unregistrationRequest.bit_mask |= UnrgstrtnRqst_endpntAls_present;
	if (m_endpointID.length != 0)
		m_pRasMessage->u.unregistrationRequest.bit_mask |= URt_endpntIdntfr_present;
	
	m_pRasMessage->u.unregistrationRequest.requestSeqNum = ++m_requestSeqNum;
	m_pRasMessage->u.unregistrationRequest.callSignalAddress = (PUnregistrationRequest_callSignalAddress)m_pCallSignalAddress;
	m_pRasMessage->u.unregistrationRequest.UnrgstrtnRqst_endpntAls = (PUnregistrationRequest_endpointAlias)m_pRgstrtnRqst_trmnlAls;
	m_pRasMessage->u.unregistrationRequest.URt_endpntIdntfr = m_endpointID;
#ifdef _DEBUG
	if (dwGKIDLLFlags & SP_DUMPMEM)
		DumpMem(m_pRasMessage, sizeof(RasMessage));
#endif

	// Encode the PDU & send it
	dwErrorCode = g_pCoder->Encode(m_pRasMessage, &Asn1Buf);
	if (dwErrorCode)
		return (GKI_ENCODER_ERROR);

	// Create a backup copy of the encoded PDU if using debug echo support
	if (fGKIEcho)
	{
		pEchoBuff = new char[Asn1Buf.length];
		SPIDER_TRACE(SP_NEWDEL, "new pEchoBuff = %X\n", pEchoBuff);
		if (pEchoBuff == 0)
			return (GKI_NO_MEMORY);
		memcpy(pEchoBuff, (char *)Asn1Buf.value, Asn1Buf.length);
		nEchoLen = Asn1Buf.length;
	}

	m_State = GK_UNREG_PENDING;
	SPIDER_TRACE(SP_STATE, "m_State = GK_UNREG_PENDING (%X)\n", this);

	SPIDER_TRACE(SP_PDU, "Send URQ; g_pReg = %X\n", this);
	if (fGKIDontSend == FALSE)
		if (m_pSocket->Send((char *)Asn1Buf.value, Asn1Buf.length) == SOCKET_ERROR)
			return (GKI_WINSOCK2_ERROR(SOCKET_ERROR));

	// Free the encoder memory
	g_pCoder->Free(Asn1Buf);

	return (GKI_OK);
}

HRESULT
CRegistration::LocationRequest(void)
{
	// ABSTRACT:  This procedure will create a LocationRequest structure
	//            call the encoder and send the PDU.  If it is successful, it
	//            will return 0, else it will return an error code.  Note:  The
	//            memory allocated for the RAS Message is not freed until either
	//            a response from the gatekeeper or it times out.  This allows
	//            for retransmission without having to rebuild this message.
	// AUTHOR:    Colin Hulme

	ASN1_BUF		Asn1Buf;
	DWORD			dwErrorCode;
#ifdef _DEBUG
	char			szGKDebug[80];
#endif

	SPIDER_TRACE(SP_FUNC, "CRegistration::LocationRequest()\n", 0);
	ASSERT(g_pCoder);
	if (g_pCoder == NULL)
		return (GKI_NOT_INITIALIZED);	
		
	// Allocate a RasMessage structure and initialized to 0
	m_usRetryCount = 0;
	m_uRetryCountdown = m_uRetryResetCount;
	
	m_pRasMessage = new RasMessage;
	SPIDER_TRACE(SP_NEWDEL, "new m_pRasMessage = %X\n", m_pRasMessage);
	if (m_pRasMessage == 0)
		return (GKI_NO_MEMORY);
	memset(m_pRasMessage, 0, sizeof(RasMessage));

	// Setup structure fields for LocationRequest
	m_pRasMessage->choice = locationRequest_chosen;
	if (m_endpointID.length != 0)
		m_pRasMessage->u.locationRequest.bit_mask |= LctnRqst_endpntIdntfr_present;
	
	m_pRasMessage->u.locationRequest.requestSeqNum = ++m_requestSeqNum;

	m_pRasMessage->u.locationRequest.LctnRqst_endpntIdntfr = m_endpointID;
	m_pRasMessage->u.locationRequest.destinationInfo =
			(PLocationRequest_destinationInfo)m_pLocationInfo;
	m_pRasMessage->u.locationRequest.replyAddress = m_pRASAddress->value;

#ifdef _DEBUG
	if (dwGKIDLLFlags & SP_DUMPMEM)
		DumpMem(m_pRasMessage, sizeof(RasMessage));
#endif

	// Encode the PDU & send it
	dwErrorCode = g_pCoder->Encode(m_pRasMessage, &Asn1Buf);
	if (dwErrorCode)
		return (GKI_ENCODER_ERROR);

	// Create a backup copy of the encoded PDU if using debug echo support
	if (fGKIEcho)
	{
		pEchoBuff = new char[Asn1Buf.length];
		SPIDER_TRACE(SP_NEWDEL, "new pEchoBuff = %X\n", pEchoBuff);
		if (pEchoBuff == 0)
			return (GKI_NO_MEMORY);
		memcpy(pEchoBuff, (char *)Asn1Buf.value, Asn1Buf.length);
		nEchoLen = Asn1Buf.length;
	}

	m_State = GK_LOC_PENDING;
	SPIDER_TRACE(SP_STATE, "m_State = GK_LOC_PENDING (%X)\n", this);

	SPIDER_TRACE(SP_PDU, "Send LRQ; g_pReg = %X\n", this);
	if (fGKIDontSend == FALSE)
		if (m_pSocket->Send((char *)Asn1Buf.value, Asn1Buf.length) == SOCKET_ERROR)
			return (GKI_WINSOCK2_ERROR(SOCKET_ERROR));

	// Free the encoder memory
	g_pCoder->Free(Asn1Buf);

	return (GKI_OK);
}

HRESULT
CRegistration::GatekeeperRequest(void)
{
	// ABSTRACT:  This procedure will create a GatekeeperRequest structure
	//            call the encoder and send the PDU.  If it is successful, it
	//            will return 0, else it will return an error code.
	// AUTHOR:    Colin Hulme

	ASN1_BUF		Asn1Buf;
	DWORD			dwErrorCode;
#ifdef _DEBUG
	char			szGKDebug[80];
#endif

	SPIDER_TRACE(SP_FUNC, "CRegistration::GatekeeperRequest()\n", 0);
	ASSERT(g_pCoder);
	if (g_pCoder == NULL)
		return (GKI_NOT_INITIALIZED);	
		
	// Allocate a RasMessage structure and initialized to 0
	m_usRetryCount = 0;
	m_uRetryCountdown = m_uRetryResetCount;
	
	m_pRasMessage = new RasMessage;
	SPIDER_TRACE(SP_NEWDEL, "new m_pRasMessage = %X\n", m_pRasMessage);
	if (m_pRasMessage == 0)
		return (GKI_NO_MEMORY);
	memset(m_pRasMessage, 0, sizeof(RasMessage));

	// Setup structure fields for GatekeeperRequest
	m_pRasMessage->choice = gatekeeperRequest_chosen;
	if (m_pRgstrtnRqst_trmnlAls != 0)
		m_pRasMessage->u.gatekeeperRequest.bit_mask |= GtkprRqst_endpointAlias_present;
	
	m_pRasMessage->u.gatekeeperRequest.requestSeqNum = ++m_requestSeqNum;

	m_pRasMessage->u.gatekeeperRequest.rasAddress = m_pRASAddress->value;
	m_pRasMessage->u.gatekeeperRequest.endpointType = m_terminalType;
	m_pRasMessage->u.gatekeeperRequest.GtkprRqst_endpointAlias = (PGatekeeperRequest_endpointAlias)m_pRgstrtnRqst_trmnlAls;

	// Assign ProtocolIdentifier
	g_pCoder->SetProtocolIdentifier(*m_pRasMessage);

	// Encode the PDU & send it
	dwErrorCode = g_pCoder->Encode(m_pRasMessage, &Asn1Buf);
	if (dwErrorCode)
		return (GKI_ENCODER_ERROR);

	// Create a backup copy of the encoded PDU if using debug echo support
	if (fGKIEcho)
	{
		pEchoBuff = new char[Asn1Buf.length];
		SPIDER_TRACE(SP_NEWDEL, "new pEchoBuff = %X\n", pEchoBuff);
		if (pEchoBuff == 0)
			return (GKI_NO_MEMORY);
		memcpy(pEchoBuff, (char *)Asn1Buf.value, Asn1Buf.length);
		nEchoLen = Asn1Buf.length;
	}

	SPIDER_TRACE(SP_PDU, "Send GRQ; g_pReg = %X\n", this);
	if (fGKIDontSend == FALSE)
	{
		if (m_pSocket->SendBroadcast((char *)Asn1Buf.value, Asn1Buf.length) == SOCKET_ERROR)
		{
			g_pCoder->Free(Asn1Buf);
			return (GKI_WINSOCK2_ERROR(SOCKET_ERROR));
		}
	}

	// Free the encoder memory
	g_pCoder->Free(Asn1Buf);

	return (GKI_OK);
}

HRESULT
CRegistration::PDUHandler(RasMessage *pRasMessage)
{
	// ABSTRACT:  This procedure will interpret the received PDU and dispatch
	//            to the appropriate handler.
	// AUTHOR:    Colin Hulme

#ifdef _DEBUG
	char			szGKDebug[80];
#endif
	HRESULT			hResult = GKI_OK;

	SPIDER_TRACE(SP_FUNC, "CRegistration::PDUHandler(%X)\n", pRasMessage);
	ASSERT(g_pCoder);
	if (g_pCoder == NULL)
		return (GKI_NOT_INITIALIZED);	
		
	switch (pRasMessage->choice)
	{
	// Incoming response PDUs
	case gatekeeperConfirm_chosen:
		SPIDER_TRACE(SP_PDU, "Rcv GCF; g_pReg = %X\n", this);
		break;
	case gatekeeperReject_chosen:
		SPIDER_TRACE(SP_PDU, "Rcv GRJ; g_pReg = %X\n", this);
		break;
	case registrationConfirm_chosen:
		SPIDER_TRACE(SP_PDU, "Rcv RCF; g_pReg = %X\n", this);
		if ((m_State == GK_REG_PENDING) &&
				(pRasMessage->u.registrationConfirm.requestSeqNum ==
				m_pRasMessage->u.registrationRequest.requestSeqNum))
			hResult = RegistrationConfirm(pRasMessage);
		else
			hResult = UnknownMessage(pRasMessage);
		break;
	case registrationReject_chosen:
		SPIDER_TRACE(SP_PDU, "Rcv RRJ; g_pReg = %X\n", this);
		if ((m_State == GK_REG_PENDING) &&
				(pRasMessage->u.registrationReject.requestSeqNum ==
				m_pRasMessage->u.registrationRequest.requestSeqNum))
			hResult = RegistrationReject(pRasMessage);
		else
			hResult = UnknownMessage(pRasMessage);
		break;
	case unregistrationConfirm_chosen:
		SPIDER_TRACE(SP_PDU, "Rcv UCF; g_pReg = %X\n", this);
		if ((m_State == GK_UNREG_PENDING) &&
				(pRasMessage->u.unregistrationConfirm.requestSeqNum ==
				m_pRasMessage->u.unregistrationRequest.requestSeqNum))
			hResult = UnregistrationConfirm(pRasMessage);
		else
			hResult = UnknownMessage(pRasMessage);
		break;
	case unregistrationReject_chosen:
		SPIDER_TRACE(SP_PDU, "Rcv URJ; g_pReg = %X\n", this);
		if ((m_State == GK_UNREG_PENDING) &&
				(pRasMessage->u.unregistrationReject.requestSeqNum ==
				m_pRasMessage->u.unregistrationRequest.requestSeqNum))
			hResult = UnregistrationReject(pRasMessage);
		else
			hResult = UnknownMessage(pRasMessage);
		break;
	case admissionConfirm_chosen:
		{
			// The sequence number of this RAS message seems to be the
			// only thing we can link back to the ARQ so we use it
			// to look up the call that this ACF is associated with
			RequestSeqNum	seqNum = pRasMessage->u.admissionConfirm.requestSeqNum;
			CCall			*pCall = FindCallBySeqNum(seqNum);
			if ((m_State == GK_REGISTERED) && (pCall))
			{
				SPIDER_TRACE(SP_PDU, "Rcv ACF; pCall = %X\n", pCall);
				hResult = pCall->AdmissionConfirm(pRasMessage);
			}
			else
			{
				SPIDER_TRACE(SP_PDU, "Rcv ACF; g_pReg = %X\n", this);
				hResult = UnknownMessage(pRasMessage);
			}
		}
		break;
	case admissionReject_chosen:
		{
			// The sequence number of this RAS message seems to be the
			// only thing we can link back to the ARQ so we use it
			// to look up the call that this ARJ is associated with
			RequestSeqNum	seqNum = pRasMessage->u.admissionReject.requestSeqNum;
			CCall			*pCall = FindCallBySeqNum(seqNum);
			if ((m_State == GK_REGISTERED) && (pCall))
			{
				SPIDER_TRACE(SP_PDU, "Rcv ARJ; pCall = %X\n", pCall);
				hResult = pCall->AdmissionReject(pRasMessage);
				if (hResult == GKI_DELETE_CALL)
				{
					DeleteCall(pCall);
					hResult = GKI_OK;	// Don't want to exit PostReceive loop
				}
			}
			else
			{
				SPIDER_TRACE(SP_PDU, "Rcv ARJ; g_pReg = %X\n", this);
				hResult = UnknownMessage(pRasMessage);
			}
		}
		break;
	case bandwidthConfirm_chosen:
		{
			// The sequence number of this RAS message seems to be the
			// only thing we can link back to the BRQ so we use it
			// to look up the call that this BCF is associated with
			RequestSeqNum	seqNum = pRasMessage->u.bandwidthConfirm.requestSeqNum;
			CCall			*pCall = FindCallBySeqNum(seqNum);
			if ((m_State == GK_REGISTERED) && (pCall))
			{
				SPIDER_TRACE(SP_PDU, "Rcv BCF; pCall = %X\n", pCall);
				hResult = pCall->BandwidthConfirm(pRasMessage);
			}
			else
			{
				SPIDER_TRACE(SP_PDU, "Rcv BCF; g_pReg = %X\n", this);
				hResult = UnknownMessage(pRasMessage);
			}
		}
		break;
	case bandwidthReject_chosen:
		{
			// The sequence number of this RAS message seems to be the
			// only thing we can link back to the BRQ so we use it
			// to look up the call that this BCF is associated with
			RequestSeqNum	seqNum = pRasMessage->u.bandwidthReject.requestSeqNum;
			CCall			*pCall = FindCallBySeqNum(seqNum);
			if ((m_State == GK_REGISTERED) && (pCall))
			{
				SPIDER_TRACE(SP_PDU, "Rcv BRJ; pCall = %X\n", pCall);
				hResult = pCall->BandwidthReject(pRasMessage);
			}
			else
			{
				SPIDER_TRACE(SP_PDU, "Rcv BRJ; g_pReg = %X\n", this);
				hResult = UnknownMessage(pRasMessage);
			}
		}
		break;
	case disengageConfirm_chosen:
		{
			// The sequence number of this RAS message seems to be the
			// only thing we can link back to the DRQ so we use it
			// to look up the call that this DCF is associated with
			RequestSeqNum	seqNum = pRasMessage->u.disengageConfirm.requestSeqNum;
			CCall			*pCall = FindCallBySeqNum(seqNum);
			if ((m_State == GK_REGISTERED) && (pCall))
			{
				SPIDER_TRACE(SP_PDU, "Rcv DCF; pCall = %X\n", pCall);
				hResult = pCall->DisengageConfirm(pRasMessage);
				if (hResult == GKI_DELETE_CALL)
				{
					DeleteCall(pCall);
					hResult = GKI_OK;	// Don't want to exit PostReceive loop
				}
			}
			else
			{
				SPIDER_TRACE(SP_PDU, "Rcv DCF; g_pReg = %X\n", this);
				hResult = UnknownMessage(pRasMessage);
			}
		}
		break;
	case disengageReject_chosen:
		{
			// The sequence number of this RAS message seems to be the
			// only thing we can link back to the DRQ so we use it
			// to look up the call that this DRJ is associated with
			RequestSeqNum	seqNum = pRasMessage->u.disengageReject.requestSeqNum;
			CCall			*pCall = FindCallBySeqNum(seqNum);
			if ((m_State == GK_REGISTERED) && (pCall))
			{
				SPIDER_TRACE(SP_PDU, "Rcv DRJ; pCall = %X\n", pCall);
				hResult = pCall->DisengageReject(pRasMessage);
				if (hResult == GKI_DELETE_CALL)
				{
					DeleteCall(pCall);
					hResult = GKI_OK;	// Don't want to exit PostReceive loop
				}
			}
			else
			{
				SPIDER_TRACE(SP_PDU, "Rcv DRJ; g_pReg = %X\n", this);
				hResult = UnknownMessage(pRasMessage);
			}
		}
		break;
	case locationConfirm_chosen:
		SPIDER_TRACE(SP_PDU, "Rcv LCF; g_pReg = %X\n", this);
		if ((m_State == GK_LOC_PENDING) &&
				(pRasMessage->u.locationConfirm.requestSeqNum ==
				m_pRasMessage->u.locationRequest.requestSeqNum))
			hResult = LocationConfirm(pRasMessage);
		else
			hResult = UnknownMessage(pRasMessage);
		break;
	case locationReject_chosen:
		SPIDER_TRACE(SP_PDU, "Rcv LRJ; g_pReg = %X\n", this);
		if ((m_State == GK_LOC_PENDING) &&
				(pRasMessage->u.locationReject.requestSeqNum ==
				m_pRasMessage->u.locationRequest.requestSeqNum))
			hResult = LocationReject(pRasMessage);
		else
			hResult = UnknownMessage(pRasMessage);
		break;

	case nonStandardMessage_chosen:
		SPIDER_TRACE(SP_PDU, "Rcv NSM; g_pReg = %X\n", this);
		hResult = UnknownMessage(pRasMessage);
		break;
	case unknownMessageResponse_chosen:
		SPIDER_TRACE(SP_PDU, "Rcv XRS; g_pReg = %X\n", this);
		break;

	// Incoming Request PDUs
	case unregistrationRequest_chosen:
		SPIDER_TRACE(SP_PDU, "Rcv URQ; g_pReg = %X\n", this);
		if (m_State == GK_REGISTERED)
		{
			WORD wReason;
			// Notify user of received unregistration request and reason
			if(pRasMessage->u.unregistrationRequest.bit_mask
				& UnregistrationRequest_reason_present)
 			{
 				wReason = pRasMessage->u.unregistrationRequest.reason.choice;
			}
			else
				wReason = 0;
			SPIDER_TRACE(SP_GKI, "PostMessage(m_hWnd, m_wBaseMessage + GKI_UNREG_REQUEST, 0, 0)\n", 0);
			PostMessage(m_hWnd, m_wBaseMessage + GKI_UNREG_REQUEST, wReason, 0);
		
			hResult = SendUnregistrationConfirm(pRasMessage);
			if (hResult == GKI_OK)
				hResult = GKI_EXIT_THREAD;
		}
		else
			hResult = UnknownMessage(pRasMessage);
		break;
	case bandwidthRequest_chosen:
		{
			// Check the CRV in this BRQ and see if we have a call
			// that corresponds to it.
			CallReferenceValue	crv = pRasMessage->u.bandwidthRequest.callReferenceValue;
			CCall			*pCall = FindCallByCRV(crv);
			if ((m_State == GK_REGISTERED) && (pCall))
			{
				SPIDER_TRACE(SP_PDU, "Rcv BRQ; pCall = %X\n", pCall);
				hResult = pCall->SendBandwidthConfirm(pRasMessage);
			}
			else
			{
				SPIDER_TRACE(SP_PDU, "Rcv BRQ; g_pReg = %X\n", this);
				hResult = UnknownMessage(pRasMessage);
			}
		}
		break;
	case disengageRequest_chosen:
		{
			// Check the CRV in this DRQ and see if we have a call
			// that corresponds to it.
			CallReferenceValue	crv = pRasMessage->u.disengageRequest.callReferenceValue;
			CCall			*pCall = FindCallByCRV(crv);
			if ((m_State == GK_REGISTERED) && (pCall))
			{
				SPIDER_TRACE(SP_PDU, "Rcv DRQ; pCall = %X\n", pCall);
				hResult = pCall->SendDisengageConfirm(pRasMessage);
				if (hResult == GKI_DELETE_CALL)
				{
					DeleteCall(pCall);
					hResult = GKI_OK;	// Don't want to exit PostReceive loop
				}
			}
			else
			{
				SPIDER_TRACE(SP_PDU, "Rcv DRQ; g_pReg = %X\n", this);
				hResult = UnknownMessage(pRasMessage);
			}
		}
		break;
	case infoRequest_chosen:
		SPIDER_TRACE(SP_PDU, "Rcv IRQ; g_pReg = %X\n", this);
		if ((m_State != GK_UNREGISTERED) && (m_State != GK_REG_PENDING))
		{
			// Check the CRV in this DRQ and see if we have a call
			// that corresponds to it.
			CallReferenceValue	crv = pRasMessage->u.infoRequest.callReferenceValue;
			CCall			*pCall = NULL;
			// A zero in the CRV means provide info for all calls, so we start
			// the chain with the first one.
			if (crv == 0)
			{
				if (m_Calls.IsEmpty())
					hResult = SendInfoRequestResponse(0, pRasMessage);
				else
				{
					POS	pos = m_Calls.GetFirstPos();
					pCall = m_Calls.GetAt(pos);
					hResult = pCall->SendInfoRequestResponse(0, pRasMessage, FALSE);
				}
			}
			else
			{
				// This is a call specific request so if we don't find
				// a matching call, we'll send an XRS
				pCall = FindCallByCRV(crv);
				if (pCall)
					hResult = pCall->SendInfoRequestResponse(0, pRasMessage, TRUE);
				else
					hResult = UnknownMessage(pRasMessage);
			}
		}
		break;

	// Should never see these PDUs
	case gatekeeperRequest_chosen:
	case registrationRequest_chosen:
	case admissionRequest_chosen:
	case locationRequest_chosen:
	case infoRequestResponse_chosen:
		SPIDER_TRACE(SP_PDU, "Rcv unexpected PDU; g_pReg = %X\n", this);
		SPIDER_TRACE(SP_PDU, "pRasMessage->choice = %X\n", pRasMessage->choice);
		hResult = UnknownMessage(pRasMessage);
		break;

	// Everything else - probably a bad PDU
	default:
		SPIDER_TRACE(SP_PDU, "Rcv unrecognized PDU; g_pReg = %X\n", this);
		SPIDER_TRACE(SP_PDU, "pRasMessage->choice = %X\n", pRasMessage->choice);
		hResult = UnknownMessage(pRasMessage);
		break;
	}

	return (hResult);
}

HRESULT
CRegistration::RegistrationConfirm(RasMessage *pRasMessage)
{
	// ABSTRACT:  This function is called if a registrationConfirm is
	//            received and matches an outstanding registrationRequest.
	//            It will delete the memory used for the registrationRequest
	//            change the state and notify the user by posting a message.
	//            Additional information contained in the registrationConfirm
	//            is stored in the CRegistration class.
	// AUTHOR:    Colin Hulme

	SeqAliasAddr	*pAA;
#ifdef _DEBUG
	char			szGKDebug[80];
#endif

	SPIDER_TRACE(SP_FUNC, "CRegistration::RegistrationConfirm(%X)\n", pRasMessage);
	ASSERT(g_pCoder);
	if (g_pCoder == NULL)
		return (GKI_NOT_INITIALIZED);	
		
	// Delete allocated RasMessage storage
	SPIDER_TRACE(SP_NEWDEL, "del m_pRasMessage = %X\n", m_pRasMessage);
	delete m_pRasMessage;
	m_pRasMessage = 0;

	// Update member variables
	m_State = GK_REGISTERED;
	SPIDER_TRACE(SP_STATE, "m_State = GK_REGISTERED (%X)\n", this);

	if (pRasMessage->u.registrationConfirm.bit_mask & RgstrtnCnfrm_trmnlAls_present)
	{
		// Copy alias addresses
		for (pAA = (SeqAliasAddr *)pRasMessage->u.registrationConfirm.RgstrtnCnfrm_trmnlAls;
				pAA != 0; pAA = pAA->next)
			AddAliasAddr(pAA->value);
	}
	if ((pRasMessage->u.registrationConfirm.bit_mask & RCm_gtkprIdntfr_present) &&
			(m_RCm_gtkprIdntfr.value == 0))
	{
		// Copy gatekeeper identifier
		m_RCm_gtkprIdntfr.length = pRasMessage->u.registrationConfirm.RCm_gtkprIdntfr.length;
		m_RCm_gtkprIdntfr.value = new unsigned short[m_RCm_gtkprIdntfr.length];
		SPIDER_TRACE(SP_NEWDEL, "new m_RCm_gtkprIdntfr.value = %X\n", m_RCm_gtkprIdntfr.value);
		if (m_RCm_gtkprIdntfr.value == 0)
			return (GKI_NO_MEMORY);
		memcpy(m_RCm_gtkprIdntfr.value,
				pRasMessage->u.registrationConfirm.RCm_gtkprIdntfr.value,
				m_RCm_gtkprIdntfr.length * sizeof(unsigned short));

	}
	// Copy endpoint identifier
	m_endpointID.length = pRasMessage->u.registrationConfirm.endpointIdentifier.length;
	m_endpointID.value = new unsigned short[m_endpointID.length];
	SPIDER_TRACE(SP_NEWDEL, "new m_endpointID.value = %X\n", m_endpointID.value);
	if (m_endpointID.value == 0)
		return (GKI_NO_MEMORY);
	memcpy(m_endpointID.value,
			pRasMessage->u.registrationConfirm.endpointIdentifier.value,
			m_endpointID.length * sizeof(unsigned short));


	SPIDER_TRACE(SP_GKI, "PostMessage(m_hWnd, m_wBaseMessage + GKI_REG_CONFIRM, 0, 0)\n", 0);
	PostMessage(m_hWnd, m_wBaseMessage + GKI_REG_CONFIRM, 0, 0);

	return (GKI_OK);
}

HRESULT
CRegistration::RegistrationReject(RasMessage *pRasMessage)
{
	// ABSTRACT:  This function is called if a registrationReject is
	//            received and matches an outstanding registrationRequest.
	//            It will delete the memory used for the registrationRequest
	//            change the state and notify the user by posting a message
	//            Returning a non-zero value, indicates that the PostReceive
	//            loop should terminate, delete the registration object
	//            and exit the thread.  If the rejectReason is discovery
	//            required, this function execs the discovery thread and
	//            notifies PostReceive to exit the thread without deleting
	//            the registration object and socket.
	// AUTHOR:    Colin Hulme

	HANDLE				hThread;
	SeqTransportAddr	*pTA1, *pTA2;
	int					nRet;
	HRESULT				hResult;
#ifdef _DEBUG
	char				szGKDebug[80];
#endif

	SPIDER_TRACE(SP_FUNC, "CRegistration::RegistrationReject(%X)\n", pRasMessage);
	ASSERT(g_pCoder);
	if (g_pCoder == NULL)
		return (GKI_NOT_INITIALIZED);	

#ifdef BROADCAST_DISCOVERY		
	if (pRasMessage->u.registrationReject.rejectReason.choice == discoveryRequired_chosen)
	{
		SPIDER_TRACE(SP_NEWDEL, "del m_pRasMessage = %X\n", m_pRasMessage);
		delete m_pRasMessage;
		m_pRasMessage = 0;

		// Close socket and reopen in non-connected state to allow sendto
		if ((nRet = m_pSocket->Close()) != 0)
			return (GKI_WINSOCK2_ERROR(nRet));
		if ((nRet = m_pSocket->Create(m_pSocket->GetAddrFam(), 0)) != 0)
			return (GKI_WINSOCK2_ERROR(nRet));

		// Delete allocated memory for sequence of RAS addresses
		pTA1 = m_pRASAddress;
		while (pTA1 != 0)
		{
			pTA2 = pTA1->next;
			SPIDER_TRACE(SP_NEWDEL, "del pTA1 = %X\n", pTA1);
			delete pTA1;
			pTA1 = pTA2;
		}

		// Update RAS Address in CRegistration
		for (pTA1 = m_pCallSignalAddress; pTA1 != 0; pTA1 = pTA1->next)
		{
			if (pTA1->value.choice == m_usRegistrationTransport)
				if ((hResult = AddRASAddr(pTA1->value, m_pSocket->GetPort())) != GKI_OK)
					return (hResult);
		}

		hThread = (HANDLE)_beginthread(GKDiscovery, 0, 0);
		SPIDER_TRACE(SP_THREAD, "_beginthread(GKDiscovery, 0, 0); <%X>\n", hThread);
		if (hThread == (HANDLE)-1)
			return (GKI_NO_THREAD);
		SetDiscThread(hThread);
		return (GKI_REDISCOVER);
	}
#endif // BROADCAST_DISCOVERY

	m_State = GK_UNREGISTERED;
	SPIDER_TRACE(SP_STATE, "m_State = GK_UNREGISTERED (%X)\n", this);

	SPIDER_TRACE(SP_GKI, "PostMessage(m_hWnd, m_wBaseMessage + GKI_REG_REJECT, %X, 0)\n",
									pRasMessage->u.registrationReject.rejectReason.choice);
	PostMessage(m_hWnd, m_wBaseMessage + GKI_REG_REJECT,
				(WORD)pRasMessage->u.registrationReject.rejectReason.choice, 0L);

	return (GKI_EXIT_THREAD);
}

HRESULT
CRegistration::UnregistrationConfirm(RasMessage *pRasMessage)
{
	// ABSTRACT:  This function is called if an unregistrationConfirm is
	//            received and matches an outstanding unregistrationRequest.
	//            It will delete the memory used for the unregistrationRequest
	//            change the state and notify the user by posting a message.
	//            Returning a non-zero value, indicates that the PostReceive
	//            loop should terminate, delete the registration object
	//            and exit the thread.
	// AUTHOR:    Colin Hulme

#ifdef _DEBUG
	char			szGKDebug[80];
#endif

	SPIDER_TRACE(SP_FUNC, "CRegistration::UnregistrationConfirm(%X)\n", pRasMessage);

	// We deliberately don't free the RasMessage memory.  Let the registration
	// destructor do it - this provides protection from other requests.

	// Update member variables
	m_State = GK_UNREGISTERED;
	SPIDER_TRACE(SP_STATE, "m_State = GK_UNREGISTERED (%X)\n", this);

	// Notify user application
	SPIDER_TRACE(SP_GKI, "PostMessage(m_hWnd, m_wBaseMessage + GKI_UNREG_CONFIRM, 0, 0)\n", 0);
	PostMessage(m_hWnd, m_wBaseMessage + GKI_UNREG_CONFIRM, 0, 0L);

	return (GKI_EXIT_THREAD);
}

HRESULT
CRegistration::UnregistrationReject(RasMessage *pRasMessage)
{
	// ABSTRACT:  This function is called if an unregistrationReject is
	//            received and matches an outstanding unregistrationRequest.
	//            It will delete the memory used for the unregistrationRequest
	//            change the state and notify the user by posting a message
	//            Returning a non-zero value, indicates that the PostReceive
	//            loop should terminate, delete the registration object
	//            and exit the thread.
	// AUTHOR:    Colin Hulme

#ifdef _DEBUG
	char			szGKDebug[80];
#endif
	HRESULT			hResult = GKI_OK;

	SPIDER_TRACE(SP_FUNC, "CRegistration::UnregistrationReject(%X)\n", pRasMessage);


	// Update member variables
	switch (pRasMessage->u.unregistrationReject.rejectReason.choice)
	{
	case callInProgress_chosen:		// return to registered state
		// Delete allocate RasMessage storage
		SPIDER_TRACE(SP_NEWDEL, "del m_pRasMessage = %X\n", m_pRasMessage);
		delete m_pRasMessage;
		m_pRasMessage = 0;

		m_State = GK_REGISTERED;
		SPIDER_TRACE(SP_STATE, "m_State = GK_REGISTERED (%X)\n", this);
		break;
	case notCurrentlyRegistered_chosen:
	default:
		m_State = GK_UNREGISTERED;
		SPIDER_TRACE(SP_STATE, "m_State = GK_UNREGISTERED (%X)\n", this);
		hResult = GKI_EXIT_THREAD;	// kill registration and PostReceive thread
		break;
	}

	// Notify user application
	SPIDER_TRACE(SP_GKI, "PostMessage(m_hWnd, m_wBaseMessage + GKI_UNREG_REJECT, %X, 0)\n",
									pRasMessage->u.unregistrationReject.rejectReason.choice);
	PostMessage(m_hWnd, m_wBaseMessage + GKI_UNREG_REJECT,
				(WORD)pRasMessage->u.unregistrationReject.rejectReason.choice, 0L);

	return (hResult);
}

HRESULT
CRegistration::LocationConfirm(RasMessage *pRasMessage)
{
	// ABSTRACT:  This function is called if a locationConfirm is
	//            received and matches an outstanding locationRequest.
	//            It will delete the memory used for the locationRequest
	//            change the state and notify the user by posting a message.
	// AUTHOR:    Colin Hulme

	SeqAliasAddr	*pAA1, *pAA2;
#ifdef _DEBUG
	char			szGKDebug[80];
#endif

	SPIDER_TRACE(SP_FUNC, "CRegistration::LocationConfirm(%X)\n", pRasMessage);

	// Delete allocated RasMessage storage
	SPIDER_TRACE(SP_NEWDEL, "del m_pRasMessage = %X\n", m_pRasMessage);
	delete m_pRasMessage;
	m_pRasMessage = 0;

	// Delete allocated memory for sequence of location alias addresses
	pAA1 = m_pLocationInfo;
	while (pAA1 != 0)
	{
		pAA2 = pAA1->next;
		if (pAA1->value.choice == h323_ID_chosen)
		{
			SPIDER_TRACE(SP_NEWDEL, "del pAA1->value.u.h323_ID.value = %X\n", pAA1->value.u.h323_ID.value);
			delete pAA1->value.u.h323_ID.value;
		}
		SPIDER_TRACE(SP_NEWDEL, "del pAA1 = %X\n", pAA1);
		delete pAA1;
		pAA1 = pAA2;
	}
	m_pLocationInfo = 0;

	// Update member variables
	m_State = GK_REGISTERED;
	SPIDER_TRACE(SP_STATE, "m_State = GK_REGISTERED (%X)\n", this);
	m_Location[0] = pRasMessage->u.locationConfirm.callSignalAddress;
	m_Location[1] = pRasMessage->u.locationConfirm.rasAddress;

	// Notify user application
	SPIDER_TRACE(SP_GKI, "PostMessage(m_hWnd, m_wBaseMessage + GKI_LOCATION_CONFIRM, 0, &m_Location[0])\n", 0);
	PostMessage(m_hWnd, m_wBaseMessage + GKI_LOCATION_CONFIRM,
			0, (LPARAM)&m_Location[0]);

	return (GKI_OK);
}

HRESULT
CRegistration::LocationReject(RasMessage *pRasMessage)
{
	// ABSTRACT:  This function is called if a locationReject is
	//            received and matches an outstanding locationRequest.
	//            It will delete the memory used for the locationRequest
	//            change the state and notify the user by posting a message
	// AUTHOR:    Colin Hulme

	SeqAliasAddr	*pAA1, *pAA2;
#ifdef _DEBUG
	char			szGKDebug[80];
#endif

	SPIDER_TRACE(SP_FUNC, "CRegistration::LocationReject(%X)\n", pRasMessage);

	// Delete allocate RasMessage storage
	SPIDER_TRACE(SP_NEWDEL, "del m_pRasMessage = %X\n", m_pRasMessage);
	delete m_pRasMessage;
	m_pRasMessage = 0;

	// Delete allocated memory for sequence of location alias addresses
	pAA1 = m_pLocationInfo;
	while (pAA1 != 0)
	{
		pAA2 = pAA1->next;
		if (pAA1->value.choice == h323_ID_chosen)
		{
			SPIDER_TRACE(SP_NEWDEL, "del pAA1->value.u.h323_ID.value = %X\n", pAA1->value.u.h323_ID.value);
			delete pAA1->value.u.h323_ID.value;
		}
		SPIDER_TRACE(SP_NEWDEL, "del pAA1 = %X\n", pAA1);
		delete pAA1;
		pAA1 = pAA2;
	}
	m_pLocationInfo = 0;

	// Update member variables
	m_State = GK_REGISTERED;
	SPIDER_TRACE(SP_STATE, "m_State = GK_REGISTERED (%X)\n", this);

	// Notify user application
	SPIDER_TRACE(SP_GKI, "PostMessage(m_hWnd, m_wBaseMessage + GKI_LOCATION_REJECT, %X, 0)\n",
									pRasMessage->u.locationReject.rejectReason.choice);
	PostMessage(m_hWnd, m_wBaseMessage + GKI_LOCATION_REJECT,
				(WORD)pRasMessage->u.locationReject.rejectReason.choice, 0L);

	return (GKI_OK);
}

HRESULT
CRegistration::UnknownMessage(RasMessage *pRasMessage)
{
	// ABSTRACT:  This member function is called to respond to the gatekeeper
	//            with an XRS PDU indicated that the received PDU is an unknown
	//            message
	// AUTHOR:    Colin Hulme

	ASN1_BUF		Asn1Buf;
	DWORD			dwErrorCode;
	RasMessage		*pOutRasMessage;
#ifdef _DEBUG
	char			szGKDebug[80];
#endif

	SPIDER_TRACE(SP_FUNC, "CRegistration::UnknownMessage(%X)\n", pRasMessage);
	ASSERT(g_pCoder);
	if (g_pCoder == NULL)
		return (GKI_NOT_INITIALIZED);	
		
	// Allocate a RasMessage structure and initialized to 0
	pOutRasMessage = new RasMessage;
	SPIDER_TRACE(SP_NEWDEL, "new pOutRasMessage = %X\n", pOutRasMessage);
	if (pOutRasMessage == 0)
		return (GKI_NO_MEMORY);
	memset(pOutRasMessage, 0, sizeof(RasMessage));

	// Setup structure fields for UnregistrationRequest
	pOutRasMessage->choice = unknownMessageResponse_chosen;
	pOutRasMessage->u.unknownMessageResponse.requestSeqNum =
			pRasMessage->u.registrationRequest.requestSeqNum; // can use from
									// from any RAS Message, since SeqNum
									// is always in same position.

	// Encode the PDU & send it
	dwErrorCode = g_pCoder->Encode(pOutRasMessage, &Asn1Buf);
	if (dwErrorCode)
		return (GKI_ENCODER_ERROR);

	SPIDER_TRACE(SP_PDU, "Send XRS; g_pReg = %X\n", this);

	if (fGKIDontSend == FALSE)
		if (m_pSocket->Send((char *)Asn1Buf.value, Asn1Buf.length) == SOCKET_ERROR)
			return (GKI_WINSOCK2_ERROR(SOCKET_ERROR));

	// Free the encoder memory
	g_pCoder->Free(Asn1Buf);

	SPIDER_TRACE(SP_NEWDEL, "del pOutRasMessage = %X\n", pOutRasMessage);
	delete pOutRasMessage;
	pOutRasMessage = 0;

	return (GKI_OK);
}

HRESULT
CRegistration::GatekeeperConfirm(RasMessage *pRasMessage)
{
	// ABSTRACT:  This function is called if a gatekeeperConfirm is
	//            received.  Note this member function must first ascertain
	//            that the supplied confirmation sequence number matches
	//            the outstanding request sequence number, if not - it
	//            will send an XRS response.
	// AUTHOR:    Colin Hulme

	char				szBuffer[80];
	HRESULT				hResult;
#ifdef _DEBUG
	char				szGKDebug[80];
#endif

	SPIDER_TRACE(SP_FUNC, "CRegistration::GatekeeperConfirm(%X)\n", pRasMessage);
	ASSERT(g_pGatekeeper);
	if(g_pGatekeeper == NULL)
		return (GKI_NOT_INITIALIZED);	
		
	if (m_pRasMessage == 0)
		return (0);

	if (pRasMessage->u.gatekeeperConfirm.requestSeqNum !=
			m_pRasMessage->u.gatekeeperRequest.requestSeqNum)
	{
		hResult = g_pReg->UnknownMessage(pRasMessage);
		return (hResult);
	}

	// Delete allocated RasMessage storage
	SPIDER_TRACE(SP_NEWDEL, "del m_pRasMessage = %X\n", m_pRasMessage);
	delete m_pRasMessage;
	m_pRasMessage = 0;

	// Update member variables
	if ((pRasMessage->u.gatekeeperConfirm.bit_mask & GtkprCnfrm_gtkprIdntfr_present) &&
			(m_RCm_gtkprIdntfr.value == 0))
	{
		// Copy gatekeeper identifier
		m_RCm_gtkprIdntfr.length = pRasMessage->u.gatekeeperConfirm.GtkprCnfrm_gtkprIdntfr.length;
		m_RCm_gtkprIdntfr.value = new unsigned short[m_RCm_gtkprIdntfr.length];
		SPIDER_TRACE(SP_NEWDEL, "new m_RCm_gtkprIdntfr.value = %X\n", m_RCm_gtkprIdntfr.value);
		if (m_RCm_gtkprIdntfr.value == 0)
			return (GKI_NO_MEMORY);
		memcpy(m_RCm_gtkprIdntfr.value,
				pRasMessage->u.gatekeeperConfirm.GtkprCnfrm_gtkprIdntfr.value,
				m_RCm_gtkprIdntfr.length * sizeof(unsigned short));
	}
	
	// Copy gatekeeper RAS Address
	ASSERT((pRasMessage->u.gatekeeperConfirm.rasAddress.choice == ipAddress_chosen) ||
			(pRasMessage->u.gatekeeperConfirm.rasAddress.choice == ipxAddress_chosen));

	switch (pRasMessage->u.gatekeeperConfirm.rasAddress.choice)
	{
	case ipAddress_chosen:
		wsprintf(szBuffer, "%d.%d.%d.%d",
				pRasMessage->u.gatekeeperConfirm.rasAddress.u.ipAddress.ip.value[0],
				pRasMessage->u.gatekeeperConfirm.rasAddress.u.ipAddress.ip.value[1],
				pRasMessage->u.gatekeeperConfirm.rasAddress.u.ipAddress.ip.value[2],
				pRasMessage->u.gatekeeperConfirm.rasAddress.u.ipAddress.ip.value[3]);
		g_pGatekeeper->SetIPAddress(szBuffer);
		break;
#if(0)		
	case ipxAddress_chosen:
		wsprintf(szBuffer, "%02X%02X%02X%02X:%02X%02X%02X%02X%02X%02X",
				pRasMessage->u.gatekeeperConfirm.rasAddress.u.ipxAddress.netnum.value[0],
				pRasMessage->u.gatekeeperConfirm.rasAddress.u.ipxAddress.netnum.value[1],
				pRasMessage->u.gatekeeperConfirm.rasAddress.u.ipxAddress.netnum.value[2],
				pRasMessage->u.gatekeeperConfirm.rasAddress.u.ipxAddress.netnum.value[3],
				pRasMessage->u.gatekeeperConfirm.rasAddress.u.ipxAddress.node.value[0],
				pRasMessage->u.gatekeeperConfirm.rasAddress.u.ipxAddress.node.value[1],
				pRasMessage->u.gatekeeperConfirm.rasAddress.u.ipxAddress.node.value[2],
				pRasMessage->u.gatekeeperConfirm.rasAddress.u.ipxAddress.node.value[3],
				pRasMessage->u.gatekeeperConfirm.rasAddress.u.ipxAddress.node.value[4],
				pRasMessage->u.gatekeeperConfirm.rasAddress.u.ipxAddress.node.value[5]);
		g_pGatekeeper->SetIPXAddress(szBuffer);
		break;
#endif // if(0)
		default:
		break;
	}

	g_pGatekeeper->Write();

	return (GKI_OK);
}

HRESULT
CRegistration::GatekeeperReject(RasMessage *pRasMessage)
{
	// ABSTRACT:  This function is called if a gatekeeperReject is
	//            received.  Note this member function must first ascertain
	//            that the supplied rejection sequence number matches
	//            the outstanding request sequence number, if not - it
	//            will send an XRS response.
	// AUTHOR:    Colin Hulme

	HRESULT			hResult;
#ifdef _DEBUG
	char			szGKDebug[80];
#endif

	SPIDER_TRACE(SP_FUNC, "CRegistration::GatekeeperReject(%X)\n", pRasMessage);
	ASSERT(g_pGatekeeper);
	if(g_pGatekeeper == NULL)
		return (GKI_NOT_INITIALIZED);	
		
	if (m_pRasMessage == 0)
		return (GKI_OK);

	if (pRasMessage->u.gatekeeperReject.requestSeqNum !=
			m_pRasMessage->u.gatekeeperRequest.requestSeqNum)
	{
		hResult = g_pReg->UnknownMessage(pRasMessage);
		return (hResult);
	}

	g_pGatekeeper->SetRejectFlag(TRUE);	// Indicate that atleast one GRJ was received
	return (GKI_OK);
}

HRESULT
CRegistration::SendUnregistrationConfirm(RasMessage *pRasMessage)
{
	// ABSTRACT:  This function is called when an unregistrationRequest is
	//            received from the gatekeeper.  It will create the
	//            unregistrationConfirm structure, encode it and send
	//            it on the net.  It posts a message to the user
	//            notifying them.
	// AUTHOR:    Colin Hulme

	ASN1_BUF		Asn1Buf;
	DWORD			dwErrorCode;
	RasMessage		*pRespRasMessage;
#ifdef _DEBUG
	char			szGKDebug[80];
#endif

	SPIDER_TRACE(SP_FUNC, "CRegistration::UnregistrationConfirm(%X)\n", pRasMessage);
	ASSERT(g_pCoder);
	if (g_pCoder == NULL)
		return (GKI_NOT_INITIALIZED);	
		
	// Allocate a RasMessage structure and initialized to 0
	pRespRasMessage = new RasMessage;
	SPIDER_TRACE(SP_NEWDEL, "new pRespRasMessage = %X\n", pRespRasMessage);
	if (pRespRasMessage == 0)
		return (GKI_NO_MEMORY);
	memset(pRespRasMessage, 0, sizeof(RasMessage));

	// Setup structure fields for UnregistrationConfirm
	pRespRasMessage->choice = unregistrationConfirm_chosen;
	pRespRasMessage->u.unregistrationConfirm.requestSeqNum =
			pRasMessage->u.unregistrationRequest.requestSeqNum;

#ifdef _DEBUG
	if (dwGKIDLLFlags & SP_DUMPMEM)
		DumpMem(pRespRasMessage, sizeof(RasMessage));
#endif

	// Encode the PDU & send it
	dwErrorCode = g_pCoder->Encode(pRespRasMessage, &Asn1Buf);
	if (dwErrorCode)
		return (GKI_ENCODER_ERROR);

	m_State = GK_UNREGISTERED;
	SPIDER_TRACE(SP_STATE, "m_State = GK_UNREGISTERED (%X)\n", this);

	SPIDER_TRACE(SP_PDU, "Send UCF; g_pReg = %X\n", this);
	if (fGKIDontSend == FALSE)
		if (m_pSocket->Send((char *)Asn1Buf.value, Asn1Buf.length) == SOCKET_ERROR)
			return (GKI_WINSOCK2_ERROR(SOCKET_ERROR));

	// Free the encoder memory
	g_pCoder->Free(Asn1Buf);

	// Delete allocated RasMessage storage
	SPIDER_TRACE(SP_NEWDEL, "del pRespRasMessage = %X\n", pRespRasMessage);
	delete pRespRasMessage;

	// fake "received unregistration confirm" because the upper
	// state machine code depends on it
	SPIDER_TRACE(SP_GKI, "PostMessage(m_hWnd, m_wBaseMessage + GKI_UNREG_CONFIRM, 0, 0)\n", 0);
	PostMessage(m_hWnd, m_wBaseMessage + GKI_UNREG_CONFIRM, 0, 0);

	return (GKI_OK);
}

HRESULT
CRegistration::Retry(void)
{
	// ABSTRACT:  This function is called by the background Retry thread
	//            at the configured time interval.  It will check if there
	//            are any outstanding PDUs for the Registration object
	//            If so, they will be retransmitted.  If the maximum number of
	//            retries has expired, the memory will be cleaned up.
	//            This function will return 0 to the background thread unless
	//            it wants the thread to terminate.
	// AUTHOR:    Colin Hulme

	ASN1_BUF			Asn1Buf;
	DWORD				dwErrorCode;
	HANDLE				hThread;
	SeqTransportAddr	*pTA1, *pTA2;
	SeqAliasAddr		*pAA1, *pAA2;
	int					nRet;
#ifdef _DEBUG
	char				szGKDebug[80];
#endif
	HRESULT				hResult = GKI_OK;

//	SPIDER_TRACE(SP_FUNC, "CRegistration::Retry() %X\n", m_pCall);
	ASSERT(g_pCoder);
	if ((g_pCoder == NULL) && (g_pGatekeeper == NULL))
		return (GKI_NOT_INITIALIZED);	

	// Allow calls to do retry processing
	if (!m_Calls.IsEmpty())
	{
		// Loop through and let each call do it's retry processing
		// It should be safe to call DeleteCall() from within the
		// iteration since pos1 should still be valid after the
		// removal.
		POS pos1;
		for( pos1 = m_Calls.GetFirstPos(); pos1 != NULL; )
		{
			// Call Retry() for this call
			CCall *pCall = m_Calls.GetNext(pos1);
			ASSERT (pCall);
			hResult = pCall->Retry();
			if (hResult == GKI_DELETE_CALL)
			{
				DeleteCall(pCall);
				hResult = GKI_OK;
			}
		}
	}
	
	// Check if any outstanding registration PDUs
	if (m_pRasMessage && (--m_uRetryCountdown == 0))
	{
		// going to retry, reset countdown
		m_uRetryCountdown = m_uRetryResetCount;

		if (m_usRetryCount <= m_uMaxRetryCount)
		{
			// Encode the PDU & resend it
			dwErrorCode = g_pCoder->Encode(m_pRasMessage, &Asn1Buf);
			if (dwErrorCode)
				return (GKI_ENCODER_ERROR);

			SPIDER_TRACE(SP_PDU, "RESend PDU; g_pReg = %X\n", this);
			if (fGKIDontSend == FALSE)
			{
				if (m_pRasMessage->choice == gatekeeperRequest_chosen)
				{
					if (m_pSocket->SendBroadcast((char *)Asn1Buf.value, Asn1Buf.length) == SOCKET_ERROR)
						return (GKI_WINSOCK2_ERROR(SOCKET_ERROR));
				}
				else
				{
					if (m_pSocket->Send((char *)Asn1Buf.value, Asn1Buf.length) == SOCKET_ERROR)
						return (GKI_WINSOCK2_ERROR(SOCKET_ERROR));
				}
			}

			// Free the encoder memory
			g_pCoder->Free(Asn1Buf);
			m_usRetryCount++;
		}
		else	// Retries expired - clean up
		{
			switch (m_pRasMessage->choice)
			{
			case gatekeeperRequest_chosen:

#ifdef BROADCAST_DISCOVERY			

				m_State = GK_UNREGISTERED;
				SPIDER_TRACE(SP_STATE, "m_State = GK_UNREGISTERED (%X)\n", this);

				// We deliberately don't free the RasMessage memory.  Let the
				// registration destructor do it - this provides protection
				// from other requests.

				// Close socket - this will terminate the Discovery thread
				if ((nRet = m_pSocket->Close()) != 0)
					return (GKI_WINSOCK2_ERROR(nRet));

				// Delete cached address from the registry
				g_pGatekeeper->DeleteCachedAddresses();

				if (g_pGatekeeper->GetRejectFlag() == FALSE)
				{
					SPIDER_TRACE(SP_GKI, "PostMessage(m_hWnd, m_wBaseMessage + GKI_REG_BYPASS, 0, 0)\n", 0);
					PostMessage(m_hWnd, m_wBaseMessage + GKI_REG_BYPASS,
							0, 0);
					return (GKI_EXIT_THREAD);
				}
				else
					hResult = GKI_EXIT_THREAD;
#else 	
				ASSERT(0);
				hResult = GKI_EXIT_THREAD;
#endif	//BROADCAST_DISCOVERY				
				break;
			case registrationRequest_chosen:
				SPIDER_TRACE(SP_NEWDEL, "del m_pRasMessage = %X\n", m_pRasMessage);
				delete m_pRasMessage;
				m_pRasMessage = 0;
				
#ifdef BROADCAST_DISCOVERY
				// Need to attempt gatekeeper discovery

				// Close socket and reopen in non-connected state to allow sendto
				// This will also terminate the PostRecv thread
				if ((nRet = m_pSocket->Close()) != 0)
					return (GKI_WINSOCK2_ERROR(nRet));
				if ((nRet = m_pSocket->Create(m_pSocket->GetAddrFam(), 0)) != 0)
					return (GKI_WINSOCK2_ERROR(nRet));

				// Delete allocated memory for sequence of RAS addresses
				pTA1 = m_pRASAddress;
				while (pTA1 != 0)
				{
					pTA2 = pTA1->next;
					SPIDER_TRACE(SP_NEWDEL, "del pTA1 = %X\n", pTA1);
					delete pTA1;
					pTA1 = pTA2;
				}

				// Update RAS Address in CRegistration
				for (pTA1 = m_pCallSignalAddress; pTA1 != 0; pTA1 = pTA1->next)
				{
					if (pTA1->value.choice == m_usRegistrationTransport)
						if ((hResult = AddRASAddr(pTA1->value, m_pSocket->GetPort())) != GKI_OK)
							return (hResult);
				}

				// Start the discovery thread
				hThread = (HANDLE)_beginthread(GKDiscovery, 0, 0);
				SPIDER_TRACE(SP_THREAD, "_beginthread(GKDiscovery, 0, 0); <%X>\n", hThread);
				if (hThread == (HANDLE)-1)
					return (GKI_NO_THREAD);
				SetDiscThread(hThread);

				hResult = GKI_REDISCOVER;
				break;
#else // not BROADCAST_DISCOVERY
				hResult = GKI_EXIT_THREAD;
#endif // BROADCAST_DISCOVERY

			case unregistrationRequest_chosen:
				m_State = GK_UNREGISTERED;
				SPIDER_TRACE(SP_STATE, "m_State = GK_UNREGISTERED (%X)\n", this);

				SPIDER_TRACE(SP_NEWDEL, "del m_pRasMessage = %X\n", m_pRasMessage);
				delete m_pRasMessage;
				m_pRasMessage = 0;

				// Close socket - this will terminate the Receive thread
				if ((nRet = m_pSocket->Close()) != 0)
					return (GKI_WINSOCK2_ERROR(nRet));

				hResult = GKI_EXIT_THREAD;
				break;

			case locationRequest_chosen:
				m_State = GK_REGISTERED;
				SPIDER_TRACE(SP_STATE, "m_State = GK_REGISTERED (%X)\n", this);

				SPIDER_TRACE(SP_NEWDEL, "del m_pRasMessage = %X\n", m_pRasMessage);
				delete m_pRasMessage;
				m_pRasMessage = 0;

				// Delete allocated memory for sequence of location alias addresses
				pAA1 = m_pLocationInfo;
				while (pAA1 != 0)
				{
					pAA2 = pAA1->next;
					if (pAA1->value.choice == h323_ID_chosen)
					{
						SPIDER_TRACE(SP_NEWDEL, "del pAA1->value.u.h323_ID.value = %X\n", pAA1->value.u.h323_ID.value);
						delete pAA1->value.u.h323_ID.value;
					}
					SPIDER_TRACE(SP_NEWDEL, "del pAA1 = %X\n", pAA1);
					delete pAA1;
					pAA1 = pAA2;
				}

				break;
			}

			// Notify user that gatekeeper didn't respond
			if (hResult != GKI_REDISCOVER)
			{
				SPIDER_TRACE(SP_GKI, "PostMessage(m_hWnd, m_wBaseMessage + GKI_ERROR, 0, GKI_NO_RESPONSE)\n", 0);
				PostMessage(m_hWnd, m_wBaseMessage + GKI_ERROR,
						0, GKI_NO_RESPONSE);
			}
			else
				hResult = GKI_OK;	// Don't exit retry thread
		}
	}

	return (hResult);
}

HRESULT
CRegistration::SendInfoRequestResponse(CallInfoStruct *pCallInfo, RasMessage *pRasMessage)
{
	// ABSTRACT:  This function is called from one or more call object
	//            to create an IRR RasMessage, encapsulate the supplied
	//            call information and send the message to the
	//            gatekeeper.
	// AUTHOR:    Colin Hulme

	ASN1_BUF			Asn1Buf;
	DWORD				dwErrorCode;
	RasMessage			*pRespRasMessage;
	struct sockaddr_in	sAddrIn;
#ifdef _DEBUG
	char				szGKDebug[80];
#endif


	SPIDER_TRACE(SP_FUNC, "CRegistration::SendInfoRequestResponse()\n", 0);
	ASSERT(g_pCoder);
	if (g_pCoder == NULL)
		return (GKI_NOT_INITIALIZED);	
		
	// Allocate a RasMessage structure and initialized to 0
	pRespRasMessage = new RasMessage;
	SPIDER_TRACE(SP_NEWDEL, "new pRespRasMessage = %X\n", pRespRasMessage);
	if (pRespRasMessage == 0)
		return (GKI_NO_MEMORY);
	memset(pRespRasMessage, 0, sizeof(RasMessage));

	// Setup structure fields for InfoRequestResponse
	pRespRasMessage->choice = infoRequestResponse_chosen;
	if (m_pRgstrtnRqst_trmnlAls != 0)
		pRespRasMessage->u.infoRequestResponse.bit_mask |= InfRqstRspns_endpntAls_present;
	if (pCallInfo != 0)
		pRespRasMessage->u.infoRequestResponse.bit_mask |= perCallInfo_present;

	if (pRasMessage)
	{
		pRespRasMessage->u.infoRequestResponse.requestSeqNum =
				pRasMessage->u.infoRequest.requestSeqNum;
		if (pRasMessage->u.infoRequest.bit_mask & replyAddress_present)
		{
			switch (pRasMessage->u.infoRequest.replyAddress.choice)
			{
			case ipAddress_chosen:
				sAddrIn.sin_family = AF_INET;
				sAddrIn.sin_port = htons(pRasMessage->u.infoRequest.replyAddress.u.ipAddress.port);
				break;
			case ipxAddress_chosen:
				sAddrIn.sin_family = AF_IPX;
				sAddrIn.sin_port = htons(GKIPX_RAS_PORT); //Need to use reply port
				break;
			}
			memcpy(&sAddrIn.sin_addr,
					&pRasMessage->u.infoRequest.replyAddress.u.ipAddress.ip.value[0], 4);
		}
	}
	else
		// unsolicited IRRs must have a sequence number of 1!!!! (H.225 says so)
		pRespRasMessage->u.infoRequestResponse.requestSeqNum = 1;
	

	pRespRasMessage->u.infoRequestResponse.endpointType = m_terminalType;
	pRespRasMessage->u.infoRequestResponse.endpointIdentifier = m_endpointID;
	pRespRasMessage->u.infoRequestResponse.rasAddress = m_pRASAddress->value;
	pRespRasMessage->u.infoRequestResponse.callSignalAddress =
				(PInfoRequestResponse_callSignalAddress)m_pCallSignalAddress;
	pRespRasMessage->u.infoRequestResponse.InfRqstRspns_endpntAls =
				(PInfoRequestResponse_endpointAlias)m_pRgstrtnRqst_trmnlAls;

	pRespRasMessage->u.infoRequestResponse.perCallInfo =
                (PInfoRequestResponse_perCallInfo)pCallInfo;

#ifdef _DEBUG
	if (dwGKIDLLFlags & SP_DUMPMEM)
		DumpMem(pRespRasMessage, sizeof(RasMessage));
#endif

	// Encode the PDU & send it
	dwErrorCode = g_pCoder->Encode(pRespRasMessage, &Asn1Buf);
	if (dwErrorCode)
		return (GKI_ENCODER_ERROR);

	SPIDER_TRACE(SP_PDU, "Send IRR; g_pReg = %X\n", this);
	if (fGKIDontSend == FALSE)
	{
		if (pRasMessage && (pRasMessage->u.infoRequest.bit_mask & replyAddress_present))
		{
			if (g_pReg->m_pSocket->SendTo((char *)Asn1Buf.value, Asn1Buf.length,
					(LPSOCKADDR)&sAddrIn, sizeof(sAddrIn)) == SOCKET_ERROR)
				return (GKI_WINSOCK2_ERROR(SOCKET_ERROR));
		}
		else
		{
			if (g_pReg->m_pSocket->Send((char *)Asn1Buf.value, Asn1Buf.length) == SOCKET_ERROR)
				return (GKI_WINSOCK2_ERROR(SOCKET_ERROR));
		}
	}

	// Free the encoder memory
	g_pCoder->Free(Asn1Buf);

	// Delete allocated RasMessage storage
	SPIDER_TRACE(SP_NEWDEL, "del pRespRasMessage = %X\n", pRespRasMessage);
	delete pRespRasMessage;

	return (GKI_OK);
}


//
// FindCallBySeqNum()
//
// ABSTRACT:
//	This function attempts to locate a call within the list of calls
//	in the registration object that has an outstanding RAS request that has this
//	sequence number.
//
// RETURNS:
//	Pointer to call associated with the sequence number or
//	NULL if no call is found.
//
// NOTES:
//	This function is usually called by the CRegistration::PDUHandler()
//	when it receives a reply message that needs to be associated with a
//	particular call.
//
// ASSUMPTIONS:
//	Each call object holds on to the sequence numbers for RAS
//	requests that it has not received replies for.
//
// AUTHOR:	Dan Dexter
CCall *
CRegistration::FindCallBySeqNum(RequestSeqNum seqNum)
{
	// If there are no calls, we can just return now
	if (m_Calls.IsEmpty())
		return(NULL);

	// Initialize return value to "call not found"
	CCall *RetVal = NULL;

	// Otherwise, iterate through the calls and ask them
	// if this sequence number belongs to them
	POS pos;
	for( pos = m_Calls.GetFirstPos(); pos != NULL; )
	{
		// Ask call if sequence number is theirs
		CCall *pCall = m_Calls.GetNext(pos);
		if (pCall->MatchSeqNum(seqNum))
		{
			RetVal = pCall;
			break;
		}
	}
	return(RetVal);
}

//
// FindCallByCRV()
//
// ABSTRACT:
//	This function attempts to locate a call within the list of calls
//	in the registration object that is associated with the passed in
//	CallReferenceValue.
//
// RETURNS:
//	Pointer to call associated with the CRV or
//	NULL if no call is found.
//
// NOTES:
//	This function is usually called by the CRegistration::PDUHandler()
//	when it receives a reply message that needs to be associated with a
//	particular call.
//
// AUTHOR:	Dan Dexter
CCall *
CRegistration::FindCallByCRV(CallReferenceValue crv)
{
	// If there are no calls, we can just return now
	if (m_Calls.IsEmpty())
		return(NULL);

	// Initialize return value to "call not found"
	CCall *RetVal = NULL;

	// Otherwise, iterate through the calls and ask them
	// if this CRV number belongs to them
	POS pos;
	for( pos = m_Calls.GetFirstPos(); pos != NULL; )
	{
		// Ask call if sequence number is theirs
		CCall *pCall = m_Calls.GetNext(pos);
		if (pCall->MatchCRV(crv))
		{
			RetVal = pCall;
			break;
		}
	}
	return(RetVal);
}

void
CRegistration::DeleteCall(CCall *pCall)
{
#ifdef _DEBUG
	char			szGKDebug[80];
#endif

	POS pos = m_Calls.Find(pCall);
	// We don't expect to be asked to delete
	// calls that aren't in the list, so ASSERT
	ASSERT(pos);

	if (pos)
	{
		CCall *pCallObject = m_Calls.GetAt(pos);
		m_Calls.RemoveAt(pos);
		SPIDER_TRACE(SP_NEWDEL, "del pCallObject = %X\n", pCallObject);
		delete pCallObject;
	}
}

void
CRegistration::AddCall(CCall *pCall)
{
	m_Calls.AddTail(pCall);
}

CCall *
CRegistration::GetNextCall(CCall *pCall)
{
	CCall	*RetVal = NULL;

	if (pCall)
	{
		// The call list should never be empty
		// if we're called with a non-NULL call pointer
		ASSERT(!m_Calls.IsEmpty());

		POS	pos = m_Calls.Find(pCall);
		// The call passed in better have been found
		ASSERT(pos);

		if (pos)
		{
			// This actually gets the existing call, but sets
			// pos to point to the next call.
			CCall *pNextCall = m_Calls.GetNext(pos);
			if (pos)
			{
				// This call sets up the return value
				RetVal = m_Calls.GetAt(pos);
			}
		}
	}
	return(RetVal);
}

#if 0
void
CRegistration::Lock(void)
{
	EnterCriticalSection(&m_CriticalSection);
	m_dwLockingThread = GetCurrentThreadId();
}

void
CRegistration::Unlock(void)
{
	// Assert that the unlock is done by the
	// thread that holds the lock
	ASSERT(m_dwLockingThread == GetCurrentThreadId());
	
	m_dwLockingThread = 0;
	LeaveCriticalSection(&m_CriticalSection);
}
#endif