test_server.cpp

小型短信网关系统

#include	<string.h>
#include	<stdio.h>
#include	<signal.h>
#include	<stdlib.h>
//#include <sys/types.h>
#include <unistd.h>  // fork()

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

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

const	UInt	MaxLength=65535;

void 	sig(int);
bool	printFields(AttrPairFields* );
bool	packMtFields(AttrPairFields* pairFields);
bool	packMoFields(AttrPairFields* pairFields);

bool	IS_MO=false;
bool	IS_MT=false;

int main(int argc, char** argv)
{
	
	char buffer[1024];
	
	if( strcmp(argv[1], "up") == 0 )
	{
		if(argc != 3)
		{
			printf("Usage: %s up PORT\n", argv[0]);
			exit(1);
		}
		IS_MO=true;
	}
	else if(strcmp(argv[1], "down") == 0)
	{
		if(argc != 4)
		{
			printf("Usage: %s down IP PORT\n", argv[0]);
			exit(1);
		}
		IS_MT=true;
	}
	else
	{
		printf("Usage: %s up/down 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	
	Logger::setLogFile(buffer);
	sprintf(buffer, "%s/%s", DIR_LOG, logFile);
	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
	if(IS_MT) //down
	{
	//pack fields
	AttrPairFields* pairFields=new AttrPairFields;
	packMtFields(pairFields);

	//print pairs
	//printFields(pairFields);

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

	//pack message
	UInt msgType, seqNo, bodyLength ;
	Octet	msgData[MaxLength];
	Octets	dataBody;
	msgType=1;
	seqNo=101;	
	bodyLength=length;
	dataBody=data;
	memset(msgData, 0, sizeof(msgData));	
	length=MsgPack::packMsg(msgType, seqNo, dataBody, bodyLength, msgData);

	//socket communication
	Socket* sock=new Socket;	
	char*	sAddr=argv[2];
	char*	sPort=argv[3];
	sock->ClientInit(sAddr, sPort);
	sock->Sock();
	sock->Connect();
	sock->Send(msgData, length);
	memset(msgData, 0, sizeof(msgData));
	length=sock->Receive(msgData);
	Logger::debug("Receive message length = %d from gateway.", length);
	//for debug
	/*
        int i;
        for(i=0;i<(int)length;i++)
        {
                printf("data[%d]=[%d],",i,msgData[i]);
        }
	printf("\n");
	*/
	sock->Close();
	delete sock;

	//unpack message
	UInt totalLength;
	memset(data, 0, sizeof(data));
	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);	
	}
	
	Logger::debug("Receive message from gateway:");
	printFields(pairFields);
	delete pairFields;
	}//end if(IS_MT)
	else if(IS_MO)	//up
	{
		UInt	Sequence=100;
		Octet	data[MaxLength];
		Octet	msgData[MaxLength];
		//socket communication
		char* sPort=argv[2];
		Socket* sock=new Socket;

		sock->ServerInit(sPort);
		sock->Sock();
		sock->Bind();
		int	maxListen=5;
		sock->Listen(maxListen);
		while(1) 
		{ 
			sock->Accept();
			int	pid;
			pid=fork();
			if(pid != 0) //parent process
			{
				sock->Close();	
				continue;	//deal next request
			}
			//child process: one client
			while(1) //keep long link
			{
				if(sock->IsLinked())	
				{
					Logger::debug("Link to client closed.");
					break;
				}	
				//receive
				UInt	length;
				memset(msgData, 0, sizeof(msgData));
				length=sock->Receive(msgData);	

				UInt	totalLength, msgType, seqNo;
				memset(data, 0, sizeof(data));
				Octets	dataBody=data;

				//unpack message
				totalLength=MsgPack::unpackMsg(msgType, seqNo, dataBody, msgData, length);
				 //unpack message body
				length=totalLength-12;
				AttrPairFields* pairFields=new AttrPairFields;
				int ret=Pack::dataToPair(pairFields, dataBody, length);
        			if(ret == false)
        			{
                			Logger::debug("Unpack fail.");
                			exit(1);
        			}
				printFields(pairFields);
				delete pairFields;

				//response to client
				//pack mo response
				pairFields=new AttrPairFields;
				packMoFields(pairFields);
				memset(data, 0, sizeof(data));
 				length=Pack::pairToData(pairFields, data);
 				if(length == 0)
 				{
 					Logger::debug("Pack data fail.");
 					exit(1);
        			}
			        //pack message
        			UInt bodyLength;
        			msgType=8; //deliver ack
        			seqNo=Sequence;
        			bodyLength=length;
        			dataBody=data;
				memset(msgData, 0, sizeof(msgData));
				length=MsgPack::packMsg(msgType, seqNo, dataBody, bodyLength, msgData);
				sock->Send(msgData, length);	
				delete pairFields;
				
				Sequence++;

			}//end while(1) keep long link until break
			sock->Close();	
			exit(0); //child process exit
		}//end while

		sock->SockEnd();
		
	}//end if(IS_MO)
	//test memory
	//system("ps -eo pid,ppid,vsz,rss,comm|grep test1");
	//end test memory
	exit(0);
}

