repos_util/MD5Test/stdafx.cpp

// stdafx.cpp : 只包括标准包含文件的源文件
// MD5Test.pch 将作为预编译头
// stdafx.obj 将包含预编译类型信息

#include "stdafx.h"

// TODO: 在 STDAFX.H 中
// 引用任何所需的附加头文件，而不是在此文件中引用
WCHAR* ASCII2UNICODE(IN LPCCH lpASCIIStr)
{
	if ( lpASCIIStr == NULL )
		return NULL;

	// 获取宽字符字节数;
	int cchWideChar  = MultiByteToWideChar(CP_ACP, 0, lpASCIIStr, -1, NULL, 0);
	if ( cchWideChar == 0)
		return NULL;

	// 转换成宽字符串;
	WCHAR *pWideChar = new WCHAR[cchWideChar + 1];
	memset(pWideChar, 0 , sizeof(WCHAR)*(cchWideChar + 1));
	int nWriteNum = MultiByteToWideChar(CP_ACP, 0, lpASCIIStr, -1, pWideChar, cchWideChar );
	if ( nWriteNum != cchWideChar)
	{ 
		if (pWideChar) 
			delete []pWideChar;
		return NULL;
	}

	return pWideChar;
}

BOOL ASCII2UNICODE(IN LPCCH lpASCIIStr, OUT PWCH pUNICODEStr, IN CONST INT& nUNICODEStrLen)
{
	if ( lpASCIIStr == NULL )
		return FALSE;

	// 获取宽字符字节数;
	int cchWideChar  = MultiByteToWideChar(CP_ACP, 0, lpASCIIStr, -1, NULL, 0);
	if ( cchWideChar == 0 || cchWideChar >= nUNICODEStrLen)
		return FALSE;

	// 转换成宽字符串;
	memset(pUNICODEStr, 0 , sizeof(WCHAR)*nUNICODEStrLen);
	int nWriteNum = MultiByteToWideChar(CP_ACP, 0, lpASCIIStr, -1, pUNICODEStr, cchWideChar );
	if ( nWriteNum != cchWideChar)
		return FALSE;

	return TRUE;
}

CHAR* UNICODE2ASCII(IN LPWCH lpUNICODEStr)
{
	if ( lpUNICODEStr == NULL )
		return NULL;

	// 获取多字节字符字节数;
	int cbMultiByte = WideCharToMultiByte(CP_OEMCP, 0, lpUNICODEStr, -1, NULL, 0, NULL, NULL);
	if ( cbMultiByte == 0 )
		return NULL;

	// 转换成多字节字符;
	CHAR *pMultiByteStr = new CHAR[cbMultiByte+1];
	memset(pMultiByteStr, 0, cbMultiByte + 1);
	int nWriteNum = WideCharToMultiByte(CP_OEMCP, 0, lpUNICODEStr, -1, pMultiByteStr, cbMultiByte, NULL, NULL);
	if (nWriteNum != cbMultiByte)
	{
		if (pMultiByteStr) 
			delete []pMultiByteStr;
		return NULL;
	}

	return pMultiByteStr;
}

BOOL UNICODE2ASCII(IN LPWCH lpUNICODEStr, OUT LPCH pASCIIStr, IN CONST INT& nASCIIStrLen)
{
	if ( lpUNICODEStr == NULL )
		return FALSE;

	// 获取多字节字符字节数;
	int cbMultiByte = WideCharToMultiByte(CP_OEMCP, 0, lpUNICODEStr, -1, NULL, 0, NULL, NULL);
	if ( cbMultiByte == 0 || cbMultiByte >= nASCIIStrLen )
		return FALSE;

	// 转换成多字节字符;
	memset((void*)pASCIIStr, 0, nASCIIStrLen);
	int nWriteNum = WideCharToMultiByte(CP_OEMCP, 0, lpUNICODEStr, -1, pASCIIStr, cbMultiByte, NULL, NULL);
	if (nWriteNum != cbMultiByte)
	{
		return FALSE;
	}

	return TRUE;
}

CHAR* UNICODE2UTF8(IN LPWCH lpUNICODEStr)
{
	if ( lpUNICODEStr == NULL )
		return NULL;

	// 获取多字节字符字节数;
	int cbMultiByte = WideCharToMultiByte(CP_UTF8, 0, lpUNICODEStr, -1, NULL, 0, NULL, NULL);
	if ( cbMultiByte == 0 )
		return NULL;

	// 转换成多字节字符;
	CHAR* pMultiByteStr = new CHAR[cbMultiByte+1];
	memset(pMultiByteStr, 0, cbMultiByte + 1);
	int nWriteNum = WideCharToMultiByte(CP_UTF8, 0, lpUNICODEStr, -1, pMultiByteStr, cbMultiByte, NULL, NULL);
	if (nWriteNum != cbMultiByte)
	{
		if (pMultiByteStr) 
			delete []pMultiByteStr;
		return NULL;
	}

	return pMultiByteStr;
}

