rvmegacoterm.c

h.248协议源码

	if(commReply_==NULL) {
		rvMegacoTerminationIdDestruct(&id);
		rvMegacoCommandReplyDestruct(&dummyReply);
	}

}


void rvMegacoTermProcessAuditValue(RvMegacoTerm * x,const RvMegacoAuditDescriptor * auditDescr,RvMegacoCommandReply * commReply) {
	RvMegacoAuditItems items = rvMegacoAuditDescriptorGetRequestedInfo(auditDescr);
	RvMegacoStatisticsDescriptor * stats;
	RvMegacoSignalsDescriptor * signalsDescr;

	if( items & RV_MEGACOAUDITITEMS_MEDIA) {
		rvMegacoCommandReplySetMedia(commReply,&x->mediaDescr);
	}
	if( items & RV_MEGACOAUDITITEMS_SIGNALS) {
		RvListIter(RvMegacoCurSignal) i;
		RvListIter(RvMegacoCurSignalList) j;
		RvMegacoCurSignal* curSignal;
		RvMegacoCurSignalList* curList;

		signalsDescr = (RvMegacoSignalsDescriptor*)rvMegacoCommandReplyGetSignals(commReply);
		for(i=rvListBegin(&x->curSignals);i!=rvListEnd(&x->curSignals);i=rvListIterNext(i)) {
			curSignal = rvListIterData(i);
			rvMegacoSignalsDescriptorAddSignal(signalsDescr,&curSignal->signal);
		}
		for(j=rvListBegin(&x->curSignalLists);j!=rvListEnd(&x->curSignalLists);j=rvListIterNext(j)) {
			curList = rvListIterData(j);
			rvMegacoSignalsDescriptorAddSignalList(signalsDescr,&curList->list);
		}
	}
	if( items & RV_MEGACOAUDITITEMS_EVENTBUFFER) {
		rvMegacoCommandReplySetEventBuffer(commReply,&x->eventBufferDescr);
	}
	if( items & RV_MEGACOAUDITITEMS_DIGITMAP) {
		RvMegacoDigitMapDescriptor dmDescr;
		/* TODO: Does it needs a name ?*/
		if(x->digitMapActive) {
			rvMegacoDigitMapDescriptorConstructA(&dmDescr,"",&x->digitMap,x->alloc);
			rvMegacoCommandReplySetDigitMap(commReply,&dmDescr);
			rvMegacoDigitMapDescriptorDestruct(&dmDescr);
		}
	}
	if( items & RV_MEGACOAUDITITEMS_STATS) {
		stats = (RvMegacoStatisticsDescriptor *)rvMegacoCommandReplyGetStatistics(commReply);
		rvMdmTermGetStats_(&x->mdmTerm,stats);
	}
	if( items & RV_MEGACOAUDITITEMS_EVENTS) {
		/*  Return active events */
		rvMegacoCommandReplySetEvents(commReply,&x->eventsDescr);
	}
	if( items & RV_MEGACOAUDITITEMS_OBSERVEDEVENTS) {
		if(x->digitMapActive) {
			/* Insert a digit map completion event */
			rvMegTermEventPushAuditDMEventCompletion(x);
		}
		rvMegacoCommandReplySetObservedEvents(commReply,&x->obsEventsDescr);

		if(x->digitMapActive) {
			/* Remove the digit map completion event */
			rvMegTermEventPopAuditDMEventCompletion(x);
		}
	}
	if( items & RV_MEGACOAUDITITEMS_PACKAGES) {
		rvMegacoCommandReplySetPackages(commReply,rvMdmTermGetPackages_(&x->mdmTerm));
	}

}

