rvmdm.c

h.248协议源码

	rvMdmRegisterEvent(pkg,"of");
	rvMdmRegisterEvent(pkg,"on");
	rvMdmRegisterEvent(pkg,"fl");

	rvMdmRegisterSignal(pkg,"ri",180000); 

	rvMegacoParameterValueConstruct(&param, "exact");
	rvMegacoParameterValueOr(&param, "state");
	rvMegacoParameterValueOr(&param, "failWrong");
	rvMdmPackageRegisterLocalControlProperty(pkg, "strict", &param);

	rvMegacoParameterValueConstruct(&param, "True");
	rvMegacoParameterValueOr(&param, "False");
	rvMdmPackageRegisterLocalControlProperty(pkg, "init", &param);

	rvMegacoParameterValueConstruct(&param, "");
	rvMdmPackageRegisterLocalControlProperty(pkg, "mindur", &param);
	rvMdmPackageRegisterLocalControlProperty(pkg, "maxdur", &param);
	rvMdmPackageRegisterLocalControlProperty(pkg, "cad", &param);
	rvMdmPackageRegisterLocalControlProperty(pkg, "freq", &param);

	/* Register package dd */
	/*---------------------*/
	pkg = rvMdmTermMgrCreatePackage(mgr,"dd");

	rvMdmRegisterEvent(pkg,"d0");
	rvMdmRegisterEvent(pkg,"d1");
	rvMdmRegisterEvent(pkg,"d2");
	rvMdmRegisterEvent(pkg,"d3");
	rvMdmRegisterEvent(pkg,"d4");
	rvMdmRegisterEvent(pkg,"d5");
	rvMdmRegisterEvent(pkg,"d6");
	rvMdmRegisterEvent(pkg,"d7");
	rvMdmRegisterEvent(pkg,"d8");
	rvMdmRegisterEvent(pkg,"d9");
	rvMdmRegisterEvent(pkg,"da");
	rvMdmRegisterEvent(pkg,"db");
	rvMdmRegisterEvent(pkg,"dc");
	rvMdmRegisterEvent(pkg,"dd");
	rvMdmRegisterEvent(pkg,"ds");
	rvMdmRegisterEvent(pkg,"do");
	rvMdmRegisterEvent(pkg,"ce");

	/* For this package also register digitmap data */
	rvMdmDigitMapDataConstruct(&dmData,"ce",
							   rvMegacoDigitMapBuildDDEvComplete,
							   rvMegacoDigitMapTranslateDDEvent,
							   mgr->a);
	rvMdmPackageRegisterDigitMapData(pkg,&dmData);
	rvMdmDigitMapDataDestruct(&dmData);

	/* Register package dg */
	/*---------------------*/
	pkg = rvMdmTermMgrCreatePackage(mgr,"dg");
	rvMdmRegisterSignal(pkg,"d0",-1);
	rvMdmRegisterSignal(pkg,"d1",-1);
	rvMdmRegisterSignal(pkg,"d2",-1);
	rvMdmRegisterSignal(pkg,"d3",-1);
	rvMdmRegisterSignal(pkg,"d4",-1);
	rvMdmRegisterSignal(pkg,"d5",-1);
	rvMdmRegisterSignal(pkg,"d6",-1);
	rvMdmRegisterSignal(pkg,"d7",-1);
	rvMdmRegisterSignal(pkg,"d8",-1);
	rvMdmRegisterSignal(pkg,"d9",-1);
	rvMdmRegisterSignal(pkg,"da",-1);
	rvMdmRegisterSignal(pkg,"db",-1);
	rvMdmRegisterSignal(pkg,"dc",-1);
	rvMdmRegisterSignal(pkg,"dd",-1);
	rvMdmRegisterSignal(pkg,"ds",-1);
	rvMdmRegisterSignal(pkg,"do",-1);

	/* Register package cg */
	/*---------------------*/
	pkg = rvMdmTermMgrCreatePackage(mgr,"cg");
	rvMdmRegisterSignal(pkg,"bt",30000); 
	rvMdmRegisterSignal(pkg,"wt",180000);
	rvMdmRegisterSignal(pkg,"rt",180000);
	rvMdmRegisterSignal(pkg,"dt",16000); 
	rvMdmRegisterSignal(pkg,"ct",30000); 
	rvMdmRegisterSignal(pkg,"sit",180000);
	rvMdmRegisterSignal(pkg,"pt",180000);
	rvMdmRegisterSignal(pkg,"cw",300+85+250); 
	rvMdmRegisterSignal(pkg,"cr",180000);

	/* Register package ct */
	/*---------------------*/
	pkg = rvMdmTermMgrCreatePackage(mgr,"ct");

	rvMdmRegisterSignal(pkg,"ct",180000);
	rvMdmRegisterSignal(pkg,"rsp",180000);

	rvMegacoParameterValueConstruct(&param, "success");
	rvMegacoParameterValueOr(&param, "failure");
	rvMdmPackageRegisterLocalControlProperty(pkg, "res", &param);

	/* Register package tonedet */
	/*--------------------------*/
	pkg = rvMdmTermMgrCreatePackage(mgr,"tonedet");
	rvMdmRegisterEvent(pkg,"std");
	rvMdmRegisterEvent(pkg,"etd");
	rvMdmRegisterEvent(pkg,"ltd");

	rvMegacoParameterValueConstruct(&param, "");
	rvMdmPackageRegisterLocalControlProperty(pkg, "tl", &param);
	rvMdmPackageRegisterLocalControlProperty(pkg, "dur", &param);
	rvMdmPackageRegisterLocalControlProperty(pkg, "tid", &param);

	/* Register package tonegen */
	/*--------------------------*/
	pkg = rvMdmTermMgrCreatePackage(mgr,"tonegen");
	
	rvMdmRegisterSignal(pkg,"pt",-1);

	rvMegacoParameterValueConstruct(&param, "");
	rvMdmPackageRegisterLocalControlProperty(pkg, "tl", &param);
	rvMdmPackageRegisterLocalControlProperty(pkg, "ind", &param);

	/* Register package nt */
	/*---------------------*/
	pkg = rvMdmTermMgrCreatePackage(mgr,"nt");

	rvMdmRegisterEvent(pkg,"netfail");
	rvMdmRegisterEvent(pkg,"qualert");
	rvMdmRegisterEvent(pkg,"cs");

	rvMdmPackageRegisterStatistic(pkg, "dur");
	rvMdmPackageRegisterStatistic(pkg, "os");
	rvMdmPackageRegisterStatistic(pkg, "or");

	rvMegacoParameterValueConstruct(&param, "");
	rvMdmPackageRegisterLocalControlProperty(pkg, "cs", &param);
	rvMdmPackageRegisterLocalControlProperty(pkg, "th", &param);

	rvMdmPackageRegisterLocalControlProperty(pkg, "jit", &param);

	/* Register package rtp */
	/*----------------------*/
	pkg = rvMdmTermMgrCreatePackage(mgr,"rtp");

	rvMdmRegisterEvent(pkg,"pltrans");

	rvMdmPackageRegisterStatistic(pkg, "ps");
	rvMdmPackageRegisterStatistic(pkg, "pr");
	rvMdmPackageRegisterStatistic(pkg, "pl");
	rvMdmPackageRegisterStatistic(pkg, "jit");

	rvMegacoParameterValueConstruct(&param, "");
	rvMdmPackageRegisterLocalControlProperty(pkg, "rtppltype", &param);

	/* Register package cd */
	/*---------------------*/
	pkg = rvMdmTermMgrCreatePackage(mgr,"cd");

	rvMdmRegisterEvent(pkg,"dt");
	rvMdmRegisterEvent(pkg,"rt");
	rvMdmRegisterEvent(pkg,"bt");
	rvMdmRegisterEvent(pkg,"ct");
	rvMdmRegisterEvent(pkg,"sit");
	rvMdmRegisterEvent(pkg,"wt");
	rvMdmRegisterEvent(pkg,"pt");
	rvMdmRegisterEvent(pkg,"cw");
	rvMdmRegisterEvent(pkg,"cr");
	
	/* Register package tdmc */
	/*---------------------*/
	pkg = rvMdmTermMgrCreatePackage(mgr,"tdmc");

	rvMegacoParameterValueConstruct(&param, "on");
	rvMegacoParameterValueOr(&param, "off");
	rvMdmPackageRegisterLocalControlProperty(pkg, "ec", &param);
	
	rvMegacoParameterValueConstruct(&param, "automatic");
	rvMdmPackageRegisterLocalControlProperty(pkg, "gain", &param);
	
	/* Register package base root */
	/*----------------------------*/
	pkg = rvMdmTermMgrCreatePackage(mgr,"root");

	/* Put an arbitrary value to avoid failing parsing with a wildcarding 
	   response (I'm not sure what the meaning shoud be...) */
	rvMegacoParameterValueConstruct(&param, "0");
	rvMdmPackageRegisterTermStateProperty(pkg, "maxNumberOfContexts", &param);
	rvMdmPackageRegisterTermStateProperty(pkg, "maxTerminationsPerContext", &param);
	rvMdmPackageRegisterTermStateProperty(pkg, "normalMGExecutionTime", &param);
	rvMdmPackageRegisterTermStateProperty(pkg, "normalMGCExecutionTime", &param);
	rvMdmPackageRegisterTermStateProperty(pkg, "ProvisionalResponseTimerValue", &param);
	 
	
}

