org.mobicents.protocols.mgcp.parser.params.EventNameHandler Maven / Gradle / Ivy

Go to download
/*
 * JBoss, Home of Professional Open Source
 * Copyright 2011, Red Hat, Inc. and individual contributors
 * by the @authors tag. See the copyright.txt in the distribution for a
 * full listing of individual contributors.
 *
 * This is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation; either version 2.1 of
 * the License, or (at your option) any later version.
 *
 * This software is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this software; if not, write to the Free
 * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
 */

package org.mobicents.protocols.mgcp.parser.params;

import java.text.ParseException;

import org.mobicents.protocols.mgcp.parser.StringFunctions;
import org.mobicents.protocols.mgcp.parser.SplitDetails;

import org.mobicents.protocols.mgcp.parser.pkg.PackageNameHandler;
import org.mobicents.protocols.mgcp.jain.pkg.AUMgcpEvent;
import org.mobicents.protocols.mgcp.jain.pkg.AUPackage;
import org.mobicents.protocols.mgcp.jain.pkg.SLPackage;

import jain.protocol.ip.mgcp.message.parms.EventName;
import jain.protocol.ip.mgcp.message.parms.ConnectionIdentifier;
import jain.protocol.ip.mgcp.pkg.PackageName;
import jain.protocol.ip.mgcp.pkg.MgcpEvent;

public class EventNameHandler
{
	static PackageName auPackage=AUPackage.AU;
	static PackageName slPackage=SLPackage.SL;
	static MgcpEvent rfc2897pa = AUMgcpEvent.aupa;
	
	private static MgcpEvent generateEvent(byte[] value,int offset,int length) throws ParseException
	{
		if(length==2)		
		{
			switch(value[offset+1])
			{
				case StringFunctions.LOW_S_BYTE: 
				case StringFunctions.HIGH_S_BYTE:
					if(value[offset]==StringFunctions.LOW_E_BYTE || value[offset]==StringFunctions.HIGH_E_BYTE)
						return AUMgcpEvent.aues;
					
				case StringFunctions.LOW_R_BYTE: 
				case StringFunctions.HIGH_R_BYTE:
					if(value[offset]==StringFunctions.LOW_P_BYTE || value[offset]==StringFunctions.HIGH_P_BYTE)
						return AUMgcpEvent.aupr;
					
				case StringFunctions.LOW_C_BYTE: 
				case StringFunctions.HIGH_C_BYTE:
					if(value[offset]==StringFunctions.LOW_P_BYTE || value[offset]==StringFunctions.HIGH_P_BYTE)
						return AUMgcpEvent.aupc;
			}
		}
		
		return MgcpEvent.factory(new String(value,offset,length));
	}
	
	private static EventName decode(byte[] value,int offset,int length,String params) throws ParseException
	{
		int currIndex=offset;
		int slashIndex=-1;
		int atIndex=-1;		
		for(int i=0;i=0)
					throw new ParseException("Unknown value for Event Name: " + new String(value,offset,length), 0);
				
				slashIndex=currIndex;
			}
			else if(value[currIndex]==StringFunctions.AT_BYTE)
			{
				if(slashIndex<0)
					throw new ParseException("Unknown value for Event Name: " + new String(value,offset,length), 0);
				
				atIndex=currIndex;
				break;
			}
		}
		
		PackageName packageName;
		MgcpEvent mgcpEvent;
		if(slashIndex>=0)
		{			
			packageName=PackageNameHandler.decode(value,offset,slashIndex-offset);
			if(atIndex>=0)				
				mgcpEvent=generateEvent(value,slashIndex+1,atIndex-slashIndex-1);
			else
				mgcpEvent=generateEvent(value,slashIndex+1,length+offset-slashIndex-1);									
		}
		else
		{
			packageName=PackageName.AllPackages;
			if(atIndex>=0)
				mgcpEvent=generateEvent(value,offset,atIndex-offset);
			else
				mgcpEvent=generateEvent(value,offset,length);			
		}
		
		ConnectionIdentifier connectionIdentifier=null;
		if(atIndex>=0)
		{
			if(length+offset-atIndex-1==1)
			{
				switch(value[atIndex+1])
				{
					case StringFunctions.DOLLAR_BYTE:
						connectionIdentifier=ConnectionIdentifier.AnyConnection;
						break;
					case StringFunctions.ASTERISK_BYTE:
						connectionIdentifier=ConnectionIdentifier.AllConnections;
						break;
					default:
						connectionIdentifier=new ConnectionIdentifier(new String(value,atIndex+1,1));
						break;
				}
			}
			else
				connectionIdentifier=new ConnectionIdentifier(new String(value,atIndex+1,length+offset-atIndex-1));
		}
		
		if(params==null)
			return new EventName(packageName,mgcpEvent,connectionIdentifier);	
		
		return new EventName(packageName,mgcpEvent.withParm(params),connectionIdentifier);
	}
	
	public static EventName decode(byte[] value,int offset,int length) throws ParseException
	{
		return decode(value,offset,length,null);
	}
	
	public static EventName decodeWithParams(byte[] value,int offset,int length,int paramsOffset,int paramsLength) throws ParseException
	{
		return decode(value,offset,length,new String(value,paramsOffset,paramsLength));		
	}
	
	public static int encode(byte[] destination,int offset,EventName eventName)
	{
		int totalLength=PackageNameHandler.encode(destination,offset,eventName.getPackageName());
		destination[offset+totalLength]=StringFunctions.SLASH_BYTE;
		totalLength++;
		
		byte[] nameBytes=eventName.getEventIdentifier().getName().getBytes();
		System.arraycopy(nameBytes, 0, destination, offset+totalLength, nameBytes.length);
		totalLength+=nameBytes.length;
		
		if(eventName.getConnectionIdentifier()!=null)
		{
			destination[offset+totalLength]=StringFunctions.AT_BYTE;
			totalLength++;
			byte[] connectionBytes=eventName.getConnectionIdentifier().toString().getBytes();
			System.arraycopy(connectionBytes, 0, destination, offset+totalLength, connectionBytes.length);
			totalLength+=connectionBytes.length;			
		}
		
		return totalLength;
	}
	
	public static int encodeParams(byte[] destination,int offset,EventName eventName)
	{
		if(eventName.getEventIdentifier().getParms()==null)
			return 0;
		
		destination[offset]=StringFunctions.OPEN_BRACKET_BYTE;
		byte[] paramsBytes=eventName.getEventIdentifier().getParms().getBytes();
		System.arraycopy(paramsBytes, 0, destination, offset+1, paramsBytes.length);
		destination[offset+paramsBytes.length+1]=StringFunctions.CLOSE_BRACKET_BYTE;
		return paramsBytes.length+2;
	}
	
	public static int encodeList(byte[] destination,int offset,EventName[] eventNames)
	{
		if(eventNames.length==0)
			return 0;
			
		int totalLength=0;
		int i=0;
		for(;i