rvmegaco.syn

h.248协议源码

{
/******************************************************************************
Filename:    rvmegacoparse.c
Description: megaco parser
*******************************************************************************
                Copyright (c) 2000 RADVision Inc.
*******************************************************************************
NOTICE:
This document contains information that is proprietary to RADVision Inc.
No part of this publication may be reproduced in any form whatsoever without
written prior approval by RADVision Inc.

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

#include "rvmegacoobjects.h"

typedef struct
{
	void *ptr;
	void (*destruct)(void *);
	size_t size;
} RvDeleteInfo;

rvDeclareList(RvDeleteInfo)

typedef RvMegacoCommand* (*RvAmmConstructFunc)(RvMegacoCommand *, const RvMegacoTerminationId *, RvAlloc *);

}

[
parser name = megaco
parser file name = "rvmegacoparse.c"
header file name = "rvmegacoparse.h"
reentrant parser
~case sensitive
distinguish keywords { ALPHA + DIGIT + '_' }
pointer input
pointer type = const char *
extend pcb { 
	const RvMegacoParserHandlers *handlers;
	void *userData;
	RvAlloc *alloc;
	RvList(RvDeleteInfo) deleteInfo;
	RvMegacoTransaction *curTransaction;
	RvMegacoAction *curAction;
	RvMegacoCommand *curAmmCommand;
	RvMegacoTransactionReply *curTransactionReply;
	RvMegacoActionReply *curActionReply;
	RvMegacoCommandReply *curCommandReply;
	RvMegacoMediaDescriptor *curMedia;
	RvMegacoStreamDescriptor *curStream;
	RvMegacoEventBufferDescriptor *curEventBufferDescriptor;
	RvMegacoEvent *curEvent;
	RvMegacoTerminationStateDescriptor *curTerminationStateDescriptor;
	RvMegacoMuxDescriptor *curMuxDescriptor;
	RvMegacoEventsDescriptor *curEventsDescriptor;
	RvMegacoRequestedEvent *curRequestedEvent;
	RvMegacoEventsDescriptor *curEmbedEventsDescriptor;
	RvMegacoRequestedEvent *curEmbEvent;
	RvMegacoSignalsDescriptor *curSignalsDescriptor;
	RvMegacoSignalList *curSignalList;
	RvMegacoSignal *curSignal;
	RvMegacoObservedEventsDescriptor *curObservedEventsDescriptor;
	RvMegacoObservedEvent *curObservedEvent;
	RvMegacoModemDescriptor *curModem;
	RvMegacoDigitPosition *curDigitPositionRange;
	RvMegacoServiceChangeDescriptor *curServiceChangeDescriptor;
	RvMegacoPackagesDescriptor *curPackagesDescriptor;
	RvMegacoTopologyDescriptor *curTopologyDescriptor;
}
allow macros
]

{
#define SYNTAX_ERROR
#define rvStringReserveSize 64
static void parseSdpMessages(RvMegacoStreamDescriptor *stream, RvString *s, RvBool remote, megaco_pcb_type *pcb);

void rvMegacoCommandDestruct(RvMegacoCommand *x);
void rvMegacoAmmCommandSetAudit(RvMegacoCommand *x, const RvMegacoAuditDescriptor *audit);
void rvMegacoAmmCommandSetMedia(RvMegacoCommand *x, const RvMegacoMediaDescriptor *media);
void rvMegacoAmmCommandSetModem(RvMegacoCommand *x, const RvMegacoModemDescriptor *modem);
void rvMegacoAmmCommandSetMux(RvMegacoCommand *x, const RvMegacoMuxDescriptor *mux);
void rvMegacoAmmCommandSetEvents(RvMegacoCommand *x, const RvMegacoEventsDescriptor *events);
void rvMegacoAmmCommandSetSignals(RvMegacoCommand *x, const RvMegacoSignalsDescriptor *signals);
void rvMegacoAmmCommandSetDigitMap(RvMegacoCommand *x, const RvMegacoDigitMapDescriptor *digitMap);
void rvMegacoAmmCommandSetEventBuffer(RvMegacoCommand *x, const RvMegacoEventBufferDescriptor *eventBuffer);

#define RvDeleteInfoConstructCopy rvDefaultConstructCopy
#define RvDeleteInfoDestruct rvDefaultDestruct
#define RvDeleteInfoEqual(a, b) ((a)==(b))
rvDefineList(RvDeleteInfo)

static void rvDelete(megaco_pcb_type *pcb, void *x)
{
	RvListIter(RvDeleteInfo) iter;
	for(iter = rvListBegin(&pcb->deleteInfo); iter != rvListEnd(&pcb->deleteInfo); iter = rvListIterNext(iter))
	{
		const RvDeleteInfo *info = rvListIterData(iter);
		if(info->ptr == x)
		{
			(info->destruct)(info->ptr);
			rvAllocDeallocate(pcb->alloc, info->size, info->ptr);
			rvListErase(RvDeleteInfo)(&pcb->deleteInfo, iter);
			return;
		}
	}
}

static void rvDeleteAll(megaco_pcb_type *pcb)
{
	while(!rvListEmpty(&pcb->deleteInfo))
	{
		const RvDeleteInfo *info = rvListFront(&pcb->deleteInfo);
		(info->destruct)(info->ptr);
		rvAllocDeallocate(pcb->alloc, info->size, info->ptr);
		rvListPopFront(RvDeleteInfo)(&pcb->deleteInfo);
	}
}

#define rvWrap(T) \
static void T##DestructWrap(void *x) \
{ \
	T##Destruct((T *)x); \
} \
static T *rvNew##T(megaco_pcb_type *pcb) \
{ \
	RvDeleteInfo info; \
	info.ptr = rvAllocAllocate(pcb->alloc, sizeof(T)); \
	info.destruct = T##DestructWrap; \
	info.size = sizeof(T); \
	rvListPushFront(RvDeleteInfo)(&pcb->deleteInfo, &info); \
	return (T*)(info.ptr); \
}
#define rvNew(T) rvNew##T

#define RvIpV6Destruct rvIpV6Destruct
#define RvStringDestruct rvStringDestruct
#define RvStringListDestruct rvStringListDestruct
#define RvMegacoActionDestruct rvMegacoActionDestruct
#define RvMegacoActionReplyDestruct rvMegacoActionReplyDestruct
#define RvMegacoAuditDescriptorDestruct rvMegacoAuditDescriptorDestruct
#define RvMegacoCommandDestruct rvMegacoCommandDestruct
#define RvMegacoCommandReplyDestruct rvMegacoCommandReplyDestruct
#define RvMegacoContextIdDestruct rvMegacoContextIdDestruct
#define RvMegacoContextPropertiesDestruct rvMegacoContextPropertiesDestruct
#define RvMegacoDigitMapDestruct rvMegacoDigitMapDestruct
#define RvMegacoDigitMapDescriptorDestruct rvMegacoDigitMapDescriptorDestruct
#define RvMegacoDigitPositionDestruct rvMegacoDigitPositionDestruct
#define RvMegacoDigitStringDestruct rvMegacoDigitStringDestruct
#define RvMegacoEntityAddressDestruct rvMegacoEntityAddressDestruct
#define RvMegacoErrorDescriptorDestruct rvMegacoErrorDescriptorDestruct
#define RvMegacoEventDestruct rvMegacoEventDestruct
#define RvMegacoEventBufferDescriptorDestruct rvMegacoEventBufferDescriptorDestruct
#define RvMegacoEventsDescriptorDestruct rvMegacoEventsDescriptorDestruct
#define RvMegacoMediaDescriptorDestruct rvMegacoMediaDescriptorDestruct
#define RvMegacoModemDescriptorDestruct rvMegacoModemDescriptorDestruct
#define RvMegacoMuxDescriptorDestruct rvMegacoMuxDescriptorDestruct
#define RvMegacoObservedEventDestruct rvMegacoObservedEventDestruct
#define RvMegacoObservedEventsDescriptorDestruct rvMegacoObservedEventsDescriptorDestruct
#define RvMegacoPackageItemDestruct rvMegacoPackageItemDestruct
#define RvMegacoPackagesDescriptorDestruct rvMegacoPackagesDescriptorDestruct
#define RvMegacoParameterDestruct rvMegacoParameterDestruct
#define RvMegacoParameterValueDestruct rvMegacoParameterValueDestruct
#define RvMegacoRequestedEventDestruct rvMegacoRequestedEventDestruct
#define RvMegacoServiceChangeDescriptorDestruct rvMegacoServiceChangeDescriptorDestruct
#define RvMegacoSignalDestruct rvMegacoSignalDestruct
#define RvMegacoSignalListDestruct rvMegacoSignalListDestruct
#define RvMegacoSignalsDescriptorDestruct rvMegacoSignalsDescriptorDestruct
#define RvMegacoStatisticsDescriptorDestruct rvMegacoStatisticsDescriptorDestruct
#define RvMegacoStreamDescriptorDestruct rvMegacoStreamDescriptorDestruct
#define RvMegacoTerminationIdDestruct rvMegacoTerminationIdDestruct
#define RvMegacoTerminationStateDescriptorDestruct rvMegacoTerminationStateDescriptorDestruct
#define RvMegacoTopologyDescriptorDestruct rvMegacoTopologyDescriptorDestruct
#define RvMegacoTransactionDestruct rvMegacoTransactionDestruct
#define RvMegacoTransactionReplyDestruct rvMegacoTransactionReplyDestruct
#define RvTimeStampDestruct rvTimeStampDestruct

rvWrap(RvString)
rvWrap(RvStringList)
rvWrap(RvMegacoAction)
rvWrap(RvMegacoActionReply)
rvWrap(RvMegacoAuditDescriptor)
rvWrap(RvMegacoCommand)
rvWrap(RvMegacoCommandReply)
rvWrap(RvMegacoContextId)
rvWrap(RvMegacoContextProperties)
rvWrap(RvMegacoDigitMap)
rvWrap(RvMegacoDigitMapDescriptor)
rvWrap(RvMegacoDigitPosition)
rvWrap(RvMegacoDigitString)
rvWrap(RvMegacoEntityAddress)
rvWrap(RvMegacoErrorDescriptor)
rvWrap(RvMegacoEvent)
rvWrap(RvMegacoEventBufferDescriptor)
rvWrap(RvMegacoEventsDescriptor)
rvWrap(RvMegacoMediaDescriptor)
rvWrap(RvMegacoModemDescriptor)
rvWrap(RvMegacoMuxDescriptor)
rvWrap(RvMegacoObservedEvent)
rvWrap(RvMegacoObservedEventsDescriptor)
rvWrap(RvMegacoPackageItem)
rvWrap(RvMegacoPackagesDescriptor)
rvWrap(RvMegacoParameter)
rvWrap(RvMegacoParameterValue)
rvWrap(RvMegacoRequestedEvent)
rvWrap(RvMegacoServiceChangeDescriptor)
rvWrap(RvMegacoSignal)
rvWrap(RvMegacoSignalList)
rvWrap(RvMegacoSignalsDescriptor)
rvWrap(RvMegacoStatisticsDescriptor)
rvWrap(RvMegacoStreamDescriptor)
rvWrap(RvMegacoTerminationId)
rvWrap(RvMegacoTerminationStateDescriptor)
rvWrap(RvMegacoTopologyDescriptor)
rvWrap(RvMegacoTransaction)
rvWrap(RvMegacoTransactionReply)
rvWrap(RvTimeStamp)

}


eof = 0

(void)
megacoMessage $
	-> LWSP, messageHeader, messageBody, eof

// The version of the protocol defined here is equal to 1.
(void)
messageHeader
	-> MegacopToken, SLASH, Version:v, SEP, mId:sender, SEP =
	{
		if(PCB.handlers->processMessageHeader != NULL &&
			PCB.handlers->processMessageHeader(sender, v, PCB.userData) == rvFalse)
		{			
			PCB.exit_flag = AG_SEMANTIC_ERROR_CODE;
			PCB.error_message = "invalid entity";
		}
		rvDelete(&PCB, sender);
	}

(void)
messageBody
	-> errorDescriptor:e =
	{
		if(PCB.handlers->processErrorTransaction != NULL)
			PCB.handlers->processErrorTransaction(e, PCB.userData);
		rvDelete(&PCB, e);
	}
	-> transaction...

(void)
transaction
	-> transactionRequest
	-> transactionReply
	-> transactionPending
	-> transactionResponseAck

(void)
transactionPending
	-> PendingToken, EQUAL, integer:transId, LWSP, LBRKT, RBRKT = 
	{ 
		if(PCB.handlers->processPending != NULL)
			PCB.handlers->processPending(transId, PCB.userData);
	}

(void)
transactionResponseAck
	-> ResponseAckToken, LWSP, LBRKT, transactionAck, [COMMA, transactionAck]..., RBRKT

(void)
transactionAck
	-> integer:id, LWSP = 
	{ 
		if(PCB.handlers->processResponseAck != NULL)
			PCB.handlers->processResponseAck(id, id, PCB.userData);
	}
	-> integer:lo, '-', integer:hi, LWSP = 
	{
		if(lo > hi)
		{
			PCB.exit_flag = AG_SEMANTIC_ERROR_CODE;
			PCB.error_message = "Bad transaction ack range";
			return;
		}
		if(PCB.handlers->processResponseAck != NULL)
			PCB.handlers->processResponseAck(lo, hi, PCB.userData);
	}

(void)
transactionRequest
	-> transactionRequestBlank:t, LBRKT, actionRequest, [COMMA, actionRequest]..., RBRKT =
	{
		if(PCB.handlers->processRequest != NULL)
			PCB.handlers->processRequest(t, PCB.userData);
		rvDelete(&PCB, t);
	}

(RvMegacoTransaction *)
transactionRequestBlank
	-> TransToken, EQUAL, integer:transId, LWSP =
	{
		PCB.curTransaction = rvNew(RvMegacoTransaction)(&PCB);
		return rvMegacoTransactionConstructEx(PCB.curTransaction, transId, PCB.alloc);
	}

(void)
actionRequest
	-> actionRequestBlank:a, LBRKT, actionRequestItems:props, RBRKT =
	{
		if(props != NULL)
		{
			rvMegacoActionSetContextProperties(a, props);
			rvDelete(&PCB, props);
		}
		rvMegacoTransactionAddAction(PCB.curTransaction, a);
		rvDelete(&PCB, a);
	}

(RvMegacoAction *)
actionRequestBlank
	-> CtxToken, EQUAL, ContextID:id, LWSP =
	{
		PCB.curAction = rvNew(RvMegacoAction)(&PCB);
		rvMegacoActionConstructA(PCB.curAction, id, PCB.alloc);
		rvDelete(&PCB, id);
		return PCB.curAction;
	}

(RvMegacoContextProperties *)
actionRequestItems
	-> contextProperties:p = p;
	-> contextProperties:p, COMMA, contextAudit = p;
	-> contextProperties:p, COMMA, commandRequestList = p;
	-> contextProperties:p, COMMA, contextAudit, COMMA, commandRequestList = p;
	-> contextAudit = NULL;
	-> commandRequestList = NULL;
	-> contextAudit, COMMA, commandRequestList = NULL;

(RvMegacoContextProperties *)
contextProperties
	-> topologyDescriptor:t =
	{
		RvMegacoContextProperties *x = rvNew(RvMegacoContextProperties)(&PCB);
		rvMegacoContextPropertiesConstructA(x, PCB.alloc);
		rvMegacoContextPropertiesSetTopology(x, t);
		rvDelete(&PCB, t);
		return x;
	}
	-> priority:p =
	{
		RvMegacoContextProperties *x = rvNew(RvMegacoContextProperties)(&PCB);
		rvMegacoContextPropertiesConstructA(x, PCB.alloc);
		rvMegacoContextPropertiesSetPriority(x, p);
		return x;
	}
	-> EmergencyToken, LWSP =
	{
		RvMegacoContextProperties *x = rvNew(RvMegacoContextProperties)(&PCB);
		rvMegacoContextPropertiesConstructA(x, PCB.alloc);
		rvMegacoContextPropertiesSetEmergencyFlag(x, rvTrue);
		return x;
	}
	-> contextProperties:x, COMMA, topologyDescriptor:t =
	{
		rvMegacoContextPropertiesSetTopology(x, t);
		rvDelete(&PCB, t);
		return x;
	}
	-> contextProperties:x, COMMA, priority:p = { rvMegacoContextPropertiesSetPriority(x, p); return x; }
	-> contextProperties:x, COMMA, EmergencyToken, LWSP = { rvMegacoContextPropertiesSetEmergencyFlag(x, rvTrue); return x; }

(void)
contextAudit
	-> ContextAuditToken, LWSP, LBRKT, contextAuditPropertiesList:a, RBRKT = { rvMegacoActionSetAudit(PCB.curAction, a); }

(RvMegacoContextAudit)
contextAuditPropertiesList
	-> contextAuditProperties:i = i;
	-> contextAuditPropertiesList:list, COMMA, contextAuditProperties:i = list | i;

(RvMegacoContextAudit)
contextAuditProperties
	-> TopologyToken, LWSP = RV_MEGACOCONTEXTAUDIT_TOPOLOGY;
	-> EmergencyToken, LWSP = RV_MEGACOCONTEXTAUDIT_EMERGENCY;
	-> PriorityToken, LWSP = RV_MEGACOCONTEXTAUDIT_PRIORITY;

(void)
commandRequestList
	-> command, [COMMA, command]...

(void)
command   /* wild response now allowed on all commands - see implementor's guide */
	-> commandOptionalFlag:opt, wildResponseFlag:wild, commandRequest:cmd =
	{
		rvMegacoCommandSetOptionalFlag(cmd, opt);
		rvMegacoCommandSetWildResponseFlag(cmd, wild);
		rvMegacoActionAddCommand(PCB.curAction, cmd);
		rvDelete(&PCB, cmd);
	}

(RvBool)
commandOptionalFlag
	-> = rvFalse;
	-> "O-" = rvTrue;

(RvBool)
wildResponseFlag
	-> = rvFalse;
	-> "W-" = rvTrue;

(RvMegacoCommand *)
commandRequest
	-> ammRequest:cmd = cmd;
	-> subtractRequest:cmd = cmd;
	-> auditRequest:cmd = cmd;
	-> notifyRequest:cmd = cmd;
	-> serviceChangeRequest:cmd = cmd;

(void)
transactionReply
	-> transactionReplyBlank:r, LBRKT, isImmAckRequired, transactionReplyMeat, RBRKT =
	{
		if(PCB.handlers->processReply != NULL)
			PCB.handlers->processReply(r, PCB.userData);
		rvDelete(&PCB, r);
	}

(RvMegacoTransactionReply *)
transactionReplyBlank
	-> ReplyToken, EQUAL, integer:id, LWSP =