void rvMdmTermMgrConstruct_(RvMdmTermMgr* mgr,RvAlloc * a) {
	mgr->a = a;
	rvMapConstruct(RvIString,RvMdmPackagePtr)(&mgr->packageData,a);
	rvPtrListConstruct(&mgr->termClassList,mgr->a);
	mgr->connectF = defaultTermMgrConnect;
	mgr->disconnectF = defaultTermMgrDisconnect;
	mgr->contextCreatedF = defaultContextCreated;
	mgr->contextDeletedF = defaultContextDeleted;
	rvPtrListConstruct(&mgr->digitMapData,a);
	mgr->maxContexts = 0xFFFFFFFF;
	mgr->maxTermPerContext = 0xFFFFFFFF;
	mgr->userData = NULL;

	rvMdmRegisterPackages(mgr);
}

/*$
{function:
	{name: rvMdmTermMgrConstructMegaco}
	{class: RvMdmTermMgr}
	{include: rvmdm.h}
	{description:
		{p: Constructs a termination manager that uses a Megaco stack.}
	}
	{proto: void rvMdmTermMgrConstructMegaco(RvMdmTermMgr* mgr,RvMegacoEntity* localEntity,RvMegacoEntityAddress* mgcAddr,void * XStack);}
	{params:
		{param: {n:mgr} {d:A pointer to termination manager object.}}
		{param: {n:localEntity} {d:A pointer to the entity object containing the address of the local entity.This pointer should be valid as long as the termination manager is running.}}
		{param: {n:mgcAddr} {d:A pointer to the entity object containing the address of the primary MGC.This pointer can go out of scope upon retruning from this function.}}
		{param: {n:XStack} {d:A pointer to a constructed Megaco stack.}}
	}

}
$*/
void rvMdmTermMgrConstructMegaco(RvMdmTermMgr* mgr,RvMegacoEntity* localEntity,RvMegacoEntityAddress* mgcAddr,void * XStack) {
	RvMegacoTermMgr * megacoMgr;
	RvMdmPackage* pkg;

	/* Base constructor */
	rvMdmTermMgrConstruct_(mgr,&rvDefaultAlloc);

	/* Should construct here the megaco termination manager, etc */
	megacoMgr = rvAllocAllocate(mgr->a,sizeof(RvMegacoTermMgr));
	rvMegacoTermMgrConstructA(megacoMgr,localEntity, mgr->a);
	rvMegacoTermMgrMgcAddrListAdd(megacoMgr,mgcAddr);

	rvMegacoTermMgrSetMdmMgr(megacoMgr,mgr);	
	mgr->xType = RV_MDMXTERMMGRTYPE_MEGACO;

	/* Register and build the default packages */
	pkg = rvMdmTermMgrCreatePackage(mgr,"g");
	rvMdmPackageBuildGenericPkg(pkg);
}

