test.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	packMoAckFields(AttrPairFields* pairFields);

bool	IS_MO=false;
bool	IS_MT=false;

static void usage(char *progname)
{
	string progName=progname;
	cout<<"Usage:\n"
		"\t"+progName+" [up/down] "+"[options] \n"+
		"options:\n"+
		"-i [IP-address]		indicate IP-address\n"+
		"-p [port]		indicate listen port\n"	+
		"-x			debug indicator\n"
	     <<endl;

	exit(1);
}
int main(int argc, char** argv)
{
	
	char buffer[1024];
	char* progname;
	char argval;
	bool	debugFlag=false;
	char*	sAddr="127.0.0.1";
	char*	sPort="5000";
	
	if((progname = strrchr(argv[0], '/')) == NULL)
		progname=argv[0];
	else
		progname++;	

	if(argc < 2)
		usage(progname);

	if(strcmp(argv[1], "up")==0)
		IS_MO=true;
	else if(strcmp(argv[1], "down")==0)
		IS_MT=true;
	else
		usage(progname);
	
	//parse parameter options
	while((argval=getopt(argc, argv, "i:p:x")) != EOF)
	{
		switch(argval)
		{
		    case 'i':
			sAddr=optarg;
			break;
		    case 'p':
			sPort=optarg;
			break;	
		    case 'x':
			debugFlag=true;
			break;
		    default:
			usage(progname);		
		}
	}
		
	//signal(SIGCHLD, sig);
	signal(SIGTERM, sig);
	signal(SIGINT, sig);
	signal(SIGQUIT, sig);
	signal(SIGSEGV, sig);
	signal(SIGABRT, sig);
	
	//end test	
	//initialization	
	sprintf(buffer, "%s/%s", DIR_LOG, logFile);
	Logger::setLogFile(buffer);
	Logger::setDebug(debugFlag);
	if(AttrDict::init(dictFile) != 0)	
	{
		Logger::debug("Initialize dictionary file %s error!", dictFile);		exit(1);
	}
	Logger::log(L_COMM, "Initialize dictionary ok!");	
	Logger::debug("Initialize dictionary ok!");	

	//socket communication
	Socket* sock=new Socket;	
	sock->ClientInit(sAddr, sPort);
	sock->Sock();
	sock->Connect();

	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::log(L_ERR, "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::log(L_DBG, "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);
	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];

		while(1) //keep long link
		{
			if(!sock->IsLinked())	
			{
				Logger::debug("Link to client closed.");
				break;
			}	
			//receive
			UInt	length;
			memset(msgData, 0, sizeof(msgData));
			Logger::debug("Waiting for message from server...");
			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);
			Logger::debug("Receive message[%d] from server...", seqNo);
			 //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;
			packMoAckFields(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);	
			Logger::debug("Deliver ack responsed to server.");
			delete pairFields;
		
			Sequence++;

		}//end while(1) keep long link until break
		sock->Close();	
	}//end 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("test");
	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("9581");
	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("13010725725");
	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);

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

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

	return true;
}
bool	packMoAckFields(AttrPairFields* pairFields)
{
	Attribute *attr;
	AttrValuePair *pair;
	
	attr=AttrDict::getAttrByName("Error_Code");
	UInt	errCode=0;
	pair=new AttrValuePair(attr->getAttr(),attr->getName(),attr->getValueType(), 4, errCode);
	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 sig(int signum)
{
	if(signum == SIGTERM)
		printf("\bMeet signal SIGTERM!\n");
	if(signum == SIGCHLD)
		printf("\bMeet signal SIGCHLD!\n");
	if(signum == SIGINT)
		printf("\bMeet signal SIGINT!\n");
	if(signum == SIGSEGV)
		printf("\bMeet signal SIGSEGV!\n");
	if(signum == SIGABRT)
		printf("\bMeet signal SIGABRT!\n");
	printf("Game is over!\n");
	exit(1);
}