test_bak.cpp

小型短信网关系统

#include	<string.h>
#include	<stdio.h>
#include	<signal.h>
#include 	<sys/socket.h>
#include 	<netinet/in.h>
#include 	<netdb.h>
#include 	<unistd.h>
#include	<errno.h>

#include	"test.h"
#include	"Logger.h"
#include	"AttrDict.h"
#include	"AttrValuePair.h"
#include	"AttrPairFields.h"
#include	"Pack.h"
#include	"MsgPack.h"

char*	logFile="mylog";
char*	dictFile="attribute.cfg";
char*   DIR_LOG = "./log";
char*	DIR_TEST = "./test";

const	UInt	MaxLength=65535;

void	writeFile(char* fileName, unsigned char* data, UInt length);
void	readFile(char* fileName, Octets data, UInt& length);
void 	sig(int);
bool	printFields(AttrPairFields* );
bool	packFields(AttrPairFields* pairFields);
UInt    unpackMsg(UInt& msgType, UInt& seqNo, Octets dataBody, Octets msgData,			UInt    length);
UInt    packMsg( UInt msgType, UInt seqNo, Octets bodyData, UInt bodyLength, 
		Octets msgData);
UInt    recvMsg(int sock_fd, Octets msgData);
int     sendMsg(int sock_fd, Octets msgData, UInt length);
int     buildSocket(char* sAddr, char* sPort);

int main(int argc, char** argv)
{

	char buffer[1024];
	
	if( argc != 3)
	{
		printf("Usage: %s IP PORT\n", argv[0]);
		exit(1);
	}
	
	//signal(SIGCHLD, sig);
	signal(SIGTERM, sig);
	signal(SIGINT, sig);
	signal(SIGQUIT, sig);
	signal(SIGSEGV, sig);
	signal(SIGABRT, sig);
	
	
	//initialization	
	sprintf(buffer, "%s/%s", DIR_LOG, logFile);
	Logger::setLogFile(buffer);
	if(AttrDict::init(dictFile) != 0)	
	{
		Logger::debug("Initialize dictionary file %s error!", dictFile);		exit(1);
	}
	Logger::log(L_COMM, "Initialize dictionary ok!");	
	 //test iterator.begin() == iterator.end()
	 //AttrDict::attrPrint();
	//end test

	//pack fields
	AttrPairFields* pairFields=new AttrPairFields;
	packFields(pairFields);

	//print pairs
	//printFields(pairFields);

	//pack message body
	Octet data[MaxLength];
	bool ret;
	UInt	length;
	memset(data, 0, sizeof(data));
	Logger::debug("Going to pack.");
	length=Pack::pairToData(pairFields, data);
	if(length == 0)
	{
		Logger::debug("Pack data fail.");
		exit(1);
	}
	delete pairFields;

/* for test
	//print data
	int i;
	for(i=0;i<(int)length;i++)
	{
		printf("data[%d]=[%d],",i,data[i]);
	}
	printf("\n");
	Logger::debug("Pack data length = %d", length);
	char fileName[50];
	sprintf(fileName,"%s/%s" ,DIR_TEST , "test.txt");
	writeFile(fileName, data,length);
		
	//read from file and unpack and print
	memset(data, 0, sizeof(data));	
	readFile(fileName, data, length);

	Logger::log(L_COMM,"Read data length is [%d]", length);
*/
	//pack message
	UInt msgType, seqNo, bodyLength ;
	Octet	msgData[MaxLength];
	Octets	dataBody;
	msgType=1;
	seqNo=101;	
	bodyLength=length;
	dataBody=data;
	
	length=MsgPack::packMsg(msgType, seqNo, dataBody, bodyLength, msgData);

	//socket communication
	int sock_fd;
	char*	sAddr=argv[1];
	char*	sPort=argv[2];
	sock_fd=buildSocket(sAddr, sPort);
	sendMsg(sock_fd, msgData, length);
	length=recvMsg(sock_fd, msgData);
	close(sock_fd);

	//unpack message
	UInt totalLength;
	dataBody=data;
	totalLength=MsgPack::unpackMsg(msgType, seqNo, dataBody, msgData, length);	

	//unpack message body
	length=totalLength-12;
	pairFields=new AttrPairFields;
	ret=Pack::dataToPair(pairFields, dataBody, length);
	if(ret == false)
	{
		Logger::debug("Unpack fail.");
		exit(1);	
	}

	printFields(pairFields);
		
	//test memory
	delete pairFields;
	//system("ps -eo pid,ppid,vsz,rss,comm|grep test1");
	//end test memory
	exit(0);
}

