/// if we pack, compress, encode on the way in, that means, therefore, we
/// need to decode, uncompress, then unpack on our way out. Right?
///
/// This function will base64-DECODE the string contents, then uncompress them using
/// zlib, and then unpack the result using whatever is the default packer (MsgPack, Protobuf, etc).
///
/// I originally added compression because message sizes were too big. Now I'm adding packing,
/// to solve any issues of binary compatibility across various platforms.
//
bool OTASCIIArmor::GetAndUnpackString(OTString & strData, bool bLineBreaks) const //bLineBreaks=true
{
size_t outSize = 0;
uint8_t * pData = NULL;
strData.Release();
if (GetLength() < 1)
{
return true;
}
// --------------------------------------------------------------
pData = OTCrypto::It()->Base64Decode(this->Get(), &outSize, bLineBreaks);
// pData = OT_base64_decode(Get(), &outSize, (bLineBreaks ? 1 : 0));
if (pData)
{
std::string str_decoded( pData, pData+outSize );
delete [] pData; pData=NULL;
std::string str_uncompressed = decompress_string( str_decoded );
// ---------------------------------------
// PUT THE PACKED BUFFER HERE, AND UNPACK INTO strData
// --------------------------------------------------------
OTDB::OTPacker * pPacker = OTASCIIArmor::GetPacker(); // No need to check for failure, since this already ASSERTS. No need to cleanup either.
OTDB::PackedBuffer * pBuffer = pPacker->CreateBuffer(); // Need to clean this up.
OT_ASSERT(NULL != pBuffer);
OTCleanup<OTDB::PackedBuffer> theBufferAngel(*pBuffer); // This will make sure buffer is deleted later.
pBuffer->SetData(reinterpret_cast<const uint8_t *>(str_uncompressed.data()), str_uncompressed.size());
// -----------------------------
OTDB::OTDBString * pOTDBString = dynamic_cast<OTDB::OTDBString *>(OTDB::CreateObject(OTDB::STORED_OBJ_STRING));
OT_ASSERT(NULL != pOTDBString);
OTCleanup<OTDB::OTDBString> theStringAngel(*pOTDBString); // clean up this string.
bool bUnpacked = pPacker->Unpack(*pBuffer, *pOTDBString);
// ----------------------
if (false == bUnpacked)
{
OTLog::Error("Failed unpacking string in OTASCIIArmor::GetAndUnpackString.\n");
return false;
}
// --------------------------------------------------------
// This enforces the null termination. (using the 2nd parameter as nEnforcedMaxLength)
strData.Set(pOTDBString->m_string.c_str(), static_cast<uint32_t> (pOTDBString->m_string.length()));
return true;
}
else
{
OTLog::Error("OTASCIIArmor::GetAndUnpackString: NULL pData while base64-decoding pData.\n");
return false;
}
}
// This function will base64 DECODE the string contents
// and return them as binary in theData
// Additionally it will decompress and unpack the data!
//
bool OTASCIIArmor::GetAndUnpackData(OTData & theData, bool bLineBreaks) const //linebreaks=true
{
size_t outSize = 0;
uint8_t * pData = NULL;
theData.Release();
if (GetLength() < 1)
return true;
// --------------------------------------------------------------
//
pData = OT_base64_decode(Get(), &outSize, (bLineBreaks ? 1 : 0));
if (pData)
{
// --------------------------------------------------------
OTDB::OTPacker * pPacker = OTASCIIArmor::GetPacker(); // No need to check for failure, since this already ASSERTS. No need to cleanup either.
OTDB::PackedBuffer * pBuffer = pPacker->CreateBuffer(); // Need to clean this up.
OT_ASSERT(NULL != pBuffer);
OTCleanup<OTDB::PackedBuffer> theBufferAngel(*pBuffer); // make sure buffer is deleted.
pBuffer->SetData(static_cast<const unsigned char*>(pData), outSize);
delete [] pData; pData=NULL;
// -----------------------------
OTDB::Blob * pBlob = dynamic_cast<OTDB::Blob *>(OTDB::CreateObject(OTDB::STORED_OBJ_BLOB));
OT_ASSERT(NULL != pBlob);
OTCleanup<OTDB::Blob> theBlobAngel(*pBlob); // clean up this blob.
bool bUnpacked = pPacker->Unpack(*pBuffer, *pBlob);
// ----------------------
if (false == bUnpacked)
{
OTLog::Error("Failed unpacking data in OTASCIIArmor::GetAndUnpackData.\n");
delete [] pData; pData=NULL;
return false;
}
// --------------------------------------------------------
theData.Assign(pBlob->m_memBuffer.data(), pBlob->m_memBuffer.size());
delete [] pData; pData=NULL;
return true;
}
else
{
OTLog::Error("Error while base64_decoding in OTASCIIArmor::GetAndUnpackData.\n");
return false;
}
}
bool OTASCIIArmor::GetAndUnpackStringMap(std::map<std::string, std::string> & the_map, bool bLineBreaks/*=true*/) const
{
size_t outSize = 0;
uint8_t * pData = NULL;
the_map.clear();
if (GetLength() < 1)
return true;
// --------------------------------------------------------------
//
pData = OT_base64_decode(Get(), &outSize, (bLineBreaks ? 1 : 0));
if (pData)
{
// --------------------------------------------------------
OTDB::OTPacker * pPacker = OTASCIIArmor::GetPacker(); // No need to check for failure, since this already ASSERTS. No need to cleanup either.
OTDB::PackedBuffer * pBuffer = pPacker->CreateBuffer(); // Need to clean this up.
OT_ASSERT(NULL != pBuffer);
OTCleanup<OTDB::PackedBuffer> theBufferAngel(*pBuffer); // make sure buffer is deleted.
pBuffer->SetData(static_cast<const unsigned char*>(pData), outSize);
delete [] pData; pData=NULL;
// -----------------------------
OTDB::StringMap * pStringMap = dynamic_cast<OTDB::StringMap *>(OTDB::CreateObject(OTDB::STORED_OBJ_STRING_MAP));
OT_ASSERT(NULL != pStringMap);
OTCleanup<OTDB::StringMap> theMapAngel(*pStringMap); // clean up this map.
bool bUnpacked = pPacker->Unpack(*pBuffer, *pStringMap);
// ----------------------
if (false == bUnpacked)
{
OTLog::Error("Failed unpacking data in OTASCIIArmor::GetAndUnpackStringMap.\n");
delete [] pData; pData=NULL;
return false;
}
// -----------------------------
the_map = pStringMap->the_map;
// -----------------------------
delete [] pData; pData=NULL;
return true;
}
else
{
OTLog::Error("Error while base64_decoding in OTASCIIArmor::GetAndUnpackStringMap.\n");
return false;
}
}
/// if we pack, compress, encode on the way in, that means, therefore, we
/// need to decode, uncompress, then unpack on our way out. Right?
///
/// This function will base64-DECODE the string contents, then uncompress them using
/// zlib, and then unpack the result using whatever is the default packer (MsgPack, Protobuf, etc).
///
/// I originally added compression because message sizes were too big. Now I'm adding packing,
/// to solve any issues of binary compatibility across various platforms.
//
bool OTASCIIArmor::GetAndUnpackString(OTString & strData, bool bLineBreaks) const //bLineBreaks=true
{
size_t outSize = 0;
uint8_t * pData = NULL;
strData.Release();
if (GetLength() < 1)
{
return true;
}
// --------------------------------------------------------------
pData = OTCrypto::It()->Base64Decode(this->Get(), &outSize, bLineBreaks);
// pData = OT_base64_decode(Get(), &outSize, (bLineBreaks ? 1 : 0));
if (pData)
{
// -------------------------------------------
// EASY ZLIB
//
long nDestLen = DEFAULT_BUFFER_SIZE_EASYZLIB; // todo stop hardcoding numbers (but this one is OK I think.)
unsigned char* pDest = new unsigned char [nDestLen+10]; // For safety.
OT_ASSERT(NULL != pDest);
int nErr = ezuncompress( pDest, &nDestLen, pData, static_cast<long> (outSize) );
if ( nErr == EZ_BUF_ERROR )
{
delete [] pDest;
pDest = new unsigned char [nDestLen]; // enough room now
OT_ASSERT(NULL != pDest);
nErr = ezuncompress( pDest, &nDestLen, pData, static_cast<long> (outSize) );
}
// Now we're done with this memory, let's free it.
delete [] pData; pData=NULL;
// ----------------------------------------
if ( nErr == EZ_BUF_ERROR )
{
delete [] pDest;
pDest = NULL;
OT_FAIL_MSG("Buffer error in OTASCIIArmor::GetAndUnpackString\n");
}
else if ( nErr == EZ_STREAM_ERROR )
{
delete [] pDest;
pDest = NULL;
OT_FAIL_MSG("pDest is NULL in OTASCIIArmor::GetAndUnpackString\n");
}
else if ( nErr == EZ_DATA_ERROR )
{
delete [] pDest;
pDest = NULL;
OTLog::vError("corrupted pSrc passed to ezuncompress OTASCIIArmor::GetAndUnpackString, size: %d\n", outSize);
OT_FAIL;
}
else if ( nErr == EZ_MEM_ERROR )
{
delete [] pDest;
pDest = NULL;
OT_FAIL_MSG("Out of memory in OTASCIIArmor::GetAndUnpackString\n");
}
// ---------------------------------------
// PUT THE PACKED BUFFER HERE, AND UNPACK INTO strData
// --------------------------------------------------------
OTDB::OTPacker * pPacker = OTASCIIArmor::GetPacker(); // No need to check for failure, since this already ASSERTS. No need to cleanup either.
OTDB::PackedBuffer * pBuffer = pPacker->CreateBuffer(); // Need to clean this up.
OT_ASSERT(NULL != pBuffer);
OTCleanup<OTDB::PackedBuffer> theBufferAngel(*pBuffer); // This will make sure buffer is deleted later.
const size_t theDestLen = nDestLen;
pBuffer->SetData(pDest, // const unsigned char *
theDestLen);
delete [] pDest; pDest=NULL;
// -----------------------------
OTDB::OTDBString * pOTDBString = dynamic_cast<OTDB::OTDBString *>(OTDB::CreateObject(OTDB::STORED_OBJ_STRING));
OT_ASSERT(NULL != pOTDBString);
OTCleanup<OTDB::OTDBString> theStringAngel(*pOTDBString); // clean up this string.
bool bUnpacked = pPacker->Unpack(*pBuffer, *pOTDBString);
// ----------------------
if (false == bUnpacked)
{
OTLog::Error("Failed unpacking string in OTASCIIArmor::GetAndUnpackString.\n");
return false;
}
// --------------------------------------------------------
// This enforces the null termination. (using the 2nd parameter as nEnforcedMaxLength)
strData.Set(pOTDBString->m_string.c_str(), static_cast<uint32_t> (pOTDBString->m_string.length()));
return true;
}
else
{
OTLog::Error("OTASCIIArmor::GetAndUnpackString: NULL pData while base64-decoding pData.\n");
return false;
}
}