/**********************************************************************/
/**                       Microsoft Windows/NT                       **/
/**                Copyright(c) Microsoft Corporation, 1998 - 1999 **/
/**********************************************************************/

/*
	IASHelper.cpp
		Implementation of the following helper classes:
		
		

		And global functions:
		GetSdoInterfaceProperty - Get an interface property from a SDO 
								  through its ISdo interface
			
    FILE HISTORY:
		
		2/18/98			byao		Created
        
*/

#include "Precompiled.h"
#include <limits.h>
#include <winsock2.h>
#include "IASHelper.h"

//+---------------------------------------------------------------------------
//
// Function:  IASGetSdoInterfaceProperty
//
// Synopsis:  Get an interface property from a SDO through its ISdo interface
//
// Arguments: ISdo *pISdo - Pointer to ISdo
//            LONG lPropId - property id
//            REFIID riid - ref iid
//            void ** ppvObject - pointer to the requested interface property
//
// Returns:   HRESULT - 
//
// History:   Created Header    byao	2/12/98 11:12:55 PM
//
//+---------------------------------------------------------------------------
HRESULT IASGetSdoInterfaceProperty(ISdo *pISdo, 
								LONG lPropID, 
								REFIID riid, 
								void ** ppvInterface)
{
	TRACE(_T("::IASGetSdoInterfaceProperty()\n"));
	
	CComVariant var;
	HRESULT hr;

	V_VT(&var) = VT_DISPATCH;
	V_DISPATCH(&var) = NULL;
	hr = pISdo->GetProperty(lPropID, &var);

	//ReportError(hr, IDS_IAS_ERR_SDOERROR_GETPROPERTY, NULL);
	_ASSERTE( V_VT(&var) == VT_DISPATCH );

    // query the dispatch pointer for interface
	hr = V_DISPATCH(&var) -> QueryInterface( riid, ppvInterface);
	//ReportError(hr, IDS_IAS_ERR_SDOERROR_QUERYINTERFACE, NULL);
	
	return S_OK;
}


//+---------------------------------------------------------------------------
//
// Function:  Hex2DWord
//
// Synopsis:  hexadecimal string to dword value
//
// Arguments: TCHAR* tszStr - number in hexadecimal string format "FF"
//
// Returns:   DWORD - value
//
// History:   Created Header    byao	3/6/98 2:46:49 AM
//
//+---------------------------------------------------------------------------
DWORD Hex2DWord(TCHAR* tszStr)
{
	TRACE(_T("::Hex2DWord()\n"));
	
	DWORD dwTemp = 0;
	DWORD dwDigit = 0; 
	DWORD dwIndex = 0;

	for (dwIndex=0; dwIndex<_tcslen(tszStr); dwIndex++)
	{
		// get the current digit
		if ( tszStr[dwIndex]>= _T('0') && tszStr[dwIndex]<= _T('9') )
			dwDigit = tszStr[dwIndex] - _T('0');
		else if ( tszStr[dwIndex]>= _T('A') && tszStr[dwIndex]<= _T('F') )
			dwDigit = tszStr[dwIndex] - _T('A') + 10;
		else if ( tszStr[dwIndex]>= _T('a') && tszStr[dwIndex]<= _T('f') )
			dwDigit = tszStr[dwIndex] - _T('a') + 10;

		// accumulate the value
		dwTemp = dwTemp*16 + dwDigit;
	}

	return dwTemp;
}

//todo: where should we put these constants?

#define L_INT_SIZE_BYTES  4  // from BaseCamp

// position 0--1: value format
#define I_VENDOR_ID_POS			2	// vendor ID starts from position 2;
#define I_ATTRIBUTE_TYPE_POS	10	// either the vendor attribute type(RFC), 
									// or raw value (for NONRFC value)


//+---------------------------------------------------------------------------
//
// Function:  GetVendorSpecificInfo
//
// Synopsis:  Get the information for vendor-specific attribute type
//
// Arguments: [in]::CString& strValue		- OctetString value
//            [out]int& dVendorId		- Vendor ID
//            [out]fNonRFC				-	random/Radius RFC compatible
//            [out]dFormat				- value format: string, integer, etc.
//            [out]int&dType			-  data type
//            [out]::CString&strDispValue	- data displayable value
//
// Returns:   HRESULT - 
//
// History:   Created Header    byao 2/28/98 12:12:11 AM
//
//+---------------------------------------------------------------------------
HRESULT	GetVendorSpecificInfo(::CString& strValue, 
							  DWORD&	dVendorId, 
							  BOOL&		fNonRFC,
							  DWORD&	dFormat, 
							  DWORD&	dType, 
							  ::CString&	strDispValue)
{
	TRACE(_T("::GetVendorSpecificInfo()\n"));
	
	::CString strVSAType;
	::CString strVSALen;
	::CString strVSAValue;
	::CString strVendorId;
	::CString strPrefix;
	TCHAR	tszTempStr[256];
	DWORD	dwIndex;


	if ( strValue.GetLength() < I_ATTRIBUTE_TYPE_POS)
	{
		// invalid attribute value;
		strDispValue = strValue;
		fNonRFC = TRUE;
		return E_FAIL;
	}

	strDispValue.Empty();

	// is it a RADIUS RFC compatible value?
	_tcsncpy(tszTempStr, strValue, 2);
	tszTempStr[2] = _T('\0');

	switch( _ttoi(tszTempStr) )
	{
	case 0:  fNonRFC = TRUE;  dFormat = 0; dType = 0;
			 break;
	case 1:  fNonRFC = FALSE; dFormat = 0;   // string
			 break;
	case 2:  fNonRFC = FALSE; dFormat = 1;   // integer
			 break;
	case 4:	// ipaddress
			fNonRFC = FALSE; dFormat = 3;   // hexadecimal
			 break;
	case 3:  
	default: fNonRFC = FALSE; dFormat = 2;   // hexadecimal
			 break;
	}

	// Vendor ID
	for (dwIndex=0; dwIndex<8; dwIndex++)
	{	
		tszTempStr[dwIndex] = ((LPCTSTR)strValue)[I_VENDOR_ID_POS+dwIndex];
	}
	tszTempStr[dwIndex] = _T('\0');
	dVendorId = Hex2DWord(tszTempStr);

	// non RFC data? 
	if ( fNonRFC )
	{
		_tcscpy(tszTempStr, (LPCTSTR)strValue + I_ATTRIBUTE_TYPE_POS);
		strDispValue = tszTempStr;
	}
	else
	{
		// Radius RFC format
				
		// find the attribute type
		tszTempStr[0] = ((LPCTSTR)strValue)[I_ATTRIBUTE_TYPE_POS];
		tszTempStr[1] = ((LPCTSTR)strValue)[I_ATTRIBUTE_TYPE_POS+1];
		tszTempStr[2] = _T('\0');
		dType = Hex2DWord(tszTempStr);

		TCHAR*  tszPrefixStart;
		// find the attribute value
		switch(dFormat)
		{
		case 0:  // string
				{
					DWORD   jIndex;
					TCHAR	tszTempChar[3];
					TCHAR	tszTemp[2];
										
					_tcscpy(tszTempStr, (LPCTSTR)strValue+I_ATTRIBUTE_TYPE_POS+4);
					strDispValue = tszTempStr;

					/*
					jIndex = 0;
					while ( jIndex < _tcslen(tszTempStr)-1 )
					{
						tszTempChar[0] = tszTempStr[jIndex];
						tszTempChar[1] = tszTempStr[jIndex+1];
						tszTempChar[2] = _T('\0');
						
						tszTemp[0] = (TCHAR) Hex2DWord(tszTempChar);
						tszTemp[1] = _T('\0');

						strDispValue += tszTemp;
						jIndex += 2;
					}
					*/
				}
				break;

		case 1:	 // decimal or hexadecimal
				 tszPrefixStart = _tcsstr(strValue, _T("0x"));
				 if (tszPrefixStart == NULL)
				 {
					 tszPrefixStart = _tcsstr(strValue, _T("0X"));
				 }

				 if (tszPrefixStart)
				 {
					 // hexadecimal
					 _tcscpy(tszTempStr, tszPrefixStart);
					strDispValue = tszTempStr;
				 }
				 else
				 {
					 // decimal
					 _tcscpy(tszTempStr, (LPCTSTR)strValue+I_ATTRIBUTE_TYPE_POS+4);
					DWORD dwValue = Hex2DWord(tszTempStr);
					wsprintf(tszTempStr, _T("%u"), dwValue);
					strDispValue = tszTempStr;
				 }	
				 break;

		case 3:	// ip address
				{
					 // like decimal
					 _tcscpy(tszTempStr, (LPCTSTR)strValue+I_ATTRIBUTE_TYPE_POS+4);
					 if(_tcslen(tszTempStr) != 0)
					 {
						DWORD dwValue = Hex2DWord(tszTempStr);
						in_addr ipaddr;
						ipaddr.s_addr = ntohl(dwValue);
						strDispValue = inet_ntoa(ipaddr);
					 }
					 else
						 strDispValue = _T("");
				}
				break;

		case 2:  // hexadecimal
				 _tcscpy(tszTempStr, (LPCTSTR)strValue+I_ATTRIBUTE_TYPE_POS+4);
				 strDispValue = tszTempStr;
				 break;
		}
	}

	return S_OK;
}


//+---------------------------------------------------------------------------
//
// Function:  SetVendorSpecificInfo
//
// Synopsis:  Set the information for vendor-specific attribute type
//
// Arguments: [out]::CString& strValue	- OctetString value
//            [in]int& dVendorId		- Vendor ID
//            [in]fNonRFC				-	random or RADIUS RFC compatible	
//            [in]dFormat				- attribute format: string, integer; hexadecimal
//            [in]int&  dType			-  attribute type
//            [in]::CString& strDispValue - data displayable value
//
// Returns:   HRESULT - 
//
// History:   Created Header    byao 2/28/98 12:12:11 AM
//
//+---------------------------------------------------------------------------
HRESULT	SetVendorSpecificInfo(::CString&	strValue, 
							  DWORD&	dVendorId, 
							  BOOL&		fNonRFC,
							  DWORD&	dFormat, 
							  DWORD&	dType, 
							  ::CString&	strDispValue)
{
	TRACE(_T("::SetVendorSpecificInfo()\n"));
	USES_CONVERSION;
	
	::CString strVSAType;
	::CString strVSALen;
	::CString strVSAValue;
	::CString strVendorId;
	::CString strPrefix;
	TCHAR	tszTempStr[256];
	DWORD	dwIndex;
	
	wsprintf(tszTempStr, _T("%08X"), dVendorId);
	_tcsupr(tszTempStr);
	strValue = tszTempStr; // vendor ID first

	if ( !fNonRFC )
	{
		// RFC compatible format

		// prefix determined by type
		
		// 1. VendorType -- an integer between 1-255
		wsprintf(tszTempStr, _T("%02X"), dType);
		strVSAType = tszTempStr;

		// 2. Vendor Format: string, raw or hexadecimal
		switch (dFormat)
		{
		case 0:  // string
				 wsprintf(tszTempStr, _T("%02X"), _tcslen(strDispValue)+2);
				 strVSALen = tszTempStr;

				 /*  removed per discussion with MKarki on 5/21/98. 
				     String will be saved in original format
				 for (dwIndex=0; dwIndex<_tcslen(strDispValue); dwIndex++)
				 {
					 wsprintf(tszTempStr, _T("%02X"), ((LPCTSTR)strDispValue)[dwIndex]);
					 strVSAValue += tszTempStr;
				 }
				 */

				 strVSAValue = strDispValue;
				 strPrefix = _T("01");

				 break;				 

		case 3:  // IP address : added F; 211265
				// the display string is in a.b.c.d format, we need to save it as decimal format
				//
				{
								// ip adress control
					unsigned long IpAddr = inet_addr(T2A(strDispValue));	
					IpAddr = htonl(IpAddr);

					strPrefix = _T("04");
					wsprintf(tszTempStr, _T("%08lX"), IpAddr);
					strVSAValue = tszTempStr;

					 // length
					 wsprintf(tszTempStr, _T("%02X"), L_INT_SIZE_BYTES + 2);
					 strVSALen = tszTempStr;
				}

				break;
		case 1:  // raw -- decimal or hexadecimal (0x... format)
				 if (_tcsstr(strDispValue, _T("0x")) != NULL  ||
					 _tcsstr(strDispValue, _T("0X")) != NULL)
				 {
					 // hexadecimal
					 strVSAValue = strDispValue;
				 }
				 else
				 { 

					//todo: hexLarge???
					wsprintf(tszTempStr, _T("%08lX"), _ttol(strDispValue));
					strVSAValue = tszTempStr;
				 }
				
				 // length
				 wsprintf(tszTempStr, _T("%02X"), L_INT_SIZE_BYTES + 2);
				 strVSALen = tszTempStr;

				 strPrefix = _T("02");
				 
				 break;

		case 2:  // hexadecimal format
				 wsprintf(tszTempStr, _T("%02X"), _tcslen(strDispValue)/2+2);
				 strVSALen = tszTempStr;
				 strVSAValue = strDispValue;
				 strPrefix = _T("03");
				 break;
				break;
		}
		
		if(strDispValue.IsEmpty())		// special case for nothing for value
		{

			strVSALen = _T("02");
			strVSAValue = _T("");
		}

		strVSAValue = strVSAType + strVSALen + strVSAValue;
	}
	else
	{
		strPrefix = _T("00");
		strVSAValue = strDispValue;
	}

	strValue += strVSAValue;
	strValue = strPrefix + strValue;

	return S_OK;
}

//+---------------------------------------------------------------------------
//
// Data validation and conversion routines: hexadecimal string to integer
//											decimal string to integer	
//
//+---------------------------------------------------------------------------

#define ISSPACE(ch)  (  ( ch==_T(' ') )  || ( ch==_T('\t') ) )
//+---------------------------------------------------------------------------
//
// Function:  'Decimal
//
// Synopsis:  Check whether a string is a valid 4-BYTE decimal integer
//
// Arguments: LPCTSTR tszStr		- input string
//            BOOL fUnsigned	- whether this is an unsigned integer
//            long *pdValue		- return the integer value back here
//
// Returns:   BOOL - TRUE:	valid decimal integer
//					 FALSE: otherwise
//
// History:   Created Header    byao	5/22/98 2:14:14 PM
//
//+---------------------------------------------------------------------------
BOOL IsValidDecimal(LPCTSTR tszStr, BOOL fUnsigned, long *pdValue)
{
	if ( !tszStr )
	{
		return FALSE;
	}

	*pdValue = 0;

	// first, skip the white space
	while ( *tszStr && ISSPACE(*tszStr) ) 
	{
		tszStr++;
	}
	
	if ( ! (*tszStr) )
	{
		// string has ended already -- which means this string has only
		// white space in it
		return FALSE;		
	}

	if (_tcslen(tszStr)>11)
	{
		//
		// since we only deal with 4-byte integer here, the standard value range
		// is :  -2147483648 to 2147483647; 
		// For unsigned number, that puts us to 0 to 4294967295, which has
		// maximum length 10.
		//
		return FALSE;
	}

	// 
	// negative integer?
	//
	BOOL fNegative = FALSE;
	if ( *tszStr == _T('-') )
	{
		if ( fUnsigned )
		{
			return FALSE;
		}

		fNegative = TRUE;
		tszStr++;
	}

	double dbTemp = 0; // we use a temporary double variable here
					  // so we can check whether the number is out of bounds
	while ( *tszStr )
	{
		if ( *tszStr <= '9' && *tszStr >='0' )
		{
			dbTemp = dbTemp*10 + (*tszStr - '0');
		}
		else
		{
			return FALSE;
		}

		tszStr++;
	}


	if ( fUnsigned && dbTemp > UINT_MAX )
	{
		// out of range
		return FALSE;
	}

	if ( !fUnsigned && fNegative )
	{
		// negative number??
		dbTemp =  (-dbTemp);
	}

	if ( !fUnsigned && (  dbTemp < INT_MIN || dbTemp > INT_MAX ) )
	{
		// integer out of range
		return FALSE;
	}

	*pdValue = (long)dbTemp;

	return TRUE;
}

//+---------------------------------------------------------------------------
//
// Function:  DDV_IntegerStr
//
// Synopsis:  custom data verification routine: an integer string.
//			  the string must be consisted of integer only and must be 
//			  in the right range for 4-byte integer
//
// Arguments: CDataExchange* pDX - data exchange context
//            ::CString& strText -  string to verify
//
// Returns:   void  - 
//
// History:   Created Header  byao  3/10/98 11:04:58 PM
//
//+---------------------------------------------------------------------------
void  DDV_IntegerStr(CDataExchange* pDX, ::CString& strText)
{
	TRACE(_T("DDV_IntegerStr"));
	
	TCHAR	wzMessage[MAX_PATH];
	::CString	strMessage;
	int		nIndex;

	long  lTempValue;
	BOOL fValid = IsValidDecimal((LPCTSTR)strText, FALSE, &lTempValue);

	if ( !fValid )
	{
			// invalid data
			ShowErrorDialog(pDX->m_pDlgWnd->GetSafeHwnd(),  IDS_IAS_ERR_INVALIDINTEGER, NULL);
			pDX->Fail();
			return;
	}
	TRACE(_T("Valid integer: %ws\n"), (LPCTSTR)strText);
}

//+---------------------------------------------------------------------------
//
// Function:  DDV_Unsigned_IntegerStr
//
// Synopsis:  custom data verification routine: an unsigned integer string.
//			  the string must be consisted of integer only and must be in 
//			  the range for a 4-byte unsigned integer
//
// Arguments: CDataExchange* pDX - data exchange context
//            ::CString& strText -  string to verify
//
// Returns:   void  - 
//
// History:   Created Header  byao  5/22/98 11:04:58 PM
//
//+---------------------------------------------------------------------------
void  DDV_Unsigned_IntegerStr(CDataExchange* pDX, ::CString& strText)
{
	TRACE(_T("DDV_Unsigned_IntegerStr\n"));
	
	TCHAR	wzMessage[MAX_PATH];
	::CString	strMessage;
	int		nIndex;

	long  lTempValue;
	BOOL fValid = IsValidDecimal((LPCTSTR)strText, TRUE, &lTempValue);

	if ( !fValid )
	{
			// invalid data
			ShowErrorDialog(pDX->m_pDlgWnd->GetSafeHwnd(),  IDS_IAS_ERR_INVALID_UINT, NULL);
			pDX->Fail();
			return;
	}
	TRACE(_T("Valid integer: %ws\n"), (LPCTSTR)strText);
}

//+---------------------------------------------------------------------------
//
// Function:  GetValidVSAHexString
//
// Synopsis:  check whether the input string is a valid VSA hexadecimal string
//			  and return a pointer to where the string actually starts
//				
//			  A valid VSA hexadecimal string must meet the following criteria:

// MAM 09/15/98 - _may_ start with 0x -- see 203334 -- we don't require 0x anymore.
//			    1)  _may_ start with 0x (no preceding white space)

//				2)  contains only valid hexadecimal digits
//				3)  contains even number of digits
//				4)  maximum string length is 246.
//
// Arguments: LPCTSTR tszStr - input string
//
// Returns:   NULL:  invalid VSA hex string
//			  otherwise return a pointer to the first character of the string
//
//			  e.g, if the string is: "    0xabcd", then return "abcd"
//
// History:   Created Header  byao  5/22/98 4:06:57 PM
//
//+---------------------------------------------------------------------------
LPTSTR GetValidVSAHexString(LPCTSTR tszStr)
{
	LPTSTR tszStartHex = NULL;

	if ( !tszStr )
	{
		return NULL;
	}


	// Maximum length: 246.  
	// We'll check using this below once we've dispensed with
	// any "0x" prefix if it exists.
	int iMaxLength = 246;


	// skip the white space
	while ( *tszStr && ISSPACE(*tszStr) ) 
	{
		tszStr++;
	}


	// MAM 09/15/98 - _may_ start with 0x -- see 203334 -- we don't require 0x anymore.
	//
	// does it start with 0x?
	//
	if ( tszStr[0]==_T('0') )
	{
		// If it starts with '0x', skip these two characters.
		if ( tszStr[1] == _T('x') || tszStr[1] == _T('X') )
		{
			// Skip "0x" prefix.
			tszStr++;
			tszStr++;
		}
	}

	// Check whether exceeds iMaxLength now that we have dispensed 
	// with "0x" if it was prefixed to the string.
	// Also check for minimum length: 2 (must have at least some data)
	// Also it must be even number length.

	int iLength = _tcslen(tszStr);
	if ( iLength > iMaxLength || iLength < 2 || iLength % 2 )
	{
		return NULL;
	}


	tszStartHex = (LPTSTR)tszStr;
	if ( !(*tszStartHex) )
	{
		// there's nothing followed by the prefix
		return NULL;
	}


	// does it contain any invalid character?
	while ( *tszStr )
	{
		if (!
			 ((*tszStr >= _T('0') && *tszStr <= _T('9')) ||
			  (*tszStr >= _T('a') && *tszStr <= _T('f')) ||
			  (*tszStr >= _T('A') && *tszStr <= _T('F'))
			 )
		   )
		{
			return NULL;
		}

		tszStr++;
	}
	
	// return the pointer
	return tszStartHex;
}

//+---------------------------------------------------------------------------
//
// Function:  DDV_VSA_HexString
//
// Synopsis:  custom data verification routine: VSA hexadecimal string
//			  A valid VSA hexadecimal string must meet the following criteria:

// MAM 09/15/98 - NO! see 203334 -- we don't require 0x anymore.
//			    1)  start with 0x (no preceding white space)

//				2)  contains only valid hexadecimal digits
//				3)  contains even number of digits
//				4)  maximum string length is 246.
//
// Arguments: CDataExchange* pDX - data exchange context
//            ::CString& strText -  string to verify
//
// Returns:   void  - 
//
// History:   Created Header  byao  5/22/98 11:04:58 PM
//
//+---------------------------------------------------------------------------
void  DDV_VSA_HexString(CDataExchange* pDX, ::CString& strText)
{
	TRACE(_T("::DDV_VSA_HexString()\n"));
	
	TCHAR	wzMessage[MAX_PATH];
	::CString	strMessage;

	LPTSTR	tszHex = GetValidVSAHexString( (LPCTSTR)strText );

	if ( !tszHex )
	{
		// invalid data
		ShowErrorDialog(pDX->m_pDlgWnd->GetSafeHwnd(), IDS_IAS_ERR_INVALID_VSAHEX, NULL);
		pDX -> Fail();
	}
	else
	{
		strText = tszHex;
		TRACE(_T("Valid VSA hex string %ws\n"), (LPCTSTR)strText);
	}
}


//+---------------------------------------------------------------------------
//
// Function:  DDV_BoolStr
//
// Synopsis:  custom data verification routine: a boolean string.
//			  the only valid values are "T", "F", "TRUE", "FALSE"
//
// Arguments: CDataExchange* pDX - data exchange context
//            ::CString& strText -  string to verify
//
// Returns:   void  - 
//
// History:   Created Header  byao  3/10/98 11:04:58 PM
//
//+---------------------------------------------------------------------------
void  DDV_BoolStr(CDataExchange* pDX, ::CString& strText)
{
	TRACE(_T("::DDV_BoolStr()\n"));
	
	TCHAR	wzMessage[MAX_PATH];
	::CString	strMessage;

	if (! ( _wcsicmp(strText, _T("TRUE")) == 0 || _wcsicmp(strText, _T("FALSE") ) == 0
	      ))
	{
		// invalid data
		ShowErrorDialog(pDX->m_pDlgWnd->GetSafeHwnd(), IDS_IAS_ERR_INVALIDBOOL, NULL);
		pDX -> Fail();
	}
	TRACE(_T("Valid bool value %ws\n"), (LPCTSTR)strText);
}

//////////////////////////////////////////////////////////////////////////////

TCHAR HexChar[] = {
			_T('0'), _T('1'), _T('2'), _T('3'), _T('4'), _T('5'), _T('6'), _T('7'), 
			_T('8'), _T('9'), _T('a'), _T('b'), _T('c'), _T('d'), _T('e'), _T('f')
			};


// convert binary data to hex string, bytes 01 01 01 --> _T("0x010101")
size_t		BinaryToHexString(char* pData, size_t cch, TCHAR* pTStr, size_t ctLen)
{
	int	nRequiredLen = (cch * 2 + 2 + 1);	// two WCHAR for 1 byte, and 0x at begining and , \0 at end 

	if(ctLen == 0)
		return 	nRequiredLen;

	if(ctLen < nRequiredLen || pTStr == NULL ||  pData == NULL)
		return 0;

	// make the output string empty
	if(cch == 0)
	{
		*pTStr = 0;
		return 1;
	}

	// do converstion now		
	*pTStr = _T('0');
	*(pTStr + 1) = _T('x');


	// walk through each byte
	for(int i = 0; i < cch; i++)
	{
		int h = ((*(pData + i) & 0xf0) >> 4);

		// high 4 bits
		*(pTStr + i * 2 + 2) = HexChar[h];
				
		// low 4 bits
		h = (*(pData + i) & 0x0f);
		*(pTStr + i * 2 + 1+ 2 ) = HexChar[h];
	}

	*(pTStr + nRequiredLen - 1 ) = _T('\0');

	return nRequiredLen;

}


//
#define HexValue(h)	\
		( ((h) >= _T('a') && (h) <= _T('f')) ? ((h) - _T('a') + 0xa) : \
		( ((h) >= _T('A') && (h) <= _T('F')) ? ((h) - _T('A') + 0xa) : \
		( ((h) >= _T('0') && (h) <= _T('9')) ? ((h) - _T('0')) : 0)))

// convert HexString to binary value: _T("0x010101") convert to 3 bytes 01 01 01
size_t	HexStringToBinary(TCHAR* pStr, char* pData, size_t cch)
{
	// need to convert to binary before passing into SafeArray
	pStr =  GetValidVSAHexString(pStr);

	if(pStr == NULL)	return 0;
		
	
	size_t nLen = _tcslen(pStr) / 2;

	// if inquery for length
	if(cch == 0)	return nLen;
	
	// get the binary

	for(int i = 0; i < nLen; i++)
	{
		char h, l;

		// high 4 bits
		h = (char)HexValue(pStr[i * 2]);

		// low 4 bits
		l = (char)HexValue(pStr[i * 2 + 1]);

		*(pData + i) = (h << 4) + l;
	}

	return nLen;
}