rvmegacoparse.c

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 *);


/*

 AnaGram Parsing Engine
 Copyright (c) 1993-2000, Parsifal Software.
 All Rights Reserved.

 Serial number 2P20945U
 Registered to:
   James Adragna
   RADVISION, INC.

*/

#ifndef RVMEGACO_H_1008194383
#include "rvmegacoparse.h"
#endif

#ifndef RVMEGACO_H_1008194383
#error Mismatched header file
#endif

#include <ctype.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#define RULE_CONTEXT (&((PCB).cs[(PCB).ssx]))
#define ERROR_CONTEXT ((PCB).cs[(PCB).error_frame_ssx])
#define CONTEXT ((PCB).cs[(PCB).ssx])


#ifndef PCB_TYPE
#define PCB_TYPE megaco_pcb_type
#endif


#define PCB (*pcb_pointer)
#define PCB_DECL PCB_TYPE *pcb_pointer
#define PCB_POINTER pcb_pointer

/*  Line 77, Y:/rv/megaco/common/parser/rvmegaco.syn */
#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)

/*  Line 1748, Y:/rv/megaco/common/parser/rvmegaco.syn */
const int useDefaultTimerValue = -1;
/*  Line 2425, Y:/rv/megaco/common/parser/rvmegaco.syn */
void rvMegacoParse(const char *text, const RvMegacoParserHandlers *handlers, void *data, RvAlloc *alloc)
{
	megaco_pcb_type pcb;
	
	pcb.pointer = text;
	pcb.handlers = handlers;
	pcb.userData = data;
	pcb.alloc = alloc;
	rvListConstruct(RvDeleteInfo)(&pcb.deleteInfo, pcb.alloc);

	megaco(&pcb);

	if(pcb.exit_flag != AG_SUCCESS_CODE && pcb.handlers->processParserError != NULL)
	{
		RvParseError parseError;

		if(pcb.exit_flag != AG_SYNTAX_ERROR_CODE || pcb.exit_flag != AG_SEMANTIC_ERROR_CODE)
			pcb.error_message = "Parsing Error";
		
		rvParseErrorConstruct(&parseError);
		rvParseErrorSetMessage(&parseError, pcb.error_message);
		rvParseErrorSetLine(&parseError, pcb.line);
		rvParseErrorSetColumn(&parseError, pcb.column);
		pcb.handlers->processParserError(&parseError, text, pcb.userData);
		rvParseErrorDestruct(&parseError);
	}

	rvDeleteAll(&pcb);
	rvListDestruct(RvDeleteInfo)(&pcb.deleteInfo);
}

static void parseSdpMessages(RvMegacoStreamDescriptor *stream, RvString *s, RvBool remote, megaco_pcb_type *pcb)
{
	void (*add)(RvMegacoStreamDescriptor *, const RvSdpMsg *) =
		remote ? 
		rvMegacoStreamDescriptorAddRemoteDescriptor :
		rvMegacoStreamDescriptorAddLocalDescriptor;
	const char *wsp = " \t\r\n";
	const char *start = rvStringGetData(s);
	const char *end = start + rvStringGetSize(s);

	/* remove trailing whitespace, then add 1 newline */
	while(start != end && strchr(wsp, *(end - 1)) != NULL)
		--end;
	rvStringResize(s, end - start);
	rvStringPushBack(s, '\n'), ++end;

	/* skip leading whitespace */
	while(start != end && strchr(wsp, *start) != NULL)
		++start;

	/* empty message is ok, don't add v line */
	if(start == end)
	{
		void (*addEmpty)(RvMegacoStreamDescriptor *) = remote ? 
			rvMegacoStreamDescriptorAddEmptyRemoteDescriptor :
			rvMegacoStreamDescriptorAddEmptyLocalDescriptor;
		addEmpty(stream);
		return;
	}

	/* add v line if not present */
	if(*start != 'v')
	{
		RvString temp;
		rvStringConstruct(&temp, "v=0\n", rvStringGetAllocator(s));
		rvStringConcatenateN(&temp, start, end - start);
		rvStringCopy(s, &temp);
		rvStringDestruct(&temp);
		start = rvStringGetData(s);
	}

	/* delimit SDP messages and add */
	for(;;)
	{
		RvSdpMsg sdp;
		RvSdpParseStatus status;
		int length;

		char *next = strstr(start + 1, "v=");
		if(next != NULL)
			*next = 0;

		if(rvSdpMsgConstructParseA(&sdp, (char *)start, &length, &status, pcb->alloc) == NULL)
		{
			pcb->exit_flag = AG_SEMANTIC_ERROR_CODE;
			pcb->error_message = "SDP parse failed";
			break;
		}
		add(stream, &sdp);
		rvSdpMsgDestruct(&sdp);

		if(next == NULL)
			break;
		*next = 'v';
		start = next;
	}
}


#ifndef CONVERT_CASE

static const char agCaseTable[31] = {
  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,    0,
  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20
};

static int agConvertCase(int c) {
  if (c >= 'a' && c <= 'z') return c ^= 0x20;
  if (c >= 0xe0 && c < 0xff) c ^= agCaseTable[c-0xe0];
  return c;
}

#define CONVERT_CASE(c) agConvertCase(c)

#endif


#ifndef TAB_SPACING
#define TAB_SPACING 8
#endif

static void ag_rp_1(PCB_DECL, unsigned int v, RvMegacoEntityAddress * sender) {
/* Line 236, Y:/rv/megaco/common/parser/rvmegaco.syn */
		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);
	
}

static void ag_rp_2(PCB_DECL, RvMegacoErrorDescriptor * e) {
/* Line 249, Y:/rv/megaco/common/parser/rvmegaco.syn */
		if(PCB.handlers->processErrorTransaction != NULL)
			PCB.handlers->processErrorTransaction(e, PCB.userData);
		rvDelete(&PCB, e);
	
}

static void ag_rp_3(PCB_DECL, unsigned int transId) {
/* Line 265, Y:/rv/megaco/common/parser/rvmegaco.syn */
 
		if(PCB.handlers->processPending != NULL)
			PCB.handlers->processPending(transId, PCB.userData);
	
}

static void ag_rp_4(PCB_DECL, unsigned int id) {
/* Line 277, Y:/rv/megaco/common/parser/rvmegaco.syn */
 
		if(PCB.handlers->processResponseAck != NULL)
			PCB.handlers->processResponseAck(id, id, PCB.userData);
	
}

static void ag_rp_5(PCB_DECL, unsigned int lo, unsigned int hi) {
/* Line 283, Y:/rv/megaco/common/parser/rvmegaco.syn */
		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);
	
}

static void ag_rp_6(PCB_DECL, RvMegacoTransaction * t) {
/* Line 297, Y:/rv/megaco/common/parser/rvmegaco.syn */
		if(PCB.handlers->processRequest != NULL)