bool	packFields(AttrPairFields* pairFields)
{

	Attribute* attr=AttrDict::getAttrByName("VSP_ID");
	String vspID("cmims");
	UShort len=vspID.length();
	AttrValuePair* pair=new AttrValuePair(attr->getAttr(),attr->getName(),attr->getValueType(),len, vspID);
	pairFields->addPairField(pair);
	
	attr=AttrDict::getAttrByName("TEST_INTEGER");
	UInt	valueInteger=6;
	pair=new AttrValuePair(attr->getAttr(),attr->getName(),attr->getValueType(), 4, valueInteger);
	pairFields->addPairField(pair);	
	
	attr=AttrDict::getAttrByName("TEST_OCTET");
	Octet	valueOctet=58;
	pair=new AttrValuePair(attr->getAttr(),attr->getName(),attr->getValueType(), 1, valueOctet);
	pairFields->addPairField(pair);	

	AttrDict::getAttrByName("TEST_OCTETS");
	Octet buf[50];
	buf[0]=40;
	buf[1]=44;
	buf[2]=55;
	buf[3]=0;
	Octets	ptrOct=buf;
	pair=new AttrValuePair(attr->getAttr(),attr->getName(),attr->getValueType(), 3, ptrOct);
	pairFields->addPairField(pair);	

	return true;
}
bool printFields(AttrPairFields* pairFields)
{
	AttrValuePair* pair;
	//print
	UInt	valueUInt;	
	String valueStr;
	UShort	valueUShort;
	Octet	valueOctets[MaxLength];
	Octet	valueOctet;
	
	Logger::debug("Printing pairs:");

	AttrPairsMap* fields=pairFields->getAllFields();	
	if(fields == NULL)	
		return false;
	AttrPairsMap::iterator iter=fields->begin(); 
	if(iter == fields->end())
	{
		Logger::debug("Fields is empty.\n");
		return false;
	}
//	for(;iter!=fields->end();iter++)
	while(iter != fields->end())
	{
		pair=iter->second;
		String name=pair->getNameAttr();
		VType	type;
		type=pair->getValueType();
	switch(type)
	{
	case	VString:
		pair->getValue(valueStr);	
		printf("attr[%d],%s=%s\n",pair->getAttr(),(pair->getNameAttr()).c_str(), valueStr.c_str());
		break;
	case	VOctets:
		memset(valueOctets, 0, sizeof(valueOctets));
		pair->getValue(valueOctets);	
		printf("attr[%d],%s=%s\n",pair->getAttr(),(pair->getNameAttr()).c_str(), valueOctets);
		break;
	case	VOctet:
		pair->getValue(valueOctet);	
		printf("attr[%d],%s=%d\n",pair->getAttr(),(pair->getNameAttr()).c_str(), valueOctet);
		break;
	case	VUInt:
		pair->getValue(valueUInt);
		printf("attr[%d],%s=%d\n",pair->getAttr(),(pair->getNameAttr()).c_str(), valueUInt);
		break;
	case	VUShort:
		pair->getValue(valueUShort);
		printf("attr[%d],%s=%d\n",pair->getAttr(),(pair->getNameAttr()).c_str(), valueUShort);
		break;
	default:
		printf("Unknown type=%d\n", type);
		break;
	}//end switch
	iter++;
	}//end while 
	
	return true;
}

void	writeFile(char* fileName, unsigned char* data, UInt length)
{
	FILE* fp;

	if((fp=fopen(fileName, "w"))==NULL)
	{
		Logger::debug("Open file error!");
		return;
	}	
	//stream buffer
//	fputs((char*)data, fp);
//	fputs("\n", fp);
	//binary buffer
	UInt len=fwrite(data,1,length,fp);
	if(len != length)
	{
		Logger::log(L_ERR, "Error length when write data!");
	}
	fclose(fp);
	return;	
}

void	readFile(char* fileName, Octets data, UInt& length)
{
	FILE* fp;
	if((fp=fopen(fileName, "r"))==NULL)
	{
		Logger::debug("Open file error! ");
		return;
	}	
	//stream buffer
	//fgets((char*)data, len, fp);
	//binary buffer
	length=fread(data,1,MaxLength,fp);
	fclose(fp);
	return;
}