bool	packMtFields(AttrPairFields* pairFields)
{
	Attribute* attr;
	AttrValuePair* pair;
	UShort	len;

	attr=AttrDict::getAttrByName("VSP_ID");
	String vspID("devp");
	len=vspID.length();
	pair=new AttrValuePair(attr->getAttr(),attr->getName(),attr->getValueType(),len, vspID);
	pairFields->addPairField(pair);

	attr=AttrDict::getAttrByName("Src_Terminal_Id");
//	String srcNo("011601");
	String srcNo("0958058");
	len=srcNo.length();
	pair=new AttrValuePair(attr->getAttr(),attr->getName(),attr->getValueType(),len, srcNo);
	pairFields->addPairField(pair);
	
	attr=AttrDict::getAttrByName("Dest_Terminal_Id");
	String destNo("13510725725");
	len=destNo.length();
	pair=new AttrValuePair(attr->getAttr(),attr->getName(),attr->getValueType(),len, destNo);
	pairFields->addPairField(pair);

	attr=AttrDict::getAttrByName("Service_Id");
	String serviceID("PSW");
	len=serviceID.length();
	pair=new AttrValuePair(attr->getAttr(),attr->getName(),attr->getValueType(),len, serviceID);
	pairFields->addPairField(pair);

	attr=AttrDict::getAttrByName("Fee_Type");
	String feeType("02");
	len=feeType.length();
	pair=new AttrValuePair(attr->getAttr(),attr->getName(),attr->getValueType(),len, feeType);
	pairFields->addPairField(pair);

	attr=AttrDict::getAttrByName("Fee_User_Type");
	Octet	feeUserType=0;
	pair=new AttrValuePair(attr->getAttr(),attr->getName(),attr->getValueType(), 1, feeUserType);
	pairFields->addPairField(pair);	

	attr=AttrDict::getAttrByName("Fee_Code");
	String feeCode("000001");
	len=feeCode.length();
	pair=new AttrValuePair(attr->getAttr(),attr->getName(),attr->getValueType(),len, feeCode);
	pairFields->addPairField(pair);

	attr=AttrDict::getAttrByName("Data_Type");
	Octet	dataType=0; //Text
	pair=new AttrValuePair(attr->getAttr(),attr->getName(),attr->getValueType(), 1, dataType);
	pairFields->addPairField(pair);	

	attr=AttrDict::getAttrByName("Data_Encode");
	Octet	dataEncode=1; 
	pair=new AttrValuePair(attr->getAttr(),attr->getName(),attr->getValueType(), 1, dataEncode);
	pairFields->addPairField(pair);	

	attr=AttrDict::getAttrByName("Registered_Delivery");
	Octet	registeredDelivery=1; 
	pair=new AttrValuePair(attr->getAttr(),attr->getName(),attr->getValueType(), 1, registeredDelivery);
	pairFields->addPairField(pair);	

	attr=AttrDict::getAttrByName("Content");
	String content("Hello, this is a test by chwzh!");
	len=content.length();
	Octet buffer[MaxLength];
	strcpy((char*)buffer, content.c_str());
	pair=new AttrValuePair(attr->getAttr(),attr->getName(),attr->getValueType(),len, buffer);
	pairFields->addPairField(pair);

	return true;
}
bool	packMoFields(AttrPairFields* pairFields)
{
	//continue....
	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 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);
}