base64coder.c

在嵌入式linux下发送邮件的SMTP客户端程序。基于mips平台可直接使用

#include "Base64Coder.h"

#include <string.h>
#include <malloc.h>
#include <time.h>
#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <ctype.h>

//////////////// 宏和变量定义/////////////////////////////////////

static char	Base64Digits[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
//BOOL m_Init		= TFALSE;
//char m_DecodeTable[256];

#ifndef PAGESIZE
#define PAGESIZE					4096
#endif

#ifndef ROUNDTOPAGE
#define ROUNDTOPAGE(a)			(((a/4096)+1)*4096)
#endif


void Clear(TempBucket* pTempBucket) 
{ 
	memset((pTempBucket->nData), 0, 4);
	pTempBucket->nSize = 0;
}

//构造函数
void Base64CoderInit(Base64Coder *BaseCoder)
{

	BaseCoder->m_pDBuffer = BASE_NULL;
	BaseCoder->m_pEBuffer = BASE_NULL;

	BaseCoder->m_nDBufLen = 0;
	BaseCoder->m_nEBufLen = 0;
		
}

//析构函数
void Base64CoderRealse(Base64Coder *BaseCoder)
{
	if (BaseCoder->m_pDBuffer != BASE_NULL)
  {
		free(BaseCoder->m_pDBuffer);
    BaseCoder->m_pDBuffer = BASE_NULL;
  }

	if (BaseCoder->m_pEBuffer != BASE_NULL)
  {
		free(BaseCoder->m_pEBuffer);
    BaseCoder->m_pEBuffer = BASE_NULL;
  }
}

char* DecodedMessage(Base64Coder BaseCoder) 
{ 
	return (char*) BaseCoder.m_pDBuffer;
}

char* EncodedMessage(Base64Coder BaseCoder)
{ 
	return (char*) BaseCoder.m_pEBuffer;
}

long DecodedMessageSize(Base64Coder BaseCoder)
{ 
	return BaseCoder.m_nDDataLen;
}

long EncodedMessageSize(Base64Coder BaseCoder)
{ 
	return BaseCoder.m_nEDataLen;
}

//给编码缓冲区分配指定大小的空间
void AllocEncode(Base64Coder *BaseCoder, int nSize)
{
	if(BaseCoder == NULL)
	{
			return;
	}
	
	if (BaseCoder->m_nEBufLen < nSize)
	{
		if (BaseCoder->m_pEBuffer != BASE_NULL)
			free(BaseCoder->m_pEBuffer);

		BaseCoder->m_nEBufLen = ROUNDTOPAGE(nSize);
		BaseCoder->m_pEBuffer = (unsigned char*)malloc(BaseCoder->m_nEBufLen);
	}

	memset(BaseCoder->m_pEBuffer,0,  BaseCoder->m_nEBufLen);
	BaseCoder->m_nEDataLen = 0;
}

//给解码缓冲区分配指定大小的空间
void AllocDecode(Base64Coder *BaseCoder, int nSize)
{
	if(BaseCoder == NULL)
	{
			return;
	}
	
	if (BaseCoder->m_nDBufLen < nSize)
	{
		if (BaseCoder->m_pDBuffer != BASE_NULL)
			free(BaseCoder->m_pDBuffer);

		BaseCoder->m_nDBufLen = ROUNDTOPAGE(nSize);
		//strcpy(BaseCoder->m_pDBuffer, (unsigned char*)mallocBaseCoder->m_nDBufLen);
		BaseCoder->m_pDBuffer = (unsigned char*)malloc(BaseCoder->m_nDBufLen);
	}

	memset(BaseCoder->m_pDBuffer, 0, BaseCoder->m_nDBufLen);
	BaseCoder->m_nDDataLen = 0;
}

//将指定的数据填入到编码缓冲区
void SetEncodeBuffer(Base64Coder *BaseCoder, const unsigned char* pBuffer, int nBufLen)
{
	int	i = 0;
	
	if(BaseCoder == NULL)
	{
			return;
	}
	
	AllocEncode(BaseCoder, nBufLen);
	while(i < nBufLen)
	{
		//判断是否是非法数据
		if (!_IsBadMimeChar(pBuffer[i]))
		{
			BaseCoder->m_pEBuffer[BaseCoder->m_nEDataLen] = pBuffer[i];
			BaseCoder->m_nEDataLen++;
		}
		i++;
	}
}

//将指定的数据填入到解码缓冲区
void SetDecodeBuffer(Base64Coder *BaseCoder, const unsigned char*  pBuffer, int nBufLen)
{
	if(BaseCoder == NULL)
	{
			return;
	}
	
	AllocDecode(BaseCoder, nBufLen);
	memcpy(BaseCoder->m_pDBuffer, pBuffer, nBufLen);
	BaseCoder->m_nDDataLen = nBufLen;
}

void EncodeBase(Base64Coder *BaseCoder, const unsigned char*  pBuffer, int nBufLen)
{
	
	TempBucket Raw;
	int	nIndex	= 0;
	
	SetDecodeBuffer(BaseCoder, pBuffer, nBufLen);
	AllocEncode(BaseCoder, nBufLen * 2);	

	while ((nIndex + 3) <= nBufLen)
	{
		memset(Raw.nData, 0, 4); 
		Raw.nSize = 0; 
		memcpy(&Raw, BaseCoder->m_pDBuffer + nIndex, 3);
		Raw.nSize = 3;
		_EncodeToBuffer(&Raw, BaseCoder->m_pEBuffer + BaseCoder->m_nEDataLen);
		nIndex += 3;
		BaseCoder->m_nEDataLen	+= 4;
	}

	if (nBufLen > nIndex)
	{
		Clear(&Raw);
		Raw.nSize = (unsigned char) (nBufLen - nIndex);
		memcpy(&Raw,BaseCoder-> m_pDBuffer + nIndex, nBufLen - nIndex);
		_EncodeToBuffer(&Raw, BaseCoder->m_pEBuffer + BaseCoder->m_nEDataLen);
		BaseCoder->m_nEDataLen += 4;
	}
}

void Encode(Base64Coder *BaseCoder, const char* szMessage)
{
	int		nCmdLength = 0;
	nCmdLength = strlen(szMessage);
	if (szMessage != BASE_NULL)
	{
		EncodeBase(BaseCoder, (const unsigned char* )szMessage, nCmdLength);
	}
}

void DecodeBase(Base64Coder *BaseCoder, const unsigned char*  pBuffer, int dwBufLen)
{
	int i = 0;
	TempBucket Raw;
	int	nIndex = 0;
	
	if (!BaseCoder->m_Init)
		_Init(BaseCoder);

	SetEncodeBuffer(BaseCoder, pBuffer, dwBufLen);
	AllocDecode(BaseCoder, dwBufLen);
	
	while((nIndex + 4) <= BaseCoder->m_nEDataLen)
	{
		Clear(&Raw);
		Raw.nData[0] = BaseCoder->m_DecodeTable[BaseCoder->m_pEBuffer[nIndex]];
		Raw.nData[1] = BaseCoder->m_DecodeTable[BaseCoder->m_pEBuffer[nIndex + 1]];
		Raw.nData[2] = BaseCoder->m_DecodeTable[BaseCoder->m_pEBuffer[nIndex + 2]];
		Raw.nData[3] = BaseCoder->m_DecodeTable[BaseCoder->m_pEBuffer[nIndex + 3]];

		if (Raw.nData[2] == 255)
			Raw.nData[2] = 0;
		if (Raw.nData[3] == 255)
			Raw.nData[3] = 0;
		
		Raw.nSize = 4;
		_DecodeToBuffer(&Raw, BaseCoder->m_pDBuffer + BaseCoder->m_nDDataLen);
		nIndex += 4;
		BaseCoder->m_nDDataLen += 3;
	}
	
   // 
	if (nIndex < BaseCoder->m_nEDataLen)
	{
		Clear(&Raw);
		for (i=nIndex; i< BaseCoder->m_nEDataLen; i++)
		{
			Raw.nData[i - nIndex] = BaseCoder->m_DecodeTable[BaseCoder->m_pEBuffer[i]];
			Raw.nSize++;
			if(Raw.nData[i - nIndex] == 255)
				Raw.nData[i - nIndex] = 0;
		}

		_DecodeToBuffer(&Raw, BaseCoder->m_pDBuffer + BaseCoder->m_nDDataLen);
		BaseCoder->m_nDDataLen += (BaseCoder->m_nEDataLen - nIndex);
	}
}

void Decode(Base64Coder *BaseCoder, const char* szMessage)
{
	if (szMessage != BASE_NULL)
	{
		DecodeBase(BaseCoder, (const unsigned char*)szMessage, strlen(szMessage));
	}
}

long _DecodeToBuffer(TempBucket* Decode, unsigned char* pBuffer)
{
	TempBucket	Data;
	int					nCount = 0;
	int 				i=0;

	_DecodeRaw(&Data, Decode);

	for (i=0; i<3; i++)
	{
		pBuffer[i] = Data.nData[i];
		if(pBuffer[i] != 255)
			nCount++;
	}

	return nCount;
}


void _EncodeToBuffer(TempBucket* Decode, unsigned char* pBuffer)
{
	TempBucket 	Data;
	int 				i=0;

	_EncodeRaw(&Data, Decode);

	for (i=0; i<4; i++)
		pBuffer[i] = Base64Digits[Data.nData[i]];

	switch (Decode->nSize)
	{
	  case 1:
		  pBuffer[2] = '=';
	  case 2:
		  pBuffer[3] = '=';
	}
}

void _DecodeRaw(TempBucket* Data, const TempBucket* Decode)
{
	unsigned char nTemp;

	Data->nData[0] = Decode->nData[0];
	Data->nData[0] <<= 2;

	nTemp = Decode->nData[1];
	nTemp >>= 4;
	nTemp &= 0x03;
	Data->nData[0] |= nTemp;

	Data->nData[1] = Decode->nData[1];
	Data->nData[1] <<= 4;

	nTemp = Decode->nData[2];
	nTemp >>= 2;
	nTemp &= 0x0F;
	Data->nData[1] |= nTemp;

	Data->nData[2] = Decode->nData[2];
	Data->nData[2] <<= 6;
	nTemp = Decode->nData[3];
	nTemp &= 0x3F;
	Data->nData[2] |= nTemp;
}

void _EncodeRaw(TempBucket* Data, const TempBucket* Decode)
{
	unsigned char nTemp;

	Data->nData[0] = Decode->nData[0];
	Data->nData[0] >>= 2;
	
	Data->nData[1] = Decode->nData[0];
	Data->nData[1] <<= 4;
	nTemp = Decode->nData[1];
	nTemp >>= 4;
	Data->nData[1] |= nTemp;
	Data->nData[1] &= 0x3F;

	Data->nData[2] = Decode->nData[1];
	Data->nData[2] <<= 2;

	nTemp = Decode->nData[2];
	nTemp >>= 6;

	Data->nData[2] |= nTemp;
	Data->nData[2] &= 0x3F;

	Data->nData[3] = Decode->nData[2];
	Data->nData[3] &= 0x3F;
}

BOOL _IsBadMimeChar(unsigned char nData)
{
	switch(nData)
	{
		case '\r': case '\n': case '\t': case ' ' :
		case '\b': case '\a': case '\f': case '\v':
			return TTRUE;
		default:
			return TFALSE;
	}
}

void _Init(Base64Coder *BaseCoder)
{  
  // 初始化编码表
	int	i;
	for (i=0; i<256; i++)
		BaseCoder->m_DecodeTable[i] = -2;

	for (i=0; i<64; i++)
	{
		BaseCoder->m_DecodeTable[Base64Digits[i]] = (char) i;
		BaseCoder->m_DecodeTable[Base64Digits[i]|0x80] = (char) i;
	}

	BaseCoder->m_DecodeTable['=']	= -1;
	BaseCoder->m_DecodeTable['='|0x80] = -1;
	BaseCoder->m_Init = TTRUE;
}