casocket.cpp

用于处理证书请求,生成证书的CA服务器源码,

#include "caSocket.h"
#include "certextern.h"

caSocket::caSocket()
{
}

caSocket::~caSocket()
{
}

//从网络接收字符流，转换成结构的字节流后，返回字节流的字节数
int caSocket::ExpRead(void *pData, int nBufLen)
{
	int nDataLen;

	memset(pData,0,nBufLen);
	nDataLen = CaRead(pData,nBufLen);
	if(nDataLen < 0)
		return nDataLen;

	if(g_nDebug)
		printf("Recv %d Bytes,INFO=%s\n",nDataLen,pData);

	nDataLen = ParsePK(pData,nDataLen,nBufLen);

	return nDataLen;
}

//将结构的字节流转换成字符流后发送，返回字符流的字节数
int caSocket::ExpWrite(void *pData,int nDataLen)
{
	int	nCurrLen;
	char	*p;
	int nRtn=0;

	p = (char *)malloc(nDataLen * 2);
	if(p == NULL)
		return -1008;		//caSocket::ExpWrite 分配内存错误

	memset(p,0,nDataLen*2);
	memcpy(p,pData,nDataLen);

	nCurrLen = AssemblePK(p,nDataLen,nDataLen*2);

	if(g_nDebug)
		printf("Send %d Bytes,INFO=%s\n",nCurrLen,p);

	nRtn = CaWrite(p,nCurrLen);
	if(p)
		free(p);
	return nRtn;
}


//读取原始字符流，返回读取的字符数
int caSocket::CaRead(void *pData, int nLen)
{
	CAPKHEAD capkhead;
	int nRtn;
	unsigned int nPkType;
	unsigned int nPkLen;
	char	szTmp[9];

	nRtn = Read(&capkhead,CAPKHEAD_LEN);
	if(nRtn == 0)	
	{
		return -1010;	//caSocket::CaRead Read error
	}
	
	memset(szTmp,0,sizeof(szTmp));
	memcpy(szTmp,capkhead.Type,sizeof(capkhead.Type));
	nPkType = atoi(szTmp);

	memset(szTmp,0,sizeof(szTmp));
	memcpy(szTmp,capkhead.Len,sizeof(capkhead.Len));
	nPkLen  = atoi(szTmp);

	memcpy(pData,&capkhead,CAPKHEAD_LEN);
	nRtn = Read((char *)pData+CAPKHEAD_LEN,nPkLen);
	if(nRtn == 0)	//Read error
	{
		return -1015;	//caSocket::CaRead Read error
	}
	return nPkLen + CAPKHEAD_LEN; 
}


//发送字符流。返回发送字符数
int caSocket::CaWrite(const void *pData,int nLen)
{
	
	return (Write(pData,nLen));
}