BOOL UNICODE2UTF8(IN LPWCH lpUNICODEStr, OUT LPCH pUTF8Str, IN CONST INT& nUTF8StrLen)
{
	if ( lpUNICODEStr == NULL )
		return FALSE;

	// 获取多字节字符字节数;
	int cbMultiByte = WideCharToMultiByte(CP_UTF8, 0, lpUNICODEStr, -1, NULL, 0, NULL, NULL);
	if ( cbMultiByte == 0 || cbMultiByte >= nUTF8StrLen )
		return FALSE;

	// 转换成多字节字符;
	memset(pUTF8Str, 0, nUTF8StrLen);
	int nWriteNum = WideCharToMultiByte(CP_UTF8, 0, lpUNICODEStr, -1, pUTF8Str, cbMultiByte, NULL, NULL);
	if (nWriteNum != cbMultiByte)
	{
		return FALSE;
	}

	return TRUE;
}

CHAR* ASCII2UTF8(IN LPCCH lpASCIIStr)
{
	// 将ASCII字符串转成UNICODE字符串;
	WCHAR* pWideChar = ASCII2UNICODE(lpASCIIStr);
	if ( pWideChar == NULL )
		return NULL;

	// 再将UICODE转成UTF8;
	CHAR* pUTF8 = UNICODE2UTF8(pWideChar);
	if ( pWideChar )
		delete []pWideChar;

	return pUTF8;
}

BOOL ASCII2UTF8(IN LPCCH lpASCIIStr, OUT LPCH pUTF8Str, IN CONST INT& nUTF8StrLen)
{
	// 将ASCII字符串转成UNICODE字符串;
	WCHAR* pWideChar = ASCII2UNICODE(lpASCIIStr);
	if ( pWideChar == NULL )
		return FALSE;

	// 再将UICODE转成UTF8;
	BOOL bResult = UNICODE2UTF8(pWideChar, pUTF8Str, nUTF8StrLen);

	if ( pWideChar )
		delete []pWideChar;

	return bResult;
}

WORD AsciiToBYTE(BYTE btSrc)
{
	WORD chDest = (WORD)btSrc;
	if ((btSrc >= 'A')&&(btSrc <= 'F'))
	{
		chDest = chDest - 'A' + 10;
	}
	else if ((btSrc >= 'a')&&(btSrc <= 'f'))
	{
		chDest = chDest - 'a' + 10;
	}
	else if ((btSrc >= '0')&&(btSrc <= '9'))
	{
		chDest -= '0';
	}
	return chDest;
}

void ByteToTwoByte( unsigned char *szMsg, int nCount, unsigned char *szConvMsg )
{
	char ch[3];
	unsigned char lh[2];
	for (int i = 0; i < nCount; i++)
	{
		lh[0] = szMsg[i] >> 4;
		lh[1] = szMsg[i] & 0x0f;
	
		for ( int j = 0; j < 2; j++ )
		{
			if ( lh[j] <= 9 )
				szConvMsg[i*2 + j] = lh[j] + '0';
			else 
			{
				switch ( lh[j] )
				{
				case 10:
					szConvMsg[i*2 + j] = 'a';
					break;
				case 11:
					szConvMsg[i*2 + j] = 'b';
					break;
				case 12:
					szConvMsg[i*2 + j] = 'c';
					break;
				case 13:
					szConvMsg[i*2 + j] = 'd';
					break;
				case 14:
					szConvMsg[i*2 + j] = 'e';
					break;
				case 15:
					szConvMsg[i*2 + j] = 'f';
					break;
				default:
					break;
				}
			}
		}
	}
}

// 1个字节转成2个十六进制字符;
void ByteTurn2HexChar( unsigned char by, char (&szHex)[3] )
{
	unsigned char lh[2];
	lh[0] = by >> 4;
	lh[1] = by & 0x0f;
	
	for ( int i = 0; i < 2; i++ )
	{
		if ( lh[i] <= 9 )
			szHex[i] = lh[i] + '0';
		else 
		{
			switch ( lh[i] )
			{
			case 10:
				szHex[i] = 'a';
				break;
			case 11:
				szHex[i] = 'b';
				break;
			case 12:
				szHex[i] = 'c';
				break;
			case 13:
				szHex[i] = 'd';
				break;
			case 14:
				szHex[i] = 'e';
				break;
			case 15:
				szHex[i] = 'f';
				break;
			default:
				break;
			}
		}
	}
}

char Hex16(char WillChangeNum[])   //该函数把四位二进制转换成十六进制数; 
{
	int i;
	i = (WillChangeNum[3]) + (WillChangeNum[2] * 10) + (WillChangeNum[1] * 100) + (WillChangeNum[0] * 1000);
	switch(i) 
	{
	case 0:
		return 0;
	case 1:
		return 1;
	case 10:
		return 2;
	case 11:
		return 3;
	case 100:
		return 4;
	case 101:
		return 5;
	case 110:
		return 6;
	case 111:
		return 7;
	case 1000:
		return 8;
	case 1001:
		return 9;
	case 1010:
		return 0x0A;
	case 1011:
		return 0x0B;
	case 1100:
		return 0x0C;
	case 1101:
		return 0x0D;
	case 1110:
		return 0x0E;
	case 1111:
		return 0x0F;
	}
	return -1;
}