/* By now implement only packages, seems to make the most sense */
void rvMegacoTermProcessAuditValueWild(RvMegacoTerm * x,const RvMegacoAuditDescriptor * auditDescr,RvMegacoCommandReply * commReply) {
	RvMegacoAuditItems items = rvMegacoAuditDescriptorGetRequestedInfo(auditDescr);

	if( items & RV_MEGACOAUDITITEMS_PACKAGES) {
		RvMegacoPackagesDescriptor* replyPkgs = (RvMegacoPackagesDescriptor*)rvMegacoCommandReplyGetPackages(commReply);
		RvMegacoPackagesDescriptor* termPkgs  = rvMdmTermGetPackages_(rvMegacoTermGetMdmTerm(x));
		unsigned int i,j;
		unsigned int termPkgNum = rvMegacoPackagesDescriptorGetNumPackages(termPkgs);
		unsigned int replyPkgNum = rvMegacoPackagesDescriptorGetNumPackages(replyPkgs);
		const char *tPkg,*rPkg;
		unsigned int tVers,rVers;

		for(i=0;i<termPkgNum;i++) {
			tPkg = rvMegacoPackagesDescriptorGetPackageName(termPkgs,i);
			tVers = rvMegacoPackagesDescriptorGetPackageVersion(termPkgs,i);
			for(j=0;j<replyPkgNum;j++) {
				rPkg = rvMegacoPackagesDescriptorGetPackageName(replyPkgs,i);
				rVers = rvMegacoPackagesDescriptorGetPackageVersion(replyPkgs,i);					
				/* Found the package */
				if(!rvStrIcmp(tPkg,rPkg) && rVers==tVers)
					break;
			}
			if(j==replyPkgNum) /* Package was not found, add it */
				rvMegacoPackagesDescriptorAddPackage(replyPkgs,tPkg,tVers);
		}		
	}

}


static RvBool rvElemInList(RvPtrVector* list,void* elem) {
	RvPtrVectorIter i;
	void * listElem;

	for(i=rvPtrVectorBegin(list);i!=rvPtrVectorEnd(list);i=rvPtrVectorIterNext(i)) {
		listElem = *rvPtrVectorIterData(i);
		if(listElem==elem)
			return rvTrue;
	}
	return rvFalse;
}

static void rvMergeLocalProperties(RvMegacoStreamDescriptor* target,const RvMegacoStreamDescriptor* source) {
	const RvMegacoParameterList* s = rvMegacoStreamDescriptorGetParameterList(source);
	RvMegacoParameterList* t = (RvMegacoParameterList*)rvMegacoStreamDescriptorGetParameterList(target);
	rvMegacoParameterListMerge(t,s);
}

/* Merge the current media capabilities with the ones already existing in the reply */
static void rvMergeMediaCaps(RvMdmTermClass * c,RvMegacoAuditItems items,RvMegacoCommandReply * commReply) {
	RvMegacoMediaDescriptor* mediaCaps,* replyMedia;
	unsigned int i,j;
	unsigned int numReplyStreams,numTermStreams;

	if( (items & RV_MEGACOAUDITITEMS_MEDIA) == 0 )
		return;

	mediaCaps = rvMdmTermClassGetMediaCapabilites_(c);
	replyMedia = (RvMegacoMediaDescriptor*)rvMegacoCommandReplyGetMedia(commReply);

	numReplyStreams=rvMegacoMediaDescriptorGetNumStreams(replyMedia);
	numTermStreams = rvMegacoMediaDescriptorGetNumStreams(mediaCaps);

	/* No capabilities registred */
	if(numTermStreams==0)
		return;

	/* Add the media fields to the media descriptor */
	if(numReplyStreams==0)
		/*rvMegacoMediaDescriptorCopy(replyMedia,mediaCaps);*/
		rvMegacoCommandReplySetMedia(commReply,mediaCaps);
	
	/* For each stream in reply - Add local,remote descriptor of the same stream in the mediaCaps */
	/* If there are more streams in the mediaCaps - add them to the reply */
	else { 
		RvMegacoStreamDescriptor* replyStream;
		const RvMegacoStreamDescriptor* capsStream;
		
		for(i=0;i<numReplyStreams;i++) {
			if(i=numTermStreams)
				break;
			replyStream = (RvMegacoStreamDescriptor*)rvMegacoMediaDescriptorGetStream(replyMedia,i);
			capsStream = rvMegacoMediaDescriptorGetStream(mediaCaps,i);
			for(j=0;j<rvMegacoStreamDescriptorGetNumLocalDescriptors(capsStream);j++) 
				rvMegacoStreamDescriptorAddLocalDescriptor(replyStream,
													   rvMegacoStreamDescriptorGetLocalDescriptor(capsStream,j));
			for(j=0;j<rvMegacoStreamDescriptorGetNumRemoteDescriptors(capsStream);j++) 
				rvMegacoStreamDescriptorAddRemoteDescriptor(replyStream,
													   rvMegacoStreamDescriptorGetRemoteDescriptor(capsStream,j));

			rvMergeLocalProperties(replyStream,capsStream);
		}
		for(;i<numTermStreams;i++) {
			rvMegacoMediaDescriptorAddStream(replyMedia,rvMegacoMediaDescriptorGetStream(mediaCaps,i));
		}			
	}
}