int caSocket::AssemblePK(void *pData,int nDataLen,int nBufLen)
{
	CAPKHEAD capkhead;
	CASTHEAD casthead;
	int		 nRemainLen=0;
	int		 nRtn=0,nRtnLen=0; 
	int nValid=0;

	memcpy(&casthead,pData,CASTHEAD_LEN);
	memset(&capkhead,0,CAPKHEAD_LEN);
	sprintf(capkhead.Head,"%.4s",casthead.sHead);
	sprintf(capkhead.Type,"%08d",casthead.nType);
	sprintf(capkhead.Len,"%08d",casthead.nLen);

	if(nDataLen != (int)CASTHEAD_LEN + casthead.nLen)
		return -1030;		//caSocket::AssemblePK 报文长度错误

	nRemainLen=nBufLen - CASTHEAD_LEN - 1;		//剩余可用空间

	char *p = (char *)pData + CAPKHEAD_LEN;

	switch(casthead.nType){
	case ISSUECERTRT_TMP:

		ISUCERT isucert;
		memset(&isucert,0,sizeof(isucert));
		memcpy(&isucert,(char *)pData+CASTHEAD_LEN,ISUCERT_LEN);

		memset(pData,0,nBufLen);
		while(1)
		{
			nRemainLen -= strlen(isucert.name)+1;
			if(nRemainLen < 0)
				return -5;	
			strcat(p,isucert.name);
			strcat(p,"\t");

			nRemainLen -= strlen(isucert.email)+1;
			if(nRemainLen < 0)
				return -5;
			strcat(p,isucert.email);
			strcat(p,"\t");

			nRemainLen -= strlen(isucert.company)+1;
			if(nRemainLen < 0)
				return -5;
			strcat(p,isucert.company);
			strcat(p,"\t");

			nRemainLen -= strlen(isucert.department)+1;
			if(nRemainLen < 0)
				return -5;
			strcat(p,isucert.department);
			strcat(p,"\t");

			nRemainLen -= strlen(isucert.city)+1;
			if(nRemainLen < 0)
				return -5;
			strcat(p,isucert.city);
			strcat(p,"\t");

			nRemainLen -= strlen(isucert.prov)+1;
			if(nRemainLen < 0)
				return -5;
			strcat(p,isucert.prov);
			strcat(p,"\t");

			nRemainLen -= strlen(isucert.country)+1;
			if(nRemainLen < 0)
				return -5;
			strcat(p,isucert.country);
			strcat(p,"\t");

			nRemainLen -= strlen(isucert.cellno)+1;
			if(nRemainLen < 0)
				return -5;
			strcat(p,isucert.cellno);
			strcat(p,"\t");

			nRemainLen -= strlen(isucert.ukserial)+1;
			if(nRemainLen < 0)
				return -5;
			strcat(p,isucert.ukserial);
			strcat(p,"\t");

			nRemainLen -= strlen(isucert.account)+1;
			if(nRemainLen < 0)
				return -5;
			strcat(p,isucert.account);
			strcat(p,"\t");

			nRemainLen -= strlen(isucert.pkcs10)+1;
			if(nRemainLen < 0)
				return -5;
			strcat(p,isucert.pkcs10);
			strcat(p,"\n");

			break;
		}//end while
		if(nRtn < 0)
			return -5;		//缓存不足
		
		sprintf(capkhead.Len,"%08d",strlen((char *)p));
		memcpy((char *)pData,&capkhead,CAPKHEAD_LEN);
		memcpy((char *)pData+CAPKHEAD_LEN,p,strlen((char *)p));
		nRtnLen = (int)CAPKHEAD_LEN + strlen((char *)p);
		break;


	case VERISIGNRT_TMP:

		VERIFYSIGN verifysign;
		memset(&verifysign,0,sizeof(verifysign));
		memcpy(&verifysign,(char *)pData+CASTHEAD_LEN,ISUCERT_LEN);


		memset(pData,0,nBufLen);
		while(1)
		{
			nRemainLen -= strlen(verifysign.serial)+1;
			if(nRemainLen < 0)
				return -5;
			strcat(p,verifysign.serial);
			strcat(p,"\t");

			nRemainLen -= strlen(verifysign.signature)+1;
			if(nRemainLen < 0)
				return -5;
			strcat(p,verifysign.signature);
			strcat(p,"\t");

			nRemainLen -= strlen(verifysign.randomstr)+1;
			if(nRemainLen < 0)
				return -5;
			strcat(p,verifysign.randomstr);
			strcat(p,"\n");

			break;
		}//end while
		if(nRtn < 0)
			return -5;		//缓存不足
		
		sprintf(capkhead.Len,"%08d",strlen((char *)p));
		memcpy((char *)pData,&capkhead,CAPKHEAD_LEN);
		memcpy((char *)pData+CAPKHEAD_LEN,p,strlen((char *)p));
		nRtnLen = (int)CAPKHEAD_LEN + strlen((char *)p);
		break;

	case ISSUECERTRT:

		HAVEISUCERT haveisucert;
		memset(&haveisucert,0,sizeof(haveisucert));

		if(nDataLen == CASTHEAD_LEN + HAVEISUCERT_LEN)
		memcpy(&haveisucert,(char *)pData+CASTHEAD_LEN,HAVEISUCERT_LEN);
		
		memset(pData,0,nBufLen);

		nRemainLen -= strlen(haveisucert.certserial)+1;
		if(nRemainLen < 0)
				return -1035;	//caSocket::AssemblePK ISSUECERTRT报文长度错误
		strcat(p,haveisucert.certserial);
		strcat(p,"\t");

		nRemainLen -= strlen(haveisucert.pkcs7)+1;
		if(nRemainLen < 0)
			return -1040;		//caSocket::AssemblePK ISSUECERTRT报文长度错误
		strcat(p,haveisucert.pkcs7);
		strcat(p,"\n");

		sprintf(capkhead.Len,"%08d",strlen((char *)p));
		memcpy((char *)pData,&capkhead,CAPKHEAD_LEN);
		memcpy((char *)pData+CAPKHEAD_LEN,p,strlen((char *)p));
		nRtnLen = (int)CAPKHEAD_LEN + strlen((char *)p);
		break;
	

	case DECRYPTPWDRT:

		char	szPWD[128];

		memset(szPWD,0,sizeof(szPWD));
		memcpy(szPWD,((char *)pData+CASTHEAD_LEN),sizeof(szPWD)-1);
		memset(pData,0,nBufLen);

		nRemainLen -= strlen((char *)pData+CASTHEAD_LEN)+1;
		if(nRemainLen < 0)
				return -1050;		//caSocket::AssemblePK VERISIGNRT报文长度错误
		sprintf(p,"%s",szPWD);
		strcat(p,"\n");

		sprintf(capkhead.Len,"%08d",strlen((char *)p));
		memcpy((char *)pData,&capkhead,CAPKHEAD_LEN);
		memcpy((char *)pData+CAPKHEAD_LEN,p,strlen((char *)p));
		nRtnLen = (int)CAPKHEAD_LEN + strlen((char *)p);
		break;


	case VERISIGNRT:

		if(nDataLen == CASTHEAD_LEN + sizeof(nValid))
		memcpy(&nValid,(char *)pData+CASTHEAD_LEN,sizeof(nValid));
		
		memset(pData,0,nBufLen);

		nRemainLen -= 2*sizeof(nValid)+1;
		if(nRemainLen < 0)
				return -1050;		//caSocket::AssemblePK VERISIGNRT报文长度错误
		sprintf(p,"%08d",nValid);
		strcat(p,"\n");

		sprintf(capkhead.Len,"%08d",strlen((char *)p));
		memcpy((char *)pData,&capkhead,CAPKHEAD_LEN);
		memcpy((char *)pData+CAPKHEAD_LEN,p,strlen((char *)p));
		nRtnLen = (int)CAPKHEAD_LEN + strlen((char *)p);
		break; 


	default:
		sprintf(capkhead.Head,"%.4s","4GCA");
		sprintf(capkhead.Type,"%08d",0L);
		sprintf(capkhead.Len,"%08d",0L);
		nRtnLen = 20;	//caSocket::AssemblePK 类型错
		break;
	}

	return nRtnLen;
}