/*$
{function:
	{name: rvMdmTermMgrDestruct}
	{class: RvMdmTermMgr}
	{include: rvmdm.h}
	{description:
		{p: Destructs the termination manager and release all the memory.}
	}
	{proto: void rvMdmTermMgrDestruct(RvMdmTermMgr* mgr);}
	{params:
		{param: {n:mgr} {d:A pointer to termination manager object.}}
	}

}
$*/
void rvMdmTermMgrDestruct(RvMdmTermMgr* mgr)  {
	RvPtrListIter i;

	if(mgr->xType == RV_MDMXTERMMGRTYPE_MEGACO)
		rvMegacoTermMgrDestruct((RvMegacoTermMgr *)mgr->xTermMgr);

	/* Destruct all the term class objects */
	for(i=rvPtrListBegin(&mgr->termClassList);i!=rvPtrListEnd(&mgr->termClassList);i=rvPtrListIterNext(i)){
		RvMdmTermClass * termClass = rvPtrListIterData(i);
		rvMdmTermClassDestruct_(termClass);
		rvAllocDeallocate(mgr->a,sizeof(RvMdmTermClass),termClass);
	}
	rvPtrListDestruct(&mgr->termClassList);

	rvMapDestruct(&mgr->packageData);
	/* TODO : Free the list members ??? */
	rvPtrListDestruct(&mgr->digitMapData);

	rvAllocDeallocate(mgr->a,sizeof(RvMegacoTermMgr),mgr->xTermMgr);
}

