/***
* E2-54
*
* Canonical-base64Binary ::= (B64 B64 B64 B64)*((B64 B64 B16 '=')|(B64 B04 '=='))?
* B04 ::= [AQgw]
* B16 ::= [AEIMQUYcgkosw048]
* B64 ::= [A-Za-z0-9+/]
*
***/
XMLCh* Base64::getCanonicalRepresentation(const XMLCh* const inputData
, MemoryManager* const memMgr
, Conformance conform)
{
if (!inputData || !*inputData)
return 0;
/***
* Move input data to a XMLByte buffer
*/
XMLSize_t srcLen = XMLString::stringLen(inputData);
XMLByte *dataInByte = (XMLByte*) getExternalMemory(memMgr, (srcLen+1) * sizeof(XMLByte));
ArrayJanitor<XMLByte> janFill(dataInByte, memMgr ? memMgr : XMLPlatformUtils::fgMemoryManager);
for (XMLSize_t i = 0; i < srcLen; i++)
dataInByte[i] = (XMLByte)inputData[i];
dataInByte[srcLen] = 0;
/***
* Forward to the actual decoding method to do the decoding
*/
XMLSize_t decodedLength = 0;
XMLByte* canRepInByte = 0;
XMLByte* retStr = decode(
dataInByte
, &decodedLength
, canRepInByte
, memMgr
, conform);
if (!retStr)
return 0;
/***
* Move canonical representation to a XMLCh buffer to return
*/
XMLSize_t canRepLen = XMLString::stringLen((char*)canRepInByte);
XMLCh *canRepData = (XMLCh*) getExternalMemory(memMgr, (canRepLen + 1) * sizeof(XMLCh));
for (XMLSize_t j = 0; j < canRepLen; j++)
canRepData[j] = (XMLCh)canRepInByte[j];
canRepData[canRepLen] = 0;
/***
* Release the memory allocated in the actual decoding method
*/
returnExternalMemory(memMgr, retStr);
returnExternalMemory(memMgr, canRepInByte);
return canRepData;
}
XMLByte* Base64::decodeToXMLByte(const XMLCh* const inputData
, XMLSize_t* decodedLen
, MemoryManager* const memMgr
, Conformance conform )
{
if (!inputData || !*inputData)
return 0;
/***
* Move input data to a XMLByte buffer
*/
XMLSize_t srcLen = XMLString::stringLen(inputData);
XMLByte *dataInByte = (XMLByte*) getExternalMemory(memMgr, (srcLen+1) * sizeof(XMLByte));
ArrayJanitor<XMLByte> janFill(dataInByte, memMgr ? memMgr : XMLPlatformUtils::fgMemoryManager);
for (XMLSize_t i = 0; i < srcLen; i++)
dataInByte[i] = (XMLByte)inputData[i];
dataInByte[srcLen] = 0;
/***
* Forward to the actual decoding method to do the decoding
*/
*decodedLen = 0;
return decode(dataInByte, decodedLen, memMgr, conform);
}
XMLCh* Base64::decode(const XMLCh* const inputData
, unsigned int* decodedLen
, MemoryManager* const memMgr
, Conformance conform )
{
if (!inputData)
return 0;
/***
* Move input data to a XMLByte buffer
*/
unsigned int srcLen = XMLString::stringLen(inputData);
XMLByte *dataInByte = (XMLByte*) getExternalMemory(memMgr, (srcLen+1) * sizeof(XMLByte));
ArrayJanitor<XMLByte> janFill(dataInByte, memMgr ? memMgr : XMLPlatformUtils::fgMemoryManager);
for (unsigned int i = 0; i < srcLen; i++)
dataInByte[i] = (XMLByte)inputData[i];
dataInByte[srcLen] = 0;
/***
* Forward to the actual decoding method to do the decoding
*/
*decodedLen = 0;
XMLByte *DecodedBuf = decode(dataInByte, decodedLen, memMgr, conform);
if (!DecodedBuf)
return 0;
/***
* Move decoded data to a XMLCh buffer to return
*/
XMLCh *toRet = (XMLCh*) getExternalMemory(memMgr, (*decodedLen+1) * sizeof(XMLCh));
for (unsigned int j = 0; j < *decodedLen; j++)
toRet[j] = (XMLCh)DecodedBuf[j];
toRet[*decodedLen] = 0;
/***
* Release the memory allocated in the actual decoding method
*/
returnExternalMemory(memMgr, DecodedBuf);
return toRet;
}
XMLByte* Base64::decode ( const XMLByte* const inputData
, XMLSize_t* decodedLength
, XMLByte*& canRepData
, MemoryManager* const memMgr
, Conformance conform
)
{
if ((!inputData) || (!*inputData))
return 0;
//
// remove all XML whitespaces from the base64Data
//
XMLSize_t inputLength = XMLString::stringLen( (const char*)inputData );
XMLByte* rawInputData = (XMLByte*) getExternalMemory(memMgr, (inputLength+1) * sizeof(XMLByte));
ArrayJanitor<XMLByte> jan(rawInputData, memMgr ? memMgr : XMLPlatformUtils::fgMemoryManager);
XMLSize_t inputIndex = 0;
XMLSize_t rawInputLength = 0;
bool inWhiteSpace = false;
switch (conform)
{
case Conf_RFC2045:
while ( inputIndex < inputLength )
{
if (!XMLChar1_0::isWhitespace(inputData[inputIndex]))
{
rawInputData[ rawInputLength++ ] = inputData[ inputIndex ];
}
// RFC2045 does not explicitly forbid more than ONE whitespace
// before, in between, or after base64 octects.
// Besides, S? allows more than ONE whitespace as specified in the production
// [3] S ::= (#x20 | #x9 | #xD | #xA)+
// therefore we do not detect multiple ws
inputIndex++;
}
break;
case Conf_Schema:
// no leading #x20
if (chSpace == inputData[inputIndex])
return 0;
while ( inputIndex < inputLength )
{
if (chSpace != inputData[inputIndex])
{
rawInputData[ rawInputLength++ ] = inputData[ inputIndex ];
inWhiteSpace = false;
}
else
{
if (inWhiteSpace)
return 0; // more than 1 #x20 encountered
else
inWhiteSpace = true;
}
inputIndex++;
}
// no trailing #x20
if (inWhiteSpace)
return 0;
break;
default:
break;
}
//now rawInputData contains canonical representation
//if the data is valid Base64
rawInputData[ rawInputLength ] = 0;
// the length of raw data should be divisible by four
if (( rawInputLength % FOURBYTE ) != 0 )
return 0;
int quadrupletCount = (int)rawInputLength / FOURBYTE;
if ( quadrupletCount == 0 )
return 0;
//
// convert the quadruplet(s) to triplet(s)
//
XMLByte d1, d2, d3, d4; // base64 characters
XMLByte b1, b2, b3, b4; // base64 binary codes ( 0..64 )
XMLSize_t rawInputIndex = 0;
XMLSize_t outputIndex = 0;
XMLByte *decodedData = (XMLByte*) getExternalMemory(memMgr, (quadrupletCount*3+1) * sizeof(XMLByte));
//
// Process all quadruplet(s) except the last
//
int quad = 1;
for (; quad <= quadrupletCount-1; quad++ )
{
// read quadruplet from the input stream
if (!isData( (d1 = rawInputData[ rawInputIndex++ ]) ) ||
!isData( (d2 = rawInputData[ rawInputIndex++ ]) ) ||
!isData( (d3 = rawInputData[ rawInputIndex++ ]) ) ||
!isData( (d4 = rawInputData[ rawInputIndex++ ]) ))
{
// if found "no data" just return NULL
returnExternalMemory(memMgr, decodedData);
return 0;
}
b1 = base64Inverse[ d1 ];
b2 = base64Inverse[ d2 ];
b3 = base64Inverse[ d3 ];
b4 = base64Inverse[ d4 ];
// write triplet to the output stream
decodedData[ outputIndex++ ] = set1stOctet(b1, b2);
decodedData[ outputIndex++ ] = set2ndOctet(b2, b3);
decodedData[ outputIndex++ ] = set3rdOctet(b3, b4);
}
//
// process the last Quadruplet
//
// first two octets are present always, process them
if (!isData( (d1 = rawInputData[ rawInputIndex++ ]) ) ||
!isData( (d2 = rawInputData[ rawInputIndex++ ]) ))
{
// if found "no data" just return NULL
returnExternalMemory(memMgr, decodedData);
return 0;
}
b1 = base64Inverse[ d1 ];
b2 = base64Inverse[ d2 ];
// try to process last two octets
d3 = rawInputData[ rawInputIndex++ ];
d4 = rawInputData[ rawInputIndex++ ];
if (!isData( d3 ) || !isData( d4 ))
{
// check if last two are PAD characters
if (isPad( d3 ) && isPad( d4 ))
{
// two PAD e.g. 3c==
if ((b2 & 0xf) != 0) // last 4 bits should be zero
{
returnExternalMemory(memMgr, decodedData);
return 0;
}
decodedData[ outputIndex++ ] = set1stOctet(b1, b2);
}
else if (!isPad( d3 ) && isPad( d4 ))
{
// one PAD e.g. 3cQ=
b3 = base64Inverse[ d3 ];
if (( b3 & 0x3 ) != 0 ) // last 2 bits should be zero
{
returnExternalMemory(memMgr, decodedData);
return 0;
}
decodedData[ outputIndex++ ] = set1stOctet( b1, b2 );
decodedData[ outputIndex++ ] = set2ndOctet( b2, b3 );
}
else
{
// an error like "3c[Pad]r", "3cdX", "3cXd", "3cXX" where X is non data
returnExternalMemory(memMgr, decodedData);
return 0;
}
}
else
{
// no PAD e.g 3cQl
b3 = base64Inverse[ d3 ];
b4 = base64Inverse[ d4 ];
decodedData[ outputIndex++ ] = set1stOctet( b1, b2 );
decodedData[ outputIndex++ ] = set2ndOctet( b2, b3 );
decodedData[ outputIndex++ ] = set3rdOctet( b3, b4 );
}
// write out the end of string
decodedData[ outputIndex ] = 0;
*decodedLength = outputIndex;
//allow the caller to have access to the canonical representation
jan.release();
canRepData = rawInputData;
return decodedData;
}
XMLByte* Base64::encode(const XMLByte* const inputData
, const XMLSize_t inputLength
, XMLSize_t* outputLength
, MemoryManager* const memMgr)
{
if (!inputData || !outputLength)
return 0;
int quadrupletCount = ( (int)inputLength + 2 ) / 3;
if (quadrupletCount == 0)
return 0;
// number of rows in encoded stream ( including the last one )
int lineCount = ( quadrupletCount + quadsPerLine-1 ) / quadsPerLine;
//
// convert the triplet(s) to quadruplet(s)
//
XMLByte b1, b2, b3, b4; // base64 binary codes ( 0..63 )
XMLSize_t inputIndex = 0;
XMLSize_t outputIndex = 0;
XMLByte *encodedData = (XMLByte*) getExternalMemory(memMgr, (quadrupletCount*FOURBYTE+lineCount+1) * sizeof(XMLByte));
//
// Process all quadruplet(s) except the last
//
int quad = 1;
for (; quad <= quadrupletCount-1; quad++ )
{
// read triplet from the input stream
split1stOctet( inputData[ inputIndex++ ], b1, b2 );
split2ndOctet( inputData[ inputIndex++ ], b2, b3 );
split3rdOctet( inputData[ inputIndex++ ], b3, b4 );
// write quadruplet to the output stream
encodedData[ outputIndex++ ] = base64Alphabet[ b1 ];
encodedData[ outputIndex++ ] = base64Alphabet[ b2 ];
encodedData[ outputIndex++ ] = base64Alphabet[ b3 ];
encodedData[ outputIndex++ ] = base64Alphabet[ b4 ];
if (( quad % quadsPerLine ) == 0 )
encodedData[ outputIndex++ ] = chLF;
}
//
// process the last Quadruplet
//
// first octet is present always, process it
split1stOctet( inputData[ inputIndex++ ], b1, b2 );
encodedData[ outputIndex++ ] = base64Alphabet[ b1 ];
if( inputIndex < inputLength )
{
// second octet is present, process it
split2ndOctet( inputData[ inputIndex++ ], b2, b3 );
encodedData[ outputIndex++ ] = base64Alphabet[ b2 ];
if( inputIndex < inputLength )
{
// third octet present, process it
// no PAD e.g. 3cQl
split3rdOctet( inputData[ inputIndex++ ], b3, b4 );
encodedData[ outputIndex++ ] = base64Alphabet[ b3 ];
encodedData[ outputIndex++ ] = base64Alphabet[ b4 ];
}
else
{
// third octet not present
// one PAD e.g. 3cQ=
encodedData[ outputIndex++ ] = base64Alphabet[ b3 ];
encodedData[ outputIndex++ ] = base64Padding;
}
}
else
{
// second octet not present
// two PADs e.g. 3c==
encodedData[ outputIndex++ ] = base64Alphabet[ b2 ];
encodedData[ outputIndex++ ] = base64Padding;
encodedData[ outputIndex++ ] = base64Padding;
}
// write out end of the last line
encodedData[ outputIndex++ ] = chLF;
// write out end of string
encodedData[ outputIndex ] = 0;
*outputLength = outputIndex;
return encodedData;
}
