cmppserver.c

用c/c++实现的一个CMPP API

	memcpy(prCmppPckResp->body.rCmppDeliverResp.uchMsgId, 
		   prCmppPck->body.rCmppDeliver.uchMsgId, MacMsgId);
	prCmppPckResp->body.rCmppDeliverResp.unResult =  nResult;
	
	return 0;
}
int nQueryMakeResponse(int nResult, recCmppPck* prCmppPckResp,  recCmppPck* prCmppPck)
{
	prCmppPckResp->rHead.unTotalLength = MacHeadLen + MacQueryResLen;
	prCmppPckResp->rHead.unCommandId = MacC_QueryRep;
	prCmppPckResp->rHead.unSequenceId = prCmppPck->rHead.unSequenceId;


	memcpy(prCmppPckResp->body.rCmppQueryResp.chTime,
		   prCmppPck->body.rCmppQuery.chTime, MacQueryTime);
	prCmppPckResp->body.rCmppQueryResp.ucQueryType = prCmppPck->body.rCmppQuery.ucQueryType;
	memcpy(prCmppPckResp->body.rCmppQueryResp.chQueryCode,
		   prCmppPck->body.rCmppQuery.chQueryCode, MacQueryCode);
	prCmppPckResp->body.rCmppQueryResp.unMtTlMsg = 10;
	prCmppPckResp->body.rCmppQueryResp.unMtTlUsr = 2;
	prCmppPckResp->body.rCmppQueryResp.unMtScs = 21;
	prCmppPckResp->body.rCmppQueryResp.unMtWt = 12;
	prCmppPckResp->body.rCmppQueryResp.unMtFl = 23;
	prCmppPckResp->body.rCmppQueryResp.unMoScs = 16;
	prCmppPckResp->body.rCmppQueryResp.unMoWt = 23;
	prCmppPckResp->body.rCmppQueryResp.unMoFl = nResult;
	
	return 0;
}
int nCancelMakeResponse(int nResult, recCmppPck* prCmppPckResp,  recCmppPck* prCmppPck)
{
	prCmppPckResp->rHead.unTotalLength = MacHeadLen + MacCancelResLen;
	prCmppPckResp->rHead.unCommandId = MacC_CancelRep;
	prCmppPckResp->rHead.unSequenceId = prCmppPck->rHead.unSequenceId;


	prCmppPckResp->body.rCmppCancelResp.unSuccessId = nResult;
	
	return 0;
}
int nActiveMakeResponse(int nResult, recCmppPck* prCmppPckResp,  recCmppPck* prCmppPck)
{
	prCmppPckResp->rHead.unTotalLength = MacHeadLen + MacActiveTestResLen;
	prCmppPckResp->rHead.unCommandId = MacC_ActiveRep;
	prCmppPckResp->rHead.unSequenceId = prCmppPck->rHead.unSequenceId;


	prCmppPckResp->body.rCmppActiveTestResp.ucReserver = (char)nResult;
	return 0;
}

int nMakeResponse(recCmppPck* prCmppPckResp, recCmppPck* prCmppPck, int nResult)
{
	int nRet;
	switch(prCmppPck->rHead.unCommandId)
	{
		 case MacC_ConnectRqst:
        {
            nRet = nConnectMakeResponse(nResult, prCmppPckResp,  prCmppPck);
            break;
        }
        case MacC_SubmitRqst:
        {
            nRet = nSubmitMakeResponse(nResult, prCmppPckResp,  prCmppPck);
            break;
        }
        case MacC_DeliverRqst:
        {
            nRet = nDeliverMakeResponse(nResult, prCmppPckResp,  prCmppPck);
            break;
        }
        case MacC_QueryRqst:
        {
            nRet = nQueryMakeResponse(nResult, prCmppPckResp,  prCmppPck);
            break;
        }
        case MacC_CancelRqst:
        {
            nRet = nCancelMakeResponse(nResult, prCmppPckResp,  prCmppPck);
            break;
        }
        case MacC_ActiveRqst:
        {
            nRet = nActiveMakeResponse(nResult, prCmppPckResp,  prCmppPck);
            break;
        }
        default:
        {
            return -1;
            break;
        } 
	}
	return nRet;
}