/*$
{function:
	{name: rvMdmTermMgrSetMaxContexts}
	{class: RvMdmTermMgr}
	{include: rvmdm.h}
	{description:
		{p: Set the maximal number of simultaneous contexts supported by the MG.
		    (not counting the null context).}
	}
	{proto: void rvMdmTermMgrSetMaxContexts(RvMdmTermMgr* mgr,RvUint32 maxContexts);}
	{params:
		{param: {n:mgr} {d:A pointer to termination manager object.}}
		{param: {n:maxContexts} {d:the maximal number of contexts.}}
	}
	{notes:
		{note: 
			In Megaco, this is equivalent to setting the maxNumberOfContexts property 
			of the Base Root Package for the root termination.
		}
		{note: 
			If this function is not called, the number of contexts is not
			limited.
		}
	}
}
$*/
void rvMdmTermMgrSetMaxContexts(RvMdmTermMgr* mgr,RvUint32 maxContexts) {
	mgr->maxContexts = maxContexts;
}

/*$
{function:
	{name: rvMdmTermMgrSetMaxTermsPerContext}
	{class: RvMdmTermMgr}
	{include: rvmdm.h}
	{description:
		{p: Set the maximal number of terminations that can be present in a context.}
	}
	{proto: vvoid rvMdmTermMgrSetMaxTermsPerContext(RvMdmTermMgr* mgr,RvUint32 maxTermsPerContext);}
	{params:
		{param: {n:mgr} {d:A pointer to termination manager object.}}
		{param: {n:maxTermsPerContext} {d:the maximal number of termination in an active context.}}
	}
	{notes:
		{note: 
			In Megaco, this is equivalent to setting the MaxTerminationsPerContext property 
			of the Base Root Package for the root termination.
		}
		{note: 
			If this function is not called, the number of terminations per context is not
			limited.
		}
	}
}
$*/
void rvMdmTermMgrSetMaxTermsPerContext(RvMdmTermMgr* mgr,RvUint32 maxTermPerContext) {
	mgr->maxTermPerContext = maxTermPerContext;
}


/*$
{function:
	{name: rvMdmTermMgrStart}
	{class: RvMdmTermMgr}
	{include: rvmdm.h}
	{description:
		{p:After calling this function the termination manager will start processing
		   commands and events, and the MG will signal that is going up.}
	}
	{proto: void rvMdmTermMgrStart(RvMdmTermMgr* mgr,RvMdmServiceChange * sc);}
	{params:
		{param: {n:mgr} {d:A pointer to termination manager object.}}
		{param: {n:sc} {d:The service change parameters o NULL.}}
		{param: {n:delay} {d:The delay in milliseconds to wait before starting the MDM.}}
	}
	{notes:
		{note: 
			Usually called after registering the physical endpoints.
		}
		{note: 
			If sc is NULL default values will be used.
		}
	}
}
$*/
void rvMdmTermMgrStart(RvMdmTermMgr* mgr,RvMdmServiceChange * sc, int delay)  {
	mgr->xTermMgrClbks->startF(mgr->xTermMgr,sc, delay);
}

/*$
{function:
	{name: rvMdmTermMgrStop}
	{class: RvMdmTermMgr}
	{include: rvmdm.h}
	{description:
		{p:Calling this function will cause the MG to signal that is going down.}
	}
	{proto: void rvMdmTermMgrStop(RvMdmTermMgr* mgr,RvMdmServiceChange * sc);}
	{params:
		{param: {n:mgr} {d:A pointer to termination manager object.}}
		{param: {n:sc} {d:The service change parameters o NULL.}}
	}
	{notes:
		{note: 
			If sc is NULL default values will be used.
		}
	}
}
$*/
void rvMdmTermMgrStop(RvMdmTermMgr* mgr,RvMdmServiceChange * sc) {
	mgr->xTermMgrClbks->stopF(mgr->xTermMgr,sc);
}

/*$
{function:
	{name: rvMdmTermMgrClearTerminations}
	{class: RvMdmTermMgr}
	{include: rvmdm.h}
	{description:
		{p:Calling this function will unregister all the terminations and indicate that they
		   are going down.}
	}
	{proto: void rvMdmTermMgrClearTerminations(RvMdmTermMgr* mgr,RvMdmServiceChange * sc);}
	{params:
		{param: {n:mgr} {d:A pointer to termination manager object.}}
		{param: {n:sc} {d:The service change parameters o NULL.}}
	}
	{notes:
		{note: 
			If sc is NULL default values will be used.
		}
	}
}
$*/
void rvMdmTermMgrClearTerminations(RvMdmTermMgr* mgr,RvMdmServiceChange * sc) {
	mgr->xTermMgrClbks->clearTermF(mgr->xTermMgr,sc);
}

/*$
{function:
	{name: rvMdmTermMgrCreateTermClass}
	{class: RvMdmTermMgr}
	{include: rvmdm.h}
	{description:
		{p:Allocates and construct a ne