|
|
/************************************************************************
* ** 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\gkireg.cpv $* ** $Revision: 1.13 $* $Date: 14 Feb 1997 16:44:06 $* ** $Author: CHULME $* ** $Log: S:\sturgeon\src\gki\vcs\gkireg.cpv $//
// Rev 1.13 14 Feb 1997 16:44:06 CHULME
// If fail to create semaphore - delete registration object before returning
//
// Rev 1.12 12 Feb 1997 01:11:06 CHULME
// Redid thread synchronization to use Gatekeeper.Lock
//
// Rev 1.11 08 Feb 1997 12:14:02 CHULME
// Added semaphore creation for later terminating the retry thread
//
// Rev 1.10 24 Jan 1997 18:30:00 CHULME
// Reverted to rev 1.8
//
// Rev 1.8 22 Jan 1997 20:46:08 EHOWARDX
// Work-around for race condition that may result in
// GKI_RegistrationRequest returning GKI_ALREADY_REG.
//
// Rev 1.7 17 Jan 1997 09:02:16 CHULME
// Changed reg.h to gkreg.h to avoid name conflict with inc directory
//
// Rev 1.6 10 Jan 1997 16:15:40 CHULME
// Removed MFC dependency
//
// Rev 1.5 20 Dec 1996 16:38:28 CHULME
// Fixed access synchronization with Gatekeeper lock
//
// Rev 1.4 13 Dec 1996 14:26:04 CHULME
// Fixed access error on thread synchronization
//
// Rev 1.3 02 Dec 1996 23:50:50 CHULME
// Added premptive synchronization code
//
// Rev 1.2 22 Nov 1996 15:22:24 CHULME
// Added VCS log to the header
*************************************************************************/
// gkiregistration.cpp : Handles the GKI_RegistrationRequest API
//
#include "precomp.h"
#include <process.h>
#include <winsock.h>
#include "GKICOM.H"
#include "dspider.h"
#include "dgkilit.h"
#include "DGKIPROT.H"
#include "GATEKPR.H"
#include "gksocket.h"
#include "GKREG.H"
#include "h225asn.h"
#include "coder.hpp"
#include "dgkiext.h"
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;#endif
extern "C" HRESULT DLL_EXPORTGKI_RegistrationRequest(long lVersion, SeqTransportAddr *pCallSignalAddr, EndpointType *pTerminalType, SeqAliasAddr *pRgstrtnRqst_trmnlAls, PCC_VENDORINFO pVendorInfo, HWND hWnd, WORD wBaseMessage, unsigned short usRegistrationTransport){ // ABSTRACT: This function is exported. It is called by the client application
// to register with the Gatekeeper. It will create a CRegistration
// object to track all pertanent information.
// AUTHOR: Colin Hulme
int nAddrFam; int nRet; HRESULT hResult; //char *pDestAddr;
PSOCKADDR_IN pDestAddr; SeqTransportAddr *pTA; SeqAliasAddr *pAA; HANDLE hThread;#ifdef _DEBUG
char szGKDebug[80];#endif
BOOL fRAS = FALSE;
SPIDER_TRACE(SP_FUNC, "GKI_RegistrationRequest(%x)\n", usRegistrationTransport); ASSERT(g_pGatekeeper); if(g_pGatekeeper == NULL) return (GKI_NOT_INITIALIZED); #ifdef _DEBUG
if (dwGKIDLLFlags & SP_GKI) { SPIDER_TRACE(SP_GKI, "GKI_RegistrationRequest()\n", 0); Dump_GKI_RegistrationRequest(lVersion, pCallSignalAddr, pTerminalType, pRgstrtnRqst_trmnlAls, hWnd, wBaseMessage, usRegistrationTransport); }#endif
// Check if there is already a registration
// Create a Gatekeeper lock object on the stack
// It's constructor will lock pGK and when we return
// from any path, its destructor will unlock pGK
CGatekeeperLock GKLock(g_pGatekeeper); if (g_pReg) { if (g_pReg->GetRasMessage() != 0) return (GKI_BUSY); else return (GKI_ALREADY_REG); }
if (lVersion != GKI_VERSION) return (GKI_VERSION_ERROR);
ASSERT((usRegistrationTransport == ipAddress_chosen) ||(usRegistrationTransport == ipxAddress_chosen));
// Create a registration object
g_pReg = new CRegistration; SPIDER_TRACE(SP_NEWDEL, "new g_pReg = %X\n", g_pReg); if (g_pReg == 0) return (GKI_NO_MEMORY);#if(0)
// Create the semaphore used to signal the retry thread to exit
g_pReg->m_hRetrySemaphore = CreateSemaphore(NULL,0,1,NULL); if(!g_pReg->m_hRetrySemaphore){ SPIDER_TRACE(SP_NEWDEL, "del g_pReg = %X\n", g_pReg); delete g_pReg; g_pReg = 0; return (GKI_SEMAPHORE_ERROR); }#endif
// Create a socket and bind to a local address
g_pReg->m_pSocket = new CGKSocket; SPIDER_TRACE(SP_NEWDEL, "new g_pReg->m_pSocket = %X\n", g_pReg->m_pSocket); if (g_pReg->m_pSocket == 0) { SPIDER_TRACE(SP_NEWDEL, "del g_pReg = %X\n", g_pReg); delete g_pReg; g_pReg = 0; return (GKI_NO_MEMORY); }
ASSERT(usRegistrationTransport == ipAddress_chosen); if(usRegistrationTransport != ipAddress_chosen) { delete g_pReg; g_pReg = 0; return (GKI_NO_MEMORY); } nAddrFam = PF_INET; pDestAddr = g_pGatekeeper->GetSockAddr();
if ((nRet = g_pReg->m_pSocket->Create(nAddrFam, 0)) != 0) { SPIDER_TRACE(SP_NEWDEL, "del g_pReg = %X\n", g_pReg); delete g_pReg; g_pReg = 0; return (GKI_WINSOCK2_ERROR(nRet)); }
// Initialize registration member variables
for (pTA = pCallSignalAddr; pTA != 0; pTA = pTA->next) { if ((hResult = g_pReg->AddCallSignalAddr(pTA->value)) != GKI_OK) { SPIDER_TRACE(SP_NEWDEL, "del g_pReg = %X\n", g_pReg); delete g_pReg; g_pReg = 0; return (hResult); } // if the transport type of the address being registered is the same as
// the transport type of the gatekeeper, set RAS address
if (pTA->value.choice == usRegistrationTransport) { if ((hResult = g_pReg->AddRASAddr(pTA->value, g_pReg->m_pSocket->GetPort())) != GKI_OK) { SPIDER_TRACE(SP_NEWDEL, "del g_pReg = %X\n", g_pReg); delete g_pReg; g_pReg = 0; return (hResult); } else fRAS = TRUE; } } if(pVendorInfo) { hResult = g_pReg->AddVendorInfo(pVendorInfo); }
if (fRAS == FALSE) // No RAS address registered for this transport
{ SPIDER_TRACE(SP_NEWDEL, "del g_pReg = %X\n", g_pReg); delete g_pReg; g_pReg = 0; return (GKI_NO_TA_ERROR); }
g_pReg->SetTerminalType(pTerminalType); for (pAA = pRgstrtnRqst_trmnlAls; pAA != 0; pAA = pAA->next) { if ((hResult = g_pReg->AddAliasAddr(pAA->value)) != GKI_OK) { SPIDER_TRACE(SP_NEWDEL, "del g_pReg = %X\n", g_pReg); delete g_pReg; g_pReg = 0; return (hResult); } } g_pReg->SetHWnd(hWnd); g_pReg->SetBaseMessage(wBaseMessage); g_pReg->SetRegistrationTransport(usRegistrationTransport);
#if(0)
// Start the retries thread
hThread = (HANDLE)_beginthread(Retry, 0, 0); SPIDER_TRACE(SP_THREAD, "_beginthread(Retry, 0 0); <%X>\n", hThread); if (hThread == (HANDLE)-1) { SPIDER_TRACE(SP_NEWDEL, "del g_pReg = %X\n", g_pReg); delete g_pReg; g_pReg = 0; return (GKI_NO_THREAD); } g_pReg->SetRetryThread(hThread);#else
// initialize timer and values
UINT_PTR uTimer = g_pReg->StartRetryTimer(); if (!uTimer) { SPIDER_TRACE(SP_NEWDEL, "del g_pReg = %X\n", g_pReg); delete g_pReg; g_pReg = 0; return (GKI_NO_THREAD); }#endif
#ifdef BROADCAST_DISCOVERY
// Check to see if we are not bound to a gatekeeper
if (pDestAddr == 0) { hThread = (HANDLE)_beginthread(GKDiscovery, 0, 0); SPIDER_TRACE(SP_THREAD, "_beginthread(GKDiscovery, 0, 0); <%X>\n", hThread); if (hThread == (HANDLE)-1) { SPIDER_TRACE(SP_NEWDEL, "del g_pReg = %X\n", g_pReg); delete g_pReg; g_pReg = 0; return (GKI_NO_THREAD); } g_pReg->SetDiscThread(hThread);
return (GKI_OK); }#else
ASSERT(pDestAddr);#endif
// Connect to destination gatekeeper and retrieve RAS port
if ((nRet = g_pReg->m_pSocket->Connect(pDestAddr)) != 0) { SPIDER_TRACE(SP_NEWDEL, "del g_pReg = %X\n", g_pReg); delete g_pReg; g_pReg = 0; return (GKI_WINSOCK2_ERROR(nRet)); }
// Create RegistrationRequest structure - Encode and send PDU
if ((hResult = g_pReg->RegistrationRequest(FALSE)) != GKI_OK) { SPIDER_TRACE(SP_NEWDEL, "del g_pReg = %X\n", g_pReg); delete g_pReg; g_pReg = 0; return (hResult); }
// Post a receive on this socket
hThread = (HANDLE)_beginthread(PostReceive, 0, 0); SPIDER_TRACE(SP_THREAD, "_beginthread(PostReceive, 0, 0); <%X>\n", hThread); if (hThread == (HANDLE)-1) { SPIDER_TRACE(SP_NEWDEL, "del g_pReg = %X\n", g_pReg); delete g_pReg; g_pReg = 0; return (GKI_NO_THREAD); } g_pReg->SetRcvThread(hThread);
return (GKI_OK);}
|
