berencoder.cpp

Mysql的处理

// BEREncoder.cpp: implementation of the CBEREncoder class.
//
//////////////////////////////////////////////////////////////////////

#include "BEREncoder.h"
#include "BEREncodeHead.h"
#include "ASN1Tag.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
namespace ASN1
{
	CBEREncoder::CBEREncoder()
	{
	}
	
	CBEREncoder::~CBEREncoder()
	{
	}
	
	
	bool CBigInt::Divide16(const char* szStream, char* base, int &baselen, int& result)
	{
		char* szIn = (char*) szStream;
		
		int len= strlen(szStream);
		
		int res(0),m(0);
		
		int index=0;
		char tmp;
		bool found(false);
		
		if(len<=0)
			return false;
		
		for(int i=0;i<len;i++)
		{
			char c = szIn[i]-'0';
			
			res = res*10+c;
			tmp = res/16;
			if(!found)
			{
				if(tmp != 0)
				{
					base[index]=tmp+'0';
					index++;
					found = true;
				}
			}
			else
			{
				base[index]=tmp+'0';
				index++;
			}
			
			res = res%16;
			
			m++;
		}
		
		
	//	printf("%d\n" , res);
		result = res;
		baselen = index;
		return true;
	}
	

	void Reverse(char* sz, int &length)
	{
		char tmp[60];
		memset(tmp,0,60);

		int i;
		for(i=0;i<length/2;i++)
		{
			if(length==1)
			{
				break;
			}
			char t = sz[i];
			sz[i]=sz[length-i-1];
			sz[length-i-1] = t;
		}

		bool odd(false);

		int len1 = length/2;
		if(length %2 == 1)
		{
			odd = true;
			len1 += 1;
		}

		int pos (0);
		for(i=0;i<len1;i++)
		{
			if(odd)
			{
				if(i==0)
				{
					tmp[i]=sz[pos];
					pos ++;
				}
				else
				{
					tmp[i] = sz[pos]<<4|sz[pos+1];
					pos+=2;
				}
			}
			else
			{
				tmp[i]= sz[pos]<<4|sz[pos+1];
				pos += 2;
			}
		}
		
		memcpy(sz, tmp, len1);
		length=len1;
	}
	
	bool CBigInt::Encode(const char* szStream, char res[20], int &length)
	{
		char* szIn = (char*) szStream;
		
		int len= strlen(szStream);
		if(len<=0)
			length = 0;
		
		char r1[23];
		char r2[23];
		
		memset(r1, 0, 23);

	//	if(szStream[0] != '-')
		memcpy(r1, szStream, strlen(szStream));
	//	else
	//		memcpy(r1, &szStream[1], strlen(szStream)-1);

		int rl1;
		int r;
		length = 0;

		int trys = 128;

		for(int j=0;j<trys;j++)
		{
			memset(r2, 0, sizeof(r2));
			
			if(!Divide16(r1,r2, rl1, r))
				break;
			
				memcpy(r1, r2 , sizeof(r2));
			
			//	for(int i=0;i<rl1;i++)
				{
			//		printf("%d ", r1[i]-'0');
				}
			//	printf("\n");
			
			res[j] = r;
			length = j+1;
		}
		
		Reverse(res, length);
		
		return true;
	}
	
	
	bool CBEREncoder::encodeBlank(char *tag, int tagLen, int nLength, int &nOutLength)
	{
		int start = m_nPos;
		encodeLength(nLength);
		writeStream(tag, tagLen);
		int end = m_nPos;
		nOutLength = end - start;
		
		return true;
	}
	
	bool CBEREncoder::encodeTransparent(char *tag, int tagLen, char* pData, int nLength, int &nOutLength)
	{
		int start = m_nPos;
		writeStream(pData, nLength);
		encodeLength(nLength);
		writeStream(tag, tagLen);
		int end = m_nPos;
		nOutLength = end - start;
		return true;
	}
	
	bool CBEREncoder::encodeBool(bool bIn, int &nOutLength, char *tag, int tagLen)
	{
		int start = m_nPos;
		writeStream(bIn ? 0xFF : 0x00);
		encodeLength(1);
		
		if(tag != NULL)
			writeStream(tag, tagLen);
		else
			encodeTag(CASN1Tag::TAG_BOOLEAN, false);
		
		int end = m_nPos;
		nOutLength = end - start;
		return true;
	}
	
