rvmegacogateway.c

h.248协议源码

/******************************************************************************
Filename:    rvmegacogateway.c
Description: sample gateway class
*******************************************************************************
                Copyright (c) 2001 RADVision Inc.
*******************************************************************************
NOTICE:
This document contains information that is proprietary to RADVision LTD.
No part of this publication may be reproduced in any form whatsoever 
without written prior approval by RADVision LTD.

RADVision LTD. reserves the right to revise this publication and make 
changes without obligation to notify any person of such revisions or 
changes.
******************************************************************************/

#include "rvmegacogateway.h"
#include "rvphysterm.h"
#include "rvphonelink.h"
#include <stdio.h> /* for sprintf */

static RvMdmTerm *rvMegacoGatewaySelectTermination(RvMdmTermMgr *mgr, RvMdmTerm *tempTerm)
{
	/* assume for now that unknown ones are ephemeral */
	/* later we will need a way to determine type */
	if(rvMdmTermGetType(tempTerm) == RV_MDMTERMTYPE_EPHEMERAL ||
		rvMdmTermGetType(tempTerm) == RV_MDMTERMTYPE_UNKNOWN)
	{
		RvMegacoGateway *gw = (RvMegacoGateway *)rvMdmTermMgrGetUserData(mgr);
		RvRtpLink *rtpLink = (RvRtpLink *)rvAllocAllocate(&rvDefaultAlloc, sizeof(RvRtpLink));
		static int termNum = 1;
		char termName[16];
		RvMdmTerm *termination;

		sprintf(termName, "rtp/%d", termNum++);
		termination = rvMdmTermMgrRegisterEphemeralTermination(mgr, gw->rtpClass, termName, NULL);
		rvRtpLinkConstruct(rtpLink, &gw->engine);
		rvMdmTermSetUserData(termination, rtpLink);
		return termination;
	}
	return NULL;
}

static void rvMegacoGatewayDeleteEphTerm(RvMdmTermMgr *mgr, RvMdmTerm *ephTerm)
{
	RvRtpLink *rtpLink = (RvRtpLink *)rvMdmTermGetUserData(ephTerm);
	rvRtpLinkDestruct(rtpLink);
	rvAllocDeallocate(&rvDefaultAlloc, sizeof(RvRtpLink), rtpLink);		
}

static RvRtpLink *getRtpLink(RvMdmTerm *termination, RvMdmMediaStream *media)
{
	return rvMdmTermGetType(termination) == RV_MDMTERMTYPE_EPHEMERAL ?
		(RvRtpLink *)rvMdmTermGetUserData(termination) :
		((RvPhysTermData *)rvMdmTermGetClassData(termination))->getRtpLink(media);
}

static RvBool rvMegacoGatewayConnect(RvMdmTermMgr *mgr,
	RvMdmTerm *source, RvMdmMediaStream *m1, RvMdmTerm *target, RvMdmMediaStream *m2,
	RvMdmStreamDirection direction, RvMdmError *mdmError)
{
	rvRtpLinkConnect(getRtpLink(source, m1), getRtpLink(target, m2), direction);
	return rvTrue;
}

static RvBool rvMegacoGatewayDisconnect(RvMdmTermMgr *mgr,
	RvMdmTerm *source, RvMdmMediaStream *m1, RvMdmTerm *target, RvMdmMediaStream *m2,
	RvMdmError *mdmError)
{
	rvRtpLinkDisconnect(getRtpLink(source, m1), getRtpLink(target, m2));
	return rvTrue;
}

static RvBool rvMegacoGatewayOnRequestOffHook(RvMdmTerm *termination, 
	const char *pkg, const char *name, RvMdmMediaStream *mediaStream,
	const RvMdmParameterList *parameters, RvMdmError *errorInfo)
{
	return ((RvPhysTermData *)rvMdmTermGetClassData(termination))->
		onRequestOffHook(termination, pkg, name, mediaStream, parameters, errorInfo);
}

static RvBool rvMegacoGatewayOnRequestOnHook(RvMdmTerm *termination, 
	const char *pkg, const char *name, RvMdmMediaStream *mediaStream,
	const RvMdmParameterList *parameters, RvMdmError *errorInfo)
{
	return ((RvPhysTermData *)rvMdmTermGetClassData(termination))->
		onRequestOnHook(termination, pkg, name, mediaStream, parameters, errorInfo);
}