int	buildSocket(char* sAddr, char* sPort)
{
	struct	sockaddr_in	serv_addr;
	struct	hostent*	host;
	int	sockfd;
	int	port;
	
	
	host=gethostbyname(sAddr);
	if(host == NULL)
	{
		Logger::debug("In gethostbyname error!");
		exit(1);
	}
	port=atoi(sPort);
	if(port < 0)
	{
		Logger::debug("Get port error!");
		exit(1);
	}

	bzero(&serv_addr, sizeof(serv_addr));
	serv_addr.sin_family=AF_INET;
	serv_addr.sin_addr=*(struct in_addr *)host->h_addr;
	serv_addr.sin_port=htons(port);

	sockfd=socket(AF_INET, SOCK_STREAM, 0);	
	if(sockfd < 0)
	{
		Logger::debug("In socket error!");
		exit(1);
	}

	int ret;
	ret=connect(sockfd, ( struct sockaddr* ) &serv_addr, sizeof(struct sockaddr));
	if(ret < 0)
	{
		Logger::debug("In connect error!");
		close(sockfd);
		exit(1);
	}
	
	return sockfd;	
}
int	sendMsg(int sock_fd, Octets msgData, UInt length)
{
	int	sendLen;
	Octets	ptr;

	ptr=msgData;
	while(length > 0)	
	{
		sendLen=send(sock_fd, ptr, length, 0);
		if(sendLen < 0)
		{
			Logger::debug("In send error: %s", strerror(errno));
			close(sock_fd);
			exit(1);
		}
		length-=sendLen;
		ptr+=sendLen;
	}

	return ptr-msgData;
}
UInt	recvMsg(int sock_fd, Octets msgData)
{
	int	recvLen;
	UInt	totalLength, nTotalLength, length;
	Octets	ptr;

	memset(msgData, 0, sizeof(msgData));
	ptr=msgData;
	//totalLength
	recvLen=recv(sock_fd, ptr, 12, 0);
	if(recvLen < 0)
	{
		Logger::debug("In recv error: %s", strerror(errno));
		close(sock_fd);
		exit(1);
	}
	else if(recvLen < 12)
	{
		Logger::log(L_ERR, "Receive length < 12 !");
		close(sock_fd);
		exit(1);
	}
	memcpy(&nTotalLength,msgData, 4);
	totalLength=ntohl(nTotalLength);
	if(totalLength < 12)	
	{
		Logger::log(L_ERR, "TotalLength length < 12 !");
		close(sock_fd);
		exit(1);
	}
	length=totalLength-12;
	ptr+=12;
	while(length > 0)
	{
		recvLen=recv(sock_fd, ptr, MaxLength, 0);
		if(recvLen < 0)
		{
			Logger::debug("In recv error: %s", strerror(errno));
			close(sock_fd);
			exit(1);
		}
		else if(recvLen == 0) 	//client unlink
			break;	
		length-=recvLen;
		ptr+=recvLen;
	}
	if(length != 0)
	{
		Logger::debug("Receive data length not equal total length!");
		close(sock_fd);
		exit(1);
	}
	
	return totalLength;
}
UInt	packMsg(
	UInt msgType,
	UInt seqNo, 
	Octets bodyData,
	UInt bodyLength, 
	Octets msgData)
{
	UInt	nMsgType, nSeqNo, nTotalLength, totalLength;
	Octets	ptr;

	totalLength=12+bodyLength;
	nTotalLength=htonl(totalLength);
	nMsgType=htonl(msgType);
	nSeqNo=htonl(seqNo);

	memset(msgData, 0, sizeof(msgData));
	ptr=msgData;	
	memcpy(ptr, &nTotalLength, 4);
	ptr=ptr+4;
	memcpy(ptr, &nMsgType, 4);
	ptr=ptr+4;
	memcpy(ptr, &nSeqNo, 4);
	ptr=ptr+4;
	memcpy(ptr, bodyData, bodyLength );

	return totalLength;
}
UInt	unpackMsg(UInt& msgType, UInt& seqNo, Octets dataBody, Octets msgData, 
	UInt	length)
{
	UInt	nMsgType, nSeqNo, nTotalLength, totalLength;
	
	memcpy(&nTotalLength, msgData, 4);	
	totalLength=ntohl(nTotalLength);
	if(totalLength != length)
	{
		Logger::debug("TotalLength dos not equal receive length!");
		exit(1);
	}
	
	memcpy(&nMsgType, msgData+4, 4);
	msgType=ntohl(nMsgType);
	memcpy(&nSeqNo, msgData+8, 4);
	seqNo=ntohl(nSeqNo);

	memset(dataBody, 0, sizeof(dataBody));
	memcpy(dataBody, msgData+12, totalLength-12);

	return totalLength;
}
void sig(int signum)
{
	if(signum == SIGTERM)
		printf("Meet signal SIGTERM!\n");
	if(signum == SIGCHLD)
		printf("Meet signal SIGCHLD!\n");
	if(signum == SIGINT)
		printf("Meet signal SIGINT!\n");
	if(signum == SIGSEGV)
		printf("Meet signal SIGSEGV!\n");
	if(signum == SIGABRT)
		printf("Meet signal SIGABRT!\n");
	printf("Game is over!\n");
	exit(1);
}