	bool CBEREncoder::encodeBCDString(const char* szIn, int &nOutLength, char *tag, int tagLen)
	{
		int start = m_nPos;
		char result[12];
		int j=0,i=0;
		int s,t;
		int length;
		unsigned char temp[128];
		length=strlen(szIn);
		memcpy(temp,szIn,length);
		temp[length]=0;
		
		if (length%2==1)
		{
			//result =new char[2*nLength+1];
			for(;j<length-1;)
			{
				s=(int)(temp[j++]-48);
				t=(int)(temp[j++]-48);
				result[i++]=t*16+s;
			}
			s=(int)(temp[j++]-48);
			t=0xf;
			result[i++]=t*16+s;
			result[i]=0;
		}
		else
		{
			for(;j<length;)
			{
				s=(int)(temp[j++]-48);
				t=(int)(temp[j++]-48);
				result[i++]=t*16+s;
			}
			result[i]=0;
			
		}
		//nOutLength=i;
		writeStream(result,i);
		encodeLength(i);
		if(tag != NULL)
			writeStream(tag, tagLen);
		else
			encodeTag(CASN1Tag::TAG_OCTET_STRING, false);
		int end = m_nPos;
		nOutLength = end - start;
		return true;
		
	}
	
	
/*	bool CBEREncoder::encodeIntTo(const char* szIn, int &nOutLength, char *tag, int tagLen)
	{
		int start = m_nPos;
		int t,s;
		int nBodyLength,nLength;
		char pBodyString[16];
		char ppBodyString[16];
		char temp[16];
		int j=0,k=0;//,l;
		// uInt;
		
		CBigInt::Encode(szIn, pBodyString, nBodyLength);
		writeStream(pBodyString, nBodyLength);
//		writeStream(ppBodyString, nBodyLength);
		encodeLength(nBodyLength);
		if(tag != NULL)
			writeStream(tag, tagLen);
		else
			encodeTag(CASN1Tag::TAG_INTEGER, false);
		int end = m_nPos;
		nOutLength = end - start;
		return true;
	}
*/	
	bool CBEREncoder::encodeIntTo(const char* szIn, int &nOutLength, char *tag, int tagLen)
	{
		int start = m_nPos;
		int t=0,s=0,count=0;
		int nBodyLength;//,nLength;
		char pBodyString[50];
		int value[50],base16=16;
		unsigned int result[50];
		int valueTemp[50];
		unsigned int temp[50];
		int j=0,k=0,k0=0,len;//,l;
		// uInt;
		
		if(szIn[0]=='-'){
			len=strlen(&szIn[1]);
			
			for(int i=0;i<len;i++)
				value[i]=szIn[i+1]-48;
			
			for(i=0;i<len;i++)
			{
				t=value[i];
				for(j=i+1;j<len;j++)
				{
					valueTemp[j]=(t*10+value[j])/16;
					t=(t*10+value[j])%16;
					value[j]=valueTemp[j];
				}
				result[i]=t;
				
			}
			////////////////////////////////////////////////////////////////
			int flag0=1;
			
			for(i=len-1;i>=0;i--)
			{
				if ((result[i]!=0)&&(flag0==1))flag0=0;
				if (flag0==0)
					temp[count++]=result[i];
			}
			////////////////////////////////////////////////////////
			j=0;
			pBodyString[j++]=(char)0xff;
			if ((count%2)==1)
			{
				pBodyString[j++]=(temp[0]^0xff);//+0x1;
				k0=1;
				//pBodyString[j]=0;
			}
			
			
			for(k=k0;k<count;k+=2)
				pBodyString[j++]=(unsigned char)((temp[k]*16+temp[k+1])^0xff);
			pBodyString[j-1]+=0x1;
		}
		else
		{
			
			len=strlen(szIn);
			for(int i=0;i<len;i++)
				value[i]=szIn[i]-48;
			
			for(i=0;i<len;i++)
			{
				t=value[i];
				for(j=i+1;j<len;j++)
				{
					valueTemp[j]=(t*10+value[j])/16;
					t=(t*10+value[j])%16;
					value[j]=valueTemp[j];
				}
				result[i]=t;
				
			}
			int flag0=1;
			
			for(i=len-1;i>=0;i--)
			{
				if ((result[i]!=0)&&(flag0==1))flag0=0;
				if (flag0==0)
					temp[count++]=result[i];
			}
			////////////////////////////////////////////////////////
			j=0;
			/////////////////////////////////////////////////
			if ((count%2)==1)
			{
				pBodyString[j++]=temp[0];//+0x1;
				k0=1;
			}
			
			
			//////////////////////////////////////////////////////////////
			for(k=k0;k<count;k+=2)
				pBodyString[j++]=(unsigned char)(temp[k]*16+temp[k+1]);
			
			
		}	
		pBodyString[j]=0;
		nBodyLength=j;
		writeStream(pBodyString, nBodyLength);
		encodeLength(nBodyLength);
		if(tag != NULL)
			writeStream(tag, tagLen);
		else
			encodeTag(CASN1Tag::TAG_INTEGER, false);
		int end = m_nPos;
		nOutLength = end - start;
		return true;
	}
	
	
	bool CBEREncoder::encodeInt(int nIn, int &nOutLength, char *tag, int tagLen)
	{
		int start = m_nPos;

		int t,s;
		int nBodyLength,nLength;
		int j=0;//,l;
		// uInt;
		char strtemp[20];
		char str[20];
		char pBodyString[8];
		
			
	
		sprintf(strtemp,"%x\0",nIn);
		strcpy(str,strtemp);
		if((strlen(strtemp)%2)==1)
			sprintf(str,"%d%s",0,strtemp);//sprintf(str,"%d%s\0",0,strtemp);
		
		//nBodyLength=strlen(str);
		//pBodyString =new char[strlen(str)/2];
		if(nIn>=0)
		{
			pBodyString[j++]=0;
		}
		
		for(int k=0;k<strlen(str);k+=2){
			//	cout<<"\nstr["<<k<<"]:"<<str[k]<<"   str["<<k+1<<"]:"<<str[k+1]<<endl;
			if((str[k]>='A')&&(str[k]<='F'))
				t=str[k]-57;
			else if((str[k]>='a')&&(str[k]<='f'))
				t=str[k]-87;
			else if ((str[k]>='0')&&(str[k]<='9'))
				t=str[k]-48;
			else 
				continue;
			
			if((str[k+1]>='A')&&(str[k+1]<='F'))
				s=str[k+1]-57;
			else if((str[k+1]>='a')&&(str[k+1]<='f'))
				s=str[k+1]-87;
			else if((str[k+1]>='0')&&(str[k+1]<='9'))
				s=str[k+1]-48;
			else
				continue;
			pBodyString[j++]=t*16+s;
			
		};		//
		
		pBodyString[j+1]='\0';
		nBodyLength=j;