pack.cpp

小型短信网关系统

#include <netinet/in.h>

#include "Pack.h"
//debug
#include <stdio.h>

const  UInt MaxLength = 65532 ;
const  UInt BufLength = 65532 ;

Pack::Pack()
{
}

Pack::~Pack()
{
}

bool	Pack::dataToPair(
		AttrPairFields* attrPairFields, Octets data, UInt length)
{
	UInt	len;
	Octets	ptr;
	Octet	buffer[BufLength];

	Octet	attr;	
	VType	valueType;
	String	nameAttr;
	UShort	pairLength;

	Octet	valueOctet;
	Octets	valueOctets;
	UInt	valueUInt;
	UShort	valueUShort;
	String	valueString;
	
	ptr=data;
	len=length;

	while(len>0)	
	{
		//attr
		attr=*ptr;
		//get attribute and make pair	
		Attribute* attribute=AttrDict::getAttrByAttr(attr);	
		if(attribute == NULL)
		{
			Logger::log(L_ERR, "Unrecognised attribute [%d]!", attr);
			return false;
		}
		valueType=attribute->getValueType();
		nameAttr=attribute->getName();
		//length
		ptr++;
		UShort nLength;
		memcpy(&nLength, ptr, 2);
		//2 byte = 16 bit
		pairLength=ntohs(nLength);
		pairLength=pairLength-3;
		if(pairLength > MaxLength)
		{
			Logger::log(L_ERR, "The length of attribute pair [%d] is 				too large!", attr);
			return false;
		}
		//value
		ptr=ptr+2;	
		AttrValuePair* attrValuePair;
		switch(valueType)
		{
		case	VUShort:
			if(pairLength != sizeof(UShort))
			{
				Logger::log(L_ERR, "Illegal length of attribute pair [%d]!", attr);
				return false;
			}
			UShort nValueShort;
			memcpy(&nValueShort, ptr, pairLength);
			//16 bit
			valueUShort=ntohs(nValueShort);
			attrValuePair=new AttrValuePair(
			     attr, nameAttr, valueType, pairLength, valueUShort);
			attrPairFields->addPairField(attrValuePair);
			break;
		case	VUInt:
			if(pairLength != sizeof(UInt))
			{
				Logger::log(L_ERR, "Illegal length of attribute pair [%d]!", attr);
				return false;
			}
			UInt nValueUInt;
			memcpy(&nValueUInt, ptr, pairLength);
			//32 bit
			valueUInt=ntohl(nValueUInt);
			attrValuePair=new AttrValuePair(
			     attr, nameAttr, valueType, pairLength, valueUInt);
			attrPairFields->addPairField(attrValuePair);
			break;
		case	VOctet:
			if(pairLength != sizeof(Octet))
			{
				Logger::log(L_ERR, "Illegal length of attribute pair [%d]!", attr);
				return false;
			}
			valueOctet=*ptr;
			attrValuePair=new AttrValuePair(
			     attr, nameAttr, valueType, pairLength, valueOctet);
			attrPairFields->addPairField(attrValuePair);
			break;
		case	VOctets:
			memset(buffer, 0 ,sizeof(buffer));
			memcpy(buffer, ptr, pairLength);
			valueOctets=buffer;
			attrValuePair=new AttrValuePair(
			     attr, nameAttr, valueType, pairLength, valueOctets);
			attrPairFields->addPairField(attrValuePair);
			break;
		case	VString:
			memset(buffer, 0 ,sizeof(buffer));
			memcpy(buffer, ptr, pairLength);
			buffer[pairLength]=0;
			//strncpy(valueString.c_str(),(char*)ptr, pairLength);
			valueString=(char*)buffer;
			attrValuePair=new AttrValuePair(
			     attr, nameAttr, valueType, pairLength, valueString);
			attrPairFields->addPairField(attrValuePair);
			break;
		default:
			break;
		}
		//next pair	
		len=len-pairLength-3;
		ptr=ptr+pairLength;
	}//end while
	
	return true; 
}

UInt	Pack::pairToData(AttrPairFields* attrPairFields, Octets data)
{
	Octets	ptr;
	Octet	attr;
	VType	valueType;
	UShort	pairLength, len;

	String	valueString;
	
	AttrPairsMap* fields=attrPairFields->getAllFields();
	if(fields == NULL)
	{
		return 0;
	}
	AttrPairsMap::iterator  iter=fields->begin();
	ptr=data;
	
	while(iter != fields->end())
	{
		AttrValuePair* attrValuePair=iter->second;	
		attr=attrValuePair->getAttr();
		pairLength=attrValuePair->getLength();
		valueType=attrValuePair->getValueType();
		//pack attr and length
		//memcpy(ptr, attr, 1);
		*ptr=attr;
		ptr++;
		//2 byte = 16 bit
		len=htons(pairLength+3);
		memcpy(ptr, &len, 2);
		ptr+=2;
		//pack value
		switch(valueType)
		{
		case	VUShort:
			UShort sValue, valueShort;
			attrValuePair->getValue(valueShort);	
			//16 bit
			sValue=htons(valueShort);
			memcpy(ptr, &sValue, pairLength);
			break;
		case	VUInt:
			UInt	iValue, valueUInt;
			attrValuePair->getValue(valueUInt);
			//32 bit
			iValue=htonl(valueUInt);
			memcpy(ptr, &iValue, pairLength);
			break;
		case 	VOctet:
			Octet	valueOctet;
			attrValuePair->getValue(valueOctet);
			*ptr=valueOctet;
			break;
		case	VOctets:
			Octet	valueOctets[BufLength];
			attrValuePair->getValue(valueOctets);
			memcpy(ptr, valueOctets, pairLength);	 
			break;
		case	VString:
			attrValuePair->getValue(valueString);
			memcpy(ptr, valueString.c_str(), pairLength);	 
			break;
		default:
			Logger::log(L_ERR, "Unrecognised type[%d] of attribute[%d]!", attr, valueType);
			break;	
		}
		//next pair
		ptr=ptr+pairLength;
		iter++;
		
	}//end while

	return	ptr-data; 	
}