RvMegacoGateway *rvMegacoGatewayConstruct(RvMegacoGateway *gw,
	const char *mgName, RvTransportType transportType, RvMegacoEntityAddress *mgc, int startMdmDelay)
{
	const size_t numThreads = 1;

	RvMegacoEntityAddress mgAddr;
	RvPriority rtpPriority;

	rvMegacoStackConstruct(&gw->stack, numThreads, RV_PRIORITYVALUE_NORMAL);

#ifdef RV_PERFORMANCETEST_ON
	rvMegacoStackSetSendDelay(&gw->stack, 1);
#else
	rvMegacoStackSetCompactEncodingMode(&gw->stack, rvFalse);
#endif

	rvMegacoEntityAddressConstruct(&mgAddr, mgName, 0);
	rvMegacoEntityConstructLocal(&gw->mg, &mgAddr, rvTrue, RV_MEGACOENTITYTYPE_MG,
		transportType, RV_MEGACOENCODING_TEXT, &gw->stack);
	rvMegacoEntityAddressDestruct(&mgAddr);

	rvMdmTermMgrConstructMegaco(&gw->termMgr, &gw->mg, mgc, &gw->stack);
	rvMdmTermMgrSetUserData(&gw->termMgr, gw);
	rvMdmTermMgrRegisterSelectTermCB(&gw->termMgr, rvMegacoGatewaySelectTermination);
	rvMdmTermMgrRegisterDeleteEphTermCB(&gw->termMgr, rvMegacoGatewayDeleteEphTerm);
	rvMdmTermMgrRegisterConnectCB(&gw->termMgr, rvMegacoGatewayConnect);
	rvMdmTermMgrRegisterDisconnectCB(&gw->termMgr, rvMegacoGatewayDisconnect);

	rvMdmPackageRegisterEventParametersCB(rvMdmTermMgrGetPackage(&gw->termMgr, "al"),
		"of", rvMegacoGatewayOnRequestOffHook); 
	rvMdmPackageRegisterEventParametersCB(rvMdmTermMgrGetPackage(&gw->termMgr, "al"),
		"on", rvMegacoGatewayOnRequestOnHook); 

	rvRtpLinkInitTermClass(gw->rtpClass = rvMdmTermMgrCreateTermClass(&gw->termMgr));

	rvPriorityConstruct(&rtpPriority, RV_PRIORITYCLASS_LOW, RV_PRIORITYVALUE_NORMAL);
	rtpEngineConstruct(&gw->engine, rtpPriority);
	rvPriorityDestruct(&rtpPriority);

	/* register root termination */
	gw->rootClass = rvMdmTermMgrCreateTermClass(&gw->termMgr);
	rvMdmTermMgrSetRootTermination(&gw->termMgr, gw->rootClass, NULL);

	rvPhoneMgrConstruct(&gw->phoneMgr, &gw->termMgr, &gw->engine);
	gw->phoneSimOn = rvFalse;

	gw->startMdmDelay = startMdmDelay;

	rvMegacoSystemRegisterStack(&gw->stack);
	
	return gw;
}

void rvMegacoGatewayDestruct(RvMegacoGateway *gw)
{
	RvMdmServiceChange sc;

	rvMdmServiceChangeConstruct(&sc);
	rvMdmServiceChangeSetReason(&sc, RV_MDMSERVICECHANGEREASON_MGFAILURE);
	rvMdmTermMgrStop(&gw->termMgr, &sc);
	rvMdmServiceChangeDestruct(&sc);

	rvPhoneMgrDestruct(&gw->phoneMgr);
	if(gw->phoneSimOn)
		rvPhoneSimDestruct(&gw->phoneSim);
	
	rvMdmTermMgrDestruct(&gw->termMgr);
	rtpEngineDestruct(&gw->engine);

	rvMegacoEntityDestruct(&gw->mg);
	rvMegacoSystemUnregisterStack(&gw->stack);
	rvMegacoStackDestruct(&gw->stack);
}

void rvMegacoGatewayAddRemote(RvMegacoGateway* gw, RvMegacoEntityAddress* mgc)
{
	rvMdmTermMgrMegacoMgcAddrListAdd(&gw->termMgr, mgc);
}

void rvMegacoGatewayStart(RvMegacoGateway* gw)
{
	RvMdmServiceChange sc;

	rvMdmServiceChangeConstruct(&sc);
	rvMdmServiceChangeSetReason(&sc, RV_MDMSERVICECHANGEREASON_COLDBOOT);

	rvMdmTermMgrStart(&gw->termMgr, &sc, gw->startMdmDelay*1000);

	rvMdmServiceChangeDestruct(&sc);
}

void rvMegacoGatewayStartSim(RvMegacoGateway* gw, const char *prefix, int numTerms)
{
	rvMegacoGatewayStart(gw);
	rvPhoneSimConstruct(&gw->phoneSim, &gw->termMgr, &gw->engine, prefix, numTerms);
	gw->phoneSimOn = rvTrue;
}