void vComposeDeliveryReport(recCmppPck* prCmppPckDelivery, recCmppPck* prCmppPck)
{
	prCmppPckDelivery->rHead.unTotalLength = MacHeadLen + MacMaxDeliverLen - MacMsgLen + MacReceiptBodyLen;
	prCmppPckDelivery->rHead.unCommandId = MacC_DeliverRqst;
	prCmppPckDelivery->rHead.unSequenceId = prCmppPck->rHead.unSequenceId;

	strncpy(prCmppPckDelivery->body.rCmppDeliver.chDestId, 
		     prCmppPck->body.rCmppSubmit.chSrcId, MacDstId);
	strncpy(prCmppPckDelivery->body.rCmppDeliver.chServiceId,
		     prCmppPck->body.rCmppSubmit.chServiceId, MacServiceId);
	prCmppPckDelivery->body.rCmppDeliver.ucTpPid = prCmppPck->body.rCmppSubmit.ucTpPid;
	prCmppPckDelivery->body.rCmppDeliver.ucTpUdhi = prCmppPck->body.rCmppSubmit.ucTpUdhi;
	prCmppPckDelivery->body.rCmppDeliver.ucMsgFmt = prCmppPck->body.rCmppSubmit.ucMsgFmt;
	strncpy(prCmppPckDelivery->body.rCmppDeliver.chSrcTerminalId,
		      prCmppPck->body.rCmppSubmit.chDstTerminalId, MacSrcTermId);
	prCmppPckDelivery->body.rCmppDeliver.ucSrcTerminalType = prCmppPck->body.rCmppSubmit.ucDstTerminalType;
	prCmppPckDelivery->body.rCmppDeliver.ucRegisterDelivery = 1;
	prCmppPckDelivery->body.rCmppDeliver.ucMsgLength = MacReceiptBodyLen;
	sprintf(prCmppPckDelivery->body.rCmppDeliver.chMsgContent,
		    "%08d123456703082712320308271232%32s%d", 0, "13652386845", prCmppPck->rHead.unSequenceId);
	strncpy(prCmppPckDelivery->body.rCmppDeliver.chLinkId, prCmppPck->body.rCmppSubmit.chLinkId, MacLinkId);
}

int nMSgRecv(int nSock, char* pBuf, int nTimeout)
{
	int nRet;
	int nTotalLen;
	int nTmp;
//	char sTmp[1024];
	char sTmpBody[1024];

	memset(pBuf, 0, sizeof(pBuf));
	
	nRet = nTcpRecv(nSock, pBuf, MacIntLen, nTimeout);
	if(nRet < 0)
	{
		printf("nTcpRecv Msg Head error");
		return -1;
	}

	if(nRet == 0)
	{
		return 0;
	}
	
	memcpy(&nTmp, pBuf, MacIntLen);
	nTotalLen = ntohl(nTmp);

	if(nTotalLen < MacHeadLen)
	{
		printf("Receive Length not correct len = %d\n", nTotalLen);
		return -1;
	}
	memset(sTmpBody, 0, sizeof(sTmpBody));
	nRet = nTcpRecv(nSock, sTmpBody, nTotalLen - MacIntLen , nTimeout);
	if(nRet < 0)
	{
		printf("nTcpRecv Msg Body error");
		return -1;
	}

	if(nRet == 0)
	{
		return 0;
	}
	
	memcpy(pBuf + MacIntLen, sTmpBody, nTotalLen - MacIntLen);

	return nRet;
}