//分析接收报文，将字符串转换成结构数据，返回结构数据长度
int caSocket::ParsePK(void *pData,int nDataLen,int nBufLen)
{
	CAPKHEAD capkhead;
	CASTHEAD casthead;
	int		nLen,i;
	char	szTmp[10];
	char	chDeli='\t';
	char	chEnd ='\n';
	char *p,*q;

	if(nBufLen < nDataLen)
		return -1100;		//caSocket::ParsePK 缓冲区长度错

	memcpy(&capkhead,pData,CAPKHEAD_LEN);

	memcpy(casthead.sHead,capkhead.Head,sizeof(casthead.sHead));
	
	memset(szTmp,0,sizeof(szTmp));
	memcpy(szTmp,capkhead.Type,sizeof(casthead.nType)*2);
	casthead.nType = atoi(szTmp);

	memset(szTmp,0,sizeof(szTmp));
	memcpy(szTmp,capkhead.Len,sizeof(casthead.nLen)*2);
	casthead.nLen = atoi(szTmp);

	
	if(casthead.nLen != nDataLen - (int)CAPKHEAD_LEN)
		return -1105;		//caSocket::ParsePK 长度错

	if((char) *((char *)pData + nDataLen - 1) != '\n')	
		return -1110;		//caSocket::ParsePK 报文结束错误
//	else
//		(char) *((char *)pData + nDataLen - 1) = '\0';	//置为0

//	void *p = strtok((char *)pData + CAPKHEAD_LEN,"\t");
	p = (char *)pData + CAPKHEAD_LEN;
	switch(casthead.nType){
	case ISSUECERT:

		ISUCERT isucert;
		memset(&isucert,0,sizeof(isucert));

		for(i=0;i<11;i++)
		{
			q=strchr(p,chDeli);
			if(q)
				*q = '\0';
			else
			{
				q=strchr(p,chEnd);
				if(q)
					*q = '\0';
				else
					return -1115;	//caSocket::ParsePK 报文结束错误
			}
			switch(i)
			{
			case 0:
				strncpy(isucert.name,(char *)p,sizeof(isucert.name)-1);
				break;
			case 1:
				strncpy(isucert.email,(char *)p,sizeof(isucert.email)-1);
				break;
			case 2:
				strncpy(isucert.company,(char *)p,sizeof(isucert.company)-1);
				break;
			case 3:
				strncpy(isucert.department,(char *)p,sizeof(isucert.department)-1);
				break;
			case 4:
				strncpy(isucert.city,(char *)p,sizeof(isucert.city));
				break;
			case 5:
				strncpy(isucert.prov,(char *)p,sizeof(isucert.prov));
				break;
			case 6:
				strncpy(isucert.country,(char *)p,sizeof(isucert.country));
				break;
			case 7:
				strncpy(isucert.cellno,(char *)p,sizeof(isucert.cellno)-1);
				break;
			case 8:
				strncpy(isucert.ukserial,(char *)p,sizeof(isucert.ukserial)-1);
				break;
			case 9:
				strncpy(isucert.account,(char *)p,sizeof(isucert.account)-1);
				break;
			case 10:
				strncpy(isucert.pkcs10,(char *)p,sizeof(isucert.pkcs10)-1);
				break;
			default:
				break;
			}
			p=q+1;
		}

		casthead.nLen = ISUCERT_LEN;
		memcpy((char *)pData,&casthead,sizeof(casthead));
		memcpy((char *)pData+CASTHEAD_LEN,&isucert,sizeof(isucert));
		nLen = (int)CASTHEAD_LEN + (int)ISUCERT_LEN;
		break;


	
		case DECRYPTPWD:

		char szCPWD[200];
		memset(szCPWD,0,sizeof(szCPWD));
		for(i=0;i<1;i++)
		{
			q=strchr(p,chDeli);
			if(q)
				*q = '\0';
			else
			{
				q=strchr(p,chEnd);
				if(q)
					*q = '\0';
				else
					return -1120;	//caSocket::ParsePK 报文结束错误
			}


			switch(i)
			{
			case 0:
				strncpy(szCPWD,(char *)p,sizeof(szCPWD)-1);
				break;
			default:
				break;
			}
			p=q+1;
		}

		memset(pData,0,nBufLen);
		casthead.nLen = strlen(szCPWD);
		memcpy((char *)pData,&casthead,sizeof(casthead));
		memcpy((char *)pData+CASTHEAD_LEN,szCPWD,strlen(szCPWD));
		nLen = (int)CASTHEAD_LEN + strlen(szCPWD);
		break;

		case VERISIGN:

		VERIFYSIGN verifysign;
		memset(&verifysign,0,sizeof(verifysign));

		for(i=0;i<3;i++)
		{
			q=strchr(p,chDeli);
			if(q)
				*q = '\0';
			else
			{
				q=strchr(p,chEnd);
				if(q)
					*q = '\0';
				else
					return -1120;	//caSocket::ParsePK 报文结束错误
			}


			switch(i)
			{
			case 0:
				strncpy(verifysign.serial,(char *)p,sizeof(verifysign.serial)-1);
				break;
			case 1:
				strncpy(verifysign.signature,(char *)p,sizeof(verifysign.signature)-1);
				break;
			case 2:
				strncpy(verifysign.randomstr,(char *)p,sizeof(verifysign.randomstr)-1);
				break;
			default:
				break;
			}
			p=q+1;
		}

		casthead.nLen = VERIFYSIGN_LEN;
		memcpy((char *)pData,&casthead,sizeof(casthead));
		memcpy((char *)pData+CASTHEAD_LEN,&verifysign,sizeof(verifysign));
		nLen = (int)CASTHEAD_LEN + (int)VERIFYSIGN_LEN;
		break;

	default:
		return -1120;	//caSocket::ParsePK 报文类型错误
	}

	return nLen;
}