Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

422 lines
9.6 KiB

//+--------------------------------------------------------------------------
//
// Copyright (c) 1997-1999 Microsoft Corporation
//
// File:
//
// Contents:
//
// History:
//
//---------------------------------------------------------------------------
#include <windows.h>
#include <assert.h>
#include <math.h>
class CDataCoding {
private:
DWORD m_dwBaseDigits;
DWORD m_dwEncodedLength;
DWORD m_dwInputDataBits;
DWORD m_dwInputDataBytes;
DWORD m_dwDecodedLength;
DWORD m_dwInputEncDataBytes;
DWORD m_dwDecodedBits;
TCHAR * m_tpBaseDigits;
public:
CDataCoding(TCHAR * tpBaseDigits = NULL);
void SetInputDataBitLen(DWORD dwBits);
void SetInputEncDataLen(DWORD dwChars);
DWORD SetBaseDigits(TCHAR * tpBaseDigits);
DWORD EncodeData(LPBYTE pbSource, //[IN] Stream of Bytes to be encoded
TCHAR **pbEncodedData); //[OUT] Pointer to a string containing the encoded data
DWORD DecodeData(TCHAR * pbEncodedData,
LPBYTE * pbDecodedData);
~CDataCoding();
};
class CBase24Coding : public CDataCoding {
public:
CBase24Coding(void) : CDataCoding(L"BCDFGHJKMPQRTVWXY2346789")
{
return;
}
};
static CBase24Coding b24Global;
// **************************************************************
DWORD B24EncodeMSID(LPBYTE pbSource, TCHAR **pbEncodedData)
{
b24Global.SetInputDataBitLen(160);
return b24Global.EncodeData(pbSource, pbEncodedData);
}
// ***************************************************************
DWORD B24DecodeMSID(TCHAR * pbEncodedData, LPBYTE * pbDecodedData)
{
b24Global.SetInputEncDataLen(35);
return b24Global.DecodeData(pbEncodedData, pbDecodedData);
}
// ***********************************************************
DWORD B24EncodeCNumber(LPBYTE pbSource, TCHAR **pbEncodedData)
{
b24Global.SetInputDataBitLen(32);
return b24Global.EncodeData(pbSource, pbEncodedData);
}
// ******************************************************************
DWORD B24DecodeCNumber(TCHAR * pbEncodedData, LPBYTE * pbDecodedData)
{
b24Global.SetInputEncDataLen(7);
return b24Global.DecodeData(pbEncodedData, pbDecodedData);
}
// *******************************************************
DWORD B24EncodeSPK(LPBYTE pbSource, TCHAR **pbEncodedData)
{
b24Global.SetInputDataBitLen(114);
return b24Global.EncodeData(pbSource, pbEncodedData);
}
// ******************************************************************
DWORD B24DecodeSPK(TCHAR * pbEncodedData, LPBYTE * pbDecodedData)
{
b24Global.SetInputEncDataLen(25);
return b24Global.DecodeData(pbEncodedData, pbDecodedData);
}
// *****************************************
CDataCoding::CDataCoding(TCHAR * tpBaseDigits)
{
m_tpBaseDigits = NULL;
m_dwBaseDigits = 0;
m_dwEncodedLength = 0;
m_dwInputDataBits = 0;
m_dwInputDataBytes = 0;
SetBaseDigits(tpBaseDigits);
}
// ********************************************
void CDataCoding::SetInputDataBitLen(DWORD dwBits)
{
assert(dwBits > 0);
assert(log(m_dwBaseDigits) > 0);
// Determine How many Characters would be required to encode the data
// What we have is a dwDataLength of Binary Data stream.
// So, we can represent 2^(dwDataLength*8) amount of information using these bits
// Assuming that our set of digits (which form the base for encoding) is X,
// the above number should then equal X^(NumberofEncoded Digits)
// So,
double dLength = ((double) dwBits*log10(2)) /
((double) log10(m_dwBaseDigits));
// Now round - up
m_dwEncodedLength = (DWORD) dLength;
if ((double) m_dwEncodedLength < dLength)
{
// There was a decimal part
m_dwEncodedLength++;
}
m_dwInputDataBits = dwBits;
m_dwInputDataBytes = (dwBits / 8) + (dwBits % 8 ? 1 : 0);
return;
}
// ***********************************************
void CDataCoding::SetInputEncDataLen(DWORD dwBytes)
{
assert(dwBytes > 0);
assert(log(m_dwBaseDigits) > 0);
m_dwInputEncDataBytes = dwBytes;
// Determine How many bits would be required to decode this data
// So,
double dLength = ((double) dwBytes*log10(m_dwBaseDigits))/
((double) log10(2));
// Now round - up
m_dwDecodedBits = (DWORD) dLength;
if ((double) m_dwDecodedBits < dLength)
{
// There was a decimal part
m_dwDecodedBits++;
}
m_dwDecodedLength = (m_dwDecodedBits / 8) + (m_dwDecodedBits % 8 ? 1 : 0);
return;
}
// **************************************************
DWORD CDataCoding::SetBaseDigits(TCHAR * tpBaseDigits)
{
DWORD dwReturn = ERROR_SUCCESS;
if (tpBaseDigits != NULL)
{
DWORD dwLen = wcslen(tpBaseDigits);
assert(dwLen > 0);
m_tpBaseDigits = (TCHAR *) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (dwLen+1)*sizeof(TCHAR));
if (m_tpBaseDigits == NULL)
{
dwReturn = ERROR_NOT_ENOUGH_MEMORY;
}
else
{
memcpy(m_tpBaseDigits, tpBaseDigits, (dwLen+1)*sizeof(TCHAR));
m_dwBaseDigits = dwLen;
}
}
else
{
if (m_tpBaseDigits != NULL)
{
HeapFree(GetProcessHeap(), 0, m_tpBaseDigits);
m_tpBaseDigits = NULL;
m_dwBaseDigits = 0;
}
assert(m_tpBaseDigits == NULL && m_dwBaseDigits == 0);
}
return dwReturn;
}
// ************************************************
DWORD CDataCoding::EncodeData(LPBYTE pbSource, //[IN] Stream of Bytes to be encoded
TCHAR **pbEncodedData) //[OUT] Pointer to a string containing the encoded data
// I allocate the Buffer, you should free it
{
assert(m_dwInputDataBits > 0);
assert(m_dwInputDataBytes > 0);
assert(m_dwEncodedLength > 0);
assert(m_tpBaseDigits != NULL);
DWORD dwReturn = ERROR_SUCCESS;
int nStartIndex = m_dwEncodedLength;
*pbEncodedData = NULL;
BYTE * pbDataToEncode = NULL;
TCHAR * pbEncodeBuffer = NULL;
if (NULL == pbEncodedData)
{
dwReturn = ERROR_INVALID_PARAMETER;
goto done;
}
*pbEncodedData = NULL;
pbEncodeBuffer = (TCHAR *) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
(m_dwEncodedLength+1)*sizeof(TCHAR));
if (pbEncodeBuffer == NULL)
{
dwReturn = ERROR_NOT_ENOUGH_MEMORY;
goto done;
}
// Now need to make a copy of the incoming data, so we can run the algorithm below
pbDataToEncode = (BYTE *) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, m_dwInputDataBytes);
if (pbDataToEncode == NULL)
{
dwReturn = ERROR_NOT_ENOUGH_MEMORY;
goto done;
}
memcpy(pbDataToEncode, pbSource, m_dwInputDataBytes);
// Let us get rid of the simple stuff
pbEncodeBuffer[ nStartIndex--] = 0;
for (; nStartIndex >= 0; --nStartIndex)
{
unsigned int i = 0;
for (int nIndex = m_dwInputDataBytes-1; 0 <= nIndex; --nIndex)
{
i = (i * 256) + pbDataToEncode[nIndex];
pbDataToEncode[ nIndex] = (BYTE)(i / m_dwBaseDigits);
i %= m_dwBaseDigits;
}
// i now contains the remainder, which is the current digit
pbEncodeBuffer[ nStartIndex] = m_tpBaseDigits[ i];
}
assert(dwReturn == ERROR_SUCCESS);
*pbEncodedData = pbEncodeBuffer;
done:
if (pbDataToEncode != NULL)
{
HeapFree(GetProcessHeap(), 0, pbDataToEncode);
}
if (dwReturn != ERROR_SUCCESS)
{
// There was an error, so free the memory that you allocated
if (pbEncodeBuffer != NULL)
{
HeapFree(GetProcessHeap(), 0, pbEncodeBuffer);
}
}
return dwReturn;
}
// *************************************************
DWORD CDataCoding::DecodeData(TCHAR * pbEncodedData,
LPBYTE * pbDecodedData)
// Again, I allocate the Buffer, you release it
{
assert(m_dwDecodedBits > 0);
assert(m_dwDecodedLength > 0);
assert(m_tpBaseDigits != NULL);
assert((DWORD) lstrlen(pbEncodedData) == m_dwInputEncDataBytes);
DWORD dwReturn = ERROR_SUCCESS;
TCHAR * tpTemp;
DWORD dwDigit;
unsigned int i;
unsigned int nDecodedBytes, nDecodedBytesMax = 0;
BYTE * pbDecodeBuffer = NULL;
if (NULL == pbDecodedData)
{
dwReturn = ERROR_INVALID_PARAMETER;
goto done;
}
*pbDecodedData = NULL;
pbDecodeBuffer = (BYTE *) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, m_dwDecodedLength);
if ( pbDecodeBuffer == NULL)
{
dwReturn = ERROR_NOT_ENOUGH_MEMORY;
goto done;
}
memset(pbDecodeBuffer, 0, m_dwDecodedLength);
while (*pbEncodedData)
{
// First Find the position of this character in the Base Encoding Character Set
tpTemp = wcschr(m_tpBaseDigits, *pbEncodedData);
if (tpTemp == NULL)
{
// Found a character which is not in base character set
// ERROR ERROR
dwReturn = ERROR_INVALID_DATA;
goto done;
}
dwDigit = (DWORD)(tpTemp - m_tpBaseDigits);
nDecodedBytes = 0;
i = (unsigned int) dwDigit;
while (nDecodedBytes <= nDecodedBytesMax)
{
i += m_dwBaseDigits * pbDecodeBuffer[ nDecodedBytes];
pbDecodeBuffer[ nDecodedBytes] = (unsigned char)i;
i /= 256;
++nDecodedBytes;
}
if (i != 0)
{
assert(nDecodedBytes < m_dwDecodedLength);
pbDecodeBuffer[ nDecodedBytes] = (unsigned char)i;
nDecodedBytesMax = nDecodedBytes;
}
pbEncodedData++;
}
assert(dwReturn == ERROR_SUCCESS);
*pbDecodedData = pbDecodeBuffer;
done:
if (dwReturn != ERROR_SUCCESS)
{
// There was an error, so free the memory that you allocated
if (pbDecodeBuffer != NULL)
{
HeapFree(GetProcessHeap(), 0, pbDecodeBuffer);
}
}
return dwReturn;
}
// **********************
CDataCoding::~CDataCoding()
{
if (m_tpBaseDigits != NULL)
{
HeapFree(GetProcessHeap(), 0, m_tpBaseDigits);
m_tpBaseDigits = NULL;
m_dwBaseDigits = 0;
}
}