#ifdef WIN32
DWORD WINAPI pvCmppApiThread(LPVOID pvData)
#endif
#if defined(_HPUX_SOURCE) || defined(_LINUX_SOURCE)
void* pvCmppApiThread(void* pvData)
#endif
{
	int nSum;
	int nRet;
	int nSockId;
	int nLen;
	char sTmp[1024];
	recCmppPck rCmppPck;
	recCmppPck rCmppPckResp;
	recCmppPck rCmppPckDelivery;

	nSum = 0;
	
	nSockId = *((int*)pvData);
	printf("start pvRecvThread: %d\n", nSockId);
	for(;;)
	{
		memset(sTmp, 0, sizeof(sTmp));
		memset(&rCmppPck, 0, sizeof(recCmppPck));
		memset(&rCmppPckResp, 0, sizeof(recCmppPck));
		memset(&rCmppPckDelivery, 0, sizeof(recCmppPck));
		nRet = nMSgRecv(nSockId, sTmp, 1);
		if(nRet < 0)
		{
			printf("nMSgRecv error \n");

			nTcpClose(nSockId);
			
			#ifdef WIN32
				return -1;
			#endif
			#if defined(_HPUX_SOURCE) || defined(_LINUX_SOURCE)
				return (void *)-1;
			#endif
		}
		if(nRet == 0)
		{
			#ifdef WIN32
				Sleep(1);
			#endif
			#if defined(_HPUX_SOURCE) || defined(_LINUX_SOURCE)
				usleep(1);
			#endif
			continue;
		}	
		//printf("Receive pack Success \n");

		//printf("pack len = %d \n", nRet+MacIntLen);
		//vFormatPrintBin(stdout, sTmp, nRet+MacIntLen);
		
		nRet = nCmppDecode(sTmp, nRet+MacIntLen, &rCmppPck);

		if(nRet !=0 )
		{
			printf("nCmppDecode Error, errorno = %d\n", nRet);
		}
		else
		{
			nSum++;
			if( nSum % 100 == 0 )
			{
				printf( "Recv  a [%x] [%d] Package \n", 
					rCmppPck.rHead.unCommandId,
					nSum );
			}
			if( rCmppPck.rHead.unCommandId == MacC_SubmitRqst )
			{
				//sleep( 14 );
				usleep( 200*1000 );
			}
		}	

		vPrintCmppPack(rCmppPck);
		
		nRet = nMakeResponse(&rCmppPckResp, &rCmppPck,nRet);
		if(nRet != 0)
		{
			printf("nMakeResponse error");
			continue;
		}
		
		memset(sTmp, 0, sizeof(sTmp));
		

		vPrintCmppPack(rCmppPckResp);
		
		nRet = nCmppEncode(&rCmppPckResp, sTmp, &nLen);	
		if(nRet != 0)
		{
			printf("nCmppEncode error, errorno = %d \n",nRet); 
			continue;
		}
		//printf(" send Pack Len = %d \n", nLen);
		//vFormatPrintBin(stdout, sTmp, nLen);
		
		nRet = nTcpSend(nSockId, sTmp, nLen);
		if(nRet < 0)
		{
			printf( "socket send error, socketId=%d, errno=%d",nSockId, errno);
			nTcpClose(nSockId);
			#ifdef WIN32
				return -1;
			#endif
			#if defined(_HPUX_SOURCE) || defined(_LINUX_SOURCE)
				return (void *)-1;
			#endif
		}

		if(rCmppPck.rHead.unCommandId == MacC_SubmitRqst && rCmppPck.body.rCmppSubmit.ucRegisterDelivery ==1)
	      {
	      		vComposeDeliveryReport(&rCmppPckDelivery, &rCmppPck);
	      		vPrintCmppPack(rCmppPckDelivery);
			memset(sTmp, 0, sizeof(sTmp));
			nRet = nCmppEncode(&rCmppPckDelivery, sTmp, &nLen);	
			if(nRet != 0)
			{
				printf("nCmppEncode error, errorno = %d \n",nRet); 
				continue;
			}
			//printf(" send Pack Len = %d \n", nLen);
			//vFormatPrintBin(stdout, sTmp, nLen);
			
			nRet = nTcpSend(nSockId, sTmp, nLen);
			if(nRet < 0)
			{
				printf( "socket send error, socketId=%d, errno=%d",nSockId, errno);
				nTcpClose(nSockId);
				#ifdef WIN32
					return -1;
				#endif
				#if defined(_HPUX_SOURCE) || defined(_LINUX_SOURCE)
					return (void *)-1;
				#endif
			}

			
		      		
	      }
		
		//printf(" socket End Send send len = %d\n", nRet);
	}
}
#if defined(_HPUX_SOURCE) || defined(_LINUX_SOURCE)
		pthread_t h;
#endif

#ifdef WIN32
		WSADATA wsaData;
#endif

void vMarkSign()
{
#ifndef WIN32
    signal(SIGTERM,SIG_IGN);
    signal(SIGHUP,SIG_IGN);
    signal(SIGPIPE,SIG_IGN);
    signal(SIGALRM,SIG_IGN);    
    signal(SIGURG,SIG_IGN);
    signal(SIGCONT,SIG_IGN);
    signal(SIGCHLD,SIG_IGN);
    signal(SIGTTIN,SIG_IGN);
    signal(SIGTTOU,SIG_IGN);
    signal(SIGIO,SIG_IGN);
#endif
}
int main(int argc, char* argv[])
{
	int nRet;
	int nSock = -1;
	int nCltSock;
	
	#ifdef WIN32
		if (WSAStartup((WORD)((2<<8)|2), &wsaData))
		{
			printf("Fail load socket library.\n");
			return -1;
		}
	#endif
	vMarkSign();
	nSock = nTcpServer(MacPort);
	//nSock = nTcpConnect("10.1.2.242", 22235);
	if (nSock == -1)
	{
		printf("Fail to create TCP Server.\n");
		return -1;
	}

	while (1)
	{
		char chCltIp[128];
		
		memset(chCltIp, 0, sizeof(chCltIp));
		nCltSock = nTcpAccept(nSock, chCltIp);
		if (nCltSock <= 0)
			break;

		printf( "accept a connection from %s.nCltSock: %d \n", chCltIp, nCltSock);

#ifdef WIN32
		CreateThread(NULL,
			         0,
					 pvCmppApiThread,
					 &nCltSock,
					 0,
					 NULL);
		Sleep(500);
#endif

#if defined(_HPUX_SOURCE) || defined(_LINUX_SOURCE)
		nRet = pthread_create(&h,
			           NULL,
					   pvCmppApiThread,
					   &nCltSock);
		if(nRet != 0)
		{
			printf("create Thread failed , error= %d\n", nRet);
			perror("fail");
			nTcpClose(nSock);
			return -1;
		}
		usleep(500);
#endif
	}

#ifdef WIN32
	WSACleanup();
#endif

	nTcpClose(nSock);

	return 0;
	
}