static void rvMergePkg(RvMegacoPackagesDescriptor* packages,RvMegacoAuditItems items,
					   RvMegacoCommandReply * commReply,
					   RvPtrVector* pkgs,RvMdmTermMgr* mdmMgr,RvAlloc* a) {
	unsigned int i;
	RvMdmPackage* pkgInfo;
	RvMegacoSignalsDescriptor* signals;
	RvMegacoStatisticsDescriptor * stats;
	RvMegacoEventsDescriptor* events;
	RvMegacoObservedEventsDescriptor* obsEvents;
	RvMegacoEventBufferDescriptor* eventBuf;
	RvMegacoTerminationStateDescriptor* termState;
	RvMdmError error;

	/* Loop over all supported packages and set the capabilities */
	for(i=0;i<rvMegacoPackagesDescriptorGetNumPackages(packages);i++) {
		RvString pkgStr;
		/* Get the package data */
		rvStringConstruct(&pkgStr,rvMegacoPackagesDescriptorGetPackageName(packages,i),a);
		if(pkgInfo= rvMdmTermMgrGetPkgInfo_(mdmMgr,&pkgStr,&error)) {
			/* If the package is already in the list, don't process again      */
			/* The list of packages can be null if audits only one termination */
			if(pkgs!=NULL) { 
				if(rvElemInList(pkgs,pkgInfo))
					continue;
				else
					rvPtrVectorPushBack(pkgs,pkgInfo);
			}

			if( items & RV_MEGACOAUDITITEMS_MEDIA) {
				RvMegacoMediaDescriptor* replyMedia = (RvMegacoMediaDescriptor*)rvMegacoCommandReplyGetMedia(commReply);
				/* Add package dependent information to the media capabilities */
				termState = (RvMegacoTerminationStateDescriptor*)rvMegacoMediaDescriptorGetTerminationState(replyMedia);
				rvMdmPackageAppendTermState_(pkgInfo,termState);
			}
			if( items & RV_MEGACOAUDITITEMS_SIGNALS) {
				/* Build the signals descriptor from all the supported packages */
				signals = (RvMegacoSignalsDescriptor*)rvMegacoCommandReplyGetSignals(commReply);
				rvMdmPackageAppendSignals_(pkgInfo,signals);				
			}		
			if( items & RV_MEGACOAUDITITEMS_EVENTBUFFER) {
				eventBuf = (RvMegacoEventBufferDescriptor*)rvMegacoCommandReplyGetEventBuffer(commReply);
				rvMdmPackageAppendEvents2_(pkgInfo,eventBuf);				
			}
			if( items & RV_MEGACOAUDITITEMS_EVENTS) {
				events = (RvMegacoEventsDescriptor*)rvMegacoCommandReplyGetEvents(commReply);
				rvMdmPackageAppendEvents1_(pkgInfo,events);								
			}
			if( items & RV_MEGACOAUDITITEMS_OBSERVEDEVENTS) {
				obsEvents =(RvMegacoObservedEventsDescriptor*)rvMegacoCommandReplyGetObservedEvents(commReply);
				rvMdmPackageAppendEvents3_(pkgInfo,obsEvents,a);								
			}
			if( items & RV_MEGACOAUDITITEMS_STATS) {
				stats = (RvMegacoStatisticsDescriptor *)rvMegacoCommandReplyGetStatistics(commReply);
				rvMdmPackageAppendStats_(pkgInfo,stats);				
			}		
		}
		rvStringDestruct(&pkgStr);
	}
}

/* For each termination: If the class is already in the list - do nothing
   Else - for each supported package not in the list - append
   For media - just append 
*/
void rvMegacoTermProcessAuditCapsWild(RvMegacoTerm * x,const RvMegacoAuditDescriptor * auditDescr,
									  RvMegacoCommandReply * commReply,RvPtrVector* pkgs,RvPtrVector* termClasses) {
	RvMegacoAuditItems items = rvMegacoAuditDescriptorGetRequestedInfo(auditDescr);
	RvMdmTermMgr * mdmMgr = x->context->termMgr->mdmTermMgr;
	RvMdmTerm* mdmTerm = rvMegacoTermGetMdmTerm(x);
	RvMdmTermClass * termClass = mdmTerm->termClass;
	RvMegacoPackagesDescriptor* packages = rvMdmTermClassGetPackages_(termClass);

	/* If this class is already in the list, do nothing */
	if(rvElemInList(termClasses,termClass))
		return;
	else /* Put in list */
		rvPtrVectorPushBack(termClasses,termClass);

	/* Add the media capabilities */
	rvMergeMediaCaps(termClass,items,commReply);

	/* Loop over all supported packages and set the capabilities */
	rvMergePkg(packages,items,commReply,pkgs,mdmMgr,x->alloc);

	if( items & RV_MEGACOAUDITITEMS_PACKAGES || items & RV_MEGACOAUDITITEMS_DIGITMAP ) {
		rvMegacoTermMgrUtilAddError(commReply,RV_MEGACOERROR_ILLEGAL_DESCR,
									"Descriptor not legal in this command",x->alloc);
	}
}

/* Special case: Audit term=* and context=NULL, audit all the classes
   Used to audit the ephemeral terminations capabilities 
   The argument is not a termination because it loops over all classes! */
void rvMegacoTermProcessAuditCapsWildAll(RvMdmTermMgr * mdmMgr,const RvMegacoAuditDescriptor * auditDescr,
										 RvMegacoCommandReply * commReply,RvPtrVector* pkgs,RvAlloc* a) {

	RvMdmTermClass * termClass;
	RvMdmTermClassIter ci = NULL;
	RvMegacoAuditItems items = rvMegacoAuditDescriptorGetRequestedInfo(auditDescr);
	RvMegacoPackagesDescriptor* packages;
	
	while((termClass=rvMdmTermMgrGetNextTermClass_(mdmMgr,&ci))!=NULL) {
		/* Add the media capabilities */
		rvMergeMediaCaps(termClass,items,commReply);

		packages = rvMdmTermClassGetPackages_(termClass);

		/* Loop over all supported packages and set the capabilities */
		rvMergePkg(packages,items,commReply,pkgs,mdmMgr,a);
	}

	if( items & RV_MEGACOAUDITITEMS_PACKAGES || items & RV_MEGACOAUDITITEMS_DIGITMAP ) {
		rvMegacoTermMgrUtilAddError(commReply,RV_MEGACOERROR_ILLEGAL_DESCR,
									"Descriptor not legal in this command",a);
	}
}

void rvMegacoTermProcessAuditCaps(RvMegacoTerm * x,const RvMegacoAuditDescriptor * auditDescr,RvMegacoCommandReply * commReply) {
	RvMegacoAuditItems items = rvMegacoAuditDescriptorGetRequestedInfo(auditDescr);
	RvMdmTermMgr * mdmMgr = x->context->termMgr->mdmTermMgr;
	RvMdmTerm* mdmTerm = rvMegacoTermGetMdmTerm(x);
	RvMdmTermClass * termClass = mdmTerm->termClass;
	RvMegacoPackagesDescriptor* packages = rvMdmTermClassGetPackages_(termClass);

	/* Add the media capabilities */
	rvMergeMediaCaps(termClass,items,commReply);

	/* Loop over all supported packages and set the capabilities */
	rvMergePkg(packages,items,commReply,NULL,mdmMgr,x->alloc);

	if( items & RV_MEGACOAUDITITEMS_PACKAGES || items & RV_MEGACOAUDITITEMS_DIGITMAP) {
		rvMegacoTermMgrUtilAddError(commReply,RV_MEGACOERROR_ILLEGAL_DESCR,
									"Descriptor not legal in this command",x->alloc);
	}
}

/* Send the error, either in the response or as Notify */
/* Errors are send in Notify normaly only when processing 
   embedded parameters */
void rvMegacoTermSendErrorMsg(RvMegacoTerm * x,RvMdmError* error,int code,const char* msg,RvMegacoCommandReply * commReply) {
	rvMegacoTermMgrUtilOverwriteError(error,code,msg);
	if(commReply)
		rvMegacoTermMgrUtilAddError(commReply,error->code,error->msg,x->alloc);
	else {
		RvMegacoErrorDescriptor errorDescr;
		rvMegacoErrorDescriptorConstructA(&errorDescr,error->code,error->msg,x->alloc);
		rvMegacoContextSendNotifyOrError(x->context,rvMegacoTermGetId(x),&x->obsEventsDescr,&errorDescr);		
		rvMegacoErrorDescriptorDestruct(&errorDescr);
	}
}

/* Call when starting to process a command and after, to set mutexes, etc*/
void rvMegacoTermProcessCommandStart(RvMegacoTerm * x) {
	/* Set the blocked event flag so events received while
	   processing messages can be queued */
	rvMutexLock(&x->blockedEventMutex);
	x->blockedEventState = rvTrue;
	rvMutexUnlock(&x->blockedEventMutex);