// This function will base64 ENCODE theData,
// and then Set() that as the string contents.
bool OTASCIIArmor::SetData(const OTData & theData, bool bLineBreaks/*=true*/)
{
return SetAndPackData(theData, bLineBreaks);
char * pString = NULL;
Release();
if (theData.GetSize() < 1)
return true;
pString = OT_base64_encode((const uint8_t*)theData.GetPointer(), theData.GetSize(), (bLineBreaks ? 1 : 0));
if (pString)
{
Set(pString);
delete [] pString; pString=NULL;
return true;
}
else
{
OTLog::Error("Error while base64_encoding in OTASCIIArmor::GetData.\n");
return false;
}
}
// This function will base64 ENCODE theData,
// and then Set() that as the string contents.
// Additionally it will pack and compress the data!
//
bool OTASCIIArmor::SetAndPackData(const OTData & theData, bool bLineBreaks/*=true*/)
{
char * pString = NULL;
Release();
if (theData.GetSize() < 1)
return true;
// --------------------------------------------------------
OTDB::OTPacker * pPacker = OTASCIIArmor::GetPacker(); // No need to check for failure, since this already ASSERTS. No need to cleanup either.
// Here I use the default storage context to create the object (the blob.)
// I also originally created OTASCIIArmor::GetPacker() using OTDB_DEFAULT_PACKER,
// so I know everything is compatible.
//
OTDB::Blob * pBlob = dynamic_cast<OTDB::Blob *>(OTDB::CreateObject(OTDB::STORED_OBJ_BLOB));
OT_ASSERT(NULL != pBlob); // Beyond this point, responsible to delete pBlob.
OTCleanup<OTDB::Blob> theBlobAngel(*pBlob); // make sure memory is cleaned up.
// -----------------------------
pBlob->m_memBuffer.assign(static_cast<const unsigned char *>(theData.GetPointer()),
static_cast<const unsigned char *>(theData.GetPointer())+theData.GetSize());
OTDB::PackedBuffer * pBuffer = pPacker->Pack(*pBlob); // Now we PACK our data before compressing/encoding it.
if (NULL == pBuffer)
{
OTLog::Error("Failed packing data in OTASCIIArmor::SetAndPackData. \n");
return false;
}
OTCleanup<OTDB::PackedBuffer> theBufferAngel(*pBuffer); // make sure memory is cleaned up.
// --------------------------------------------------------
const uint8_t* pUint = static_cast<const uint8_t*>(pBuffer->GetData());
const size_t theSize = pBuffer->GetSize();
if (NULL != pUint)
pString = OT_base64_encode(pUint, theSize, (bLineBreaks ? 1 : 0));
else
{
OTLog::Error("Error while base64_encoding in OTASCIIArmor::SetAndPackData.\n");
return false;
}
// -------------------------------------
if (NULL != pString)
{
Set(pString);
delete [] pString; pString=NULL;
return true;
}
else
{
OTLog::Error("Error while base64_encoding in OTASCIIArmor::SetAndPackData.\n");
return false;
}
}
/// This function first Packs the incoming string, using whatever is the default packer. (MsgPack or Protobuf).
/// Then it Compresses the packed binary data using zlib. (ezcompress.)
/// Then it Base64-Encodes the compressed binary and sets it as a string on THIS OBJECT.
///
/// I added these pieces 1-by-1 over time. At first the messages were too long, so I started compressing them.
/// Then they were not binary compatible across various platforms, so I added the packing.
//
bool OTASCIIArmor::SetAndPackString(const OTString & theData, bool bLineBreaks) //=true
{
// OTLog::vError("DEBUGGING OTASCIIARMOR::SETSTRING, INPUT: --------->%s<---------", theData.Get());
Release();
if (theData.GetLength() < 1)
return true;
// --------------------------------------------------------
OTDB::OTPacker * pPacker = OTASCIIArmor::GetPacker(); // No need to check for failure, since this already ASSERTS. No need to cleanup either.
// Here I use the default storage context to create the object (the blob.)
// I also originally created OTASCIIArmor::GetPacker() using OTDB_DEFAULT_PACKER,
// so I know everything is compatible.
//
OTDB::OTDBString * pOTDBString = dynamic_cast<OTDB::OTDBString *>(OTDB::CreateObject(OTDB::STORED_OBJ_STRING));
OT_ASSERT(NULL != pOTDBString); // Beyond this point, responsible to delete pString.
OTCleanup<OTDB::OTDBString> theStringAngel(*pOTDBString); // make sure memory is cleaned up.
// -----------------------------
const uint32_t theStringSize32 = theData.GetLength();
const size_t theStringSize = theStringSize32; // might need a cast here. // todo make sure this will handle sizes as big as I need.
pOTDBString->m_string.assign(theData.Get(), // const char *
theStringSize);
OTDB::PackedBuffer * pBuffer = pPacker->Pack(*pOTDBString); // Now we PACK our string before compressing/encoding it.
if (NULL == pBuffer)
{
OTLog::Error("Failed packing string in OTASCIIArmor::SetAndPackString. \n");
return false;
}
OTCleanup<OTDB::PackedBuffer> theBufferAngel(*pBuffer); // make sure memory is cleaned up.
// --------------------------------------------------------
const uint8_t* pUint = static_cast<const uint8_t*>(pBuffer->GetData());
const size_t theSize = pBuffer->GetSize();
// --------------------------------------------------------
char * pString = NULL;
// Set up source buffer and destination buffer
long nDestLen = DEFAULT_BUFFER_SIZE_EASYZLIB; // todo stop hardcoding numbers (but this one is OK I think.)
const long lSourcelen = theSize;
unsigned char* pSource = new unsigned char[lSourcelen+10]; // for safety
unsigned char* pDest = new unsigned char[nDestLen+10]; // for safety
OT_ASSERT(NULL != pSource);
OT_ASSERT(NULL != pDest);
memcpy(pSource, static_cast<const unsigned char*>(pUint), theSize );
// Now we are compressing first before base64-encoding (for strings, anyway)
int nErr = ezcompress( pDest, &nDestLen, pSource, lSourcelen );
// If the destination buffer wasn't the right size the first time around,
// then we re-allocate it to the right size (which we now know) and try again...
if ( nErr == EZ_BUF_ERROR )
{
delete [] pDest;
pDest = new unsigned char [nDestLen]; // enough room now
OT_ASSERT(NULL != pDest);
nErr = ezcompress( pDest, &nDestLen, pSource, lSourcelen );
}
// Clean this up...
delete [] pSource;
pSource = NULL;
// Still errors?
if ( nErr == EZ_BUF_ERROR )
{
delete [] pDest;
pDest = NULL;
OT_ASSERT_MSG(false, "Error allocating memory in OTASCIIArmor::SetAndPackString\n");
return false; // not really necessary but just making sure.
}
else if ( nErr == EZ_STREAM_ERROR )
{
delete [] pDest;
pDest = NULL;
OT_ASSERT_MSG(false, "pDest is NULL in OTASCIIArmor::SetAndPackString\n");
return false; // not really necessary but just making sure.
}
else if ( nErr == EZ_DATA_ERROR )
{
delete [] pDest;
pDest = NULL;
OT_ASSERT_MSG(false, "corrupted pSrc passed to ezuncompress OTASCIIArmor::SetAndPackString\n");
return false; // not really necessary but just making sure.
}
else if ( nErr == EZ_MEM_ERROR )
{
delete [] pDest;
pDest = NULL;
OT_ASSERT_MSG(false, "Out of memory in OTASCIIArmor::SetAndPackString\n");
return false; // not really necessary but just making sure.
}
OT_ASSERT_MSG(pDest != NULL, "pDest NULL in OTASCIIArmor::SetAndPackString\n");
// Success
if (0 < nDestLen)
{
// Now let's base-64 encode it...
pString = OT_base64_encode((const uint8_t*)pDest, nDestLen, (bLineBreaks ? 1 : 0));
delete [] pDest;
pDest = NULL;
if (pString)
{
Set(pString);
delete [] pString; pString=NULL;
return true;
}
else
{
OTLog::Error("pString NULL in OTASCIIArmor::SetAndPackString\n");
}
}
else
{
OTLog::Error("nDestLen 0 in OTASCIIArmor::SetAndPackString\n");
}
if (pDest)
delete [] pDest;
pDest = NULL;
return false;
}
// This version is fully functional, and performs compression in addition to base64-encoding.
//
bool OTASCIIArmor::SetString(const OTString & theData, bool bLineBreaks) //=true
{
return SetAndPackString(theData, bLineBreaks);
// ---------------------------------------------------------------
// OTLog::vError("DEBUGGING OTASCIIARMOR::SETSTRING, INPUT: --------->%s<---------", theData.Get());
Release();
if (theData.GetLength() < 1)
return true;
char * pString = NULL;
// Set up source buffer and destination buffer
long nDestLen = DEFAULT_BUFFER_SIZE_EASYZLIB; // todo stop hardcoding numbers (but this one is OK I think.)
const long lSourcelen = sizeof(unsigned char)*theData.GetLength()+1;// for null terminator
unsigned char* pSource = new unsigned char[lSourcelen+10]; // for safety
unsigned char* pDest = new unsigned char[nDestLen+10]; // for safety
OT_ASSERT(NULL != pSource);
OT_ASSERT(NULL != pDest);
memcpy(pSource, (const unsigned char*)theData.Get(), lSourcelen );
// Now we are compressing first before base64-encoding (for strings, anyway)
int nErr = ezcompress( pDest, &nDestLen, pSource, lSourcelen );
// If the destination buffer wasn't the right size the first time around,
// then we re-allocate it to the right size (which we now know) and try again...
if ( nErr == EZ_BUF_ERROR )
{
delete [] pDest;
pDest = new unsigned char [nDestLen]; // enough room now
OT_ASSERT(NULL != pDest);
nErr = ezcompress( pDest, &nDestLen, pSource, lSourcelen );
}
// Clean this up...
delete [] pSource;
pSource = NULL;
// Still errors?
if ( nErr == EZ_BUF_ERROR )
{
delete [] pDest;
pDest = NULL;
OT_ASSERT_MSG(false, "Error allocating memory in OTASCIIArmor::SetString\n");
return false; // not really necessary but just making sure.
}
else if ( nErr == EZ_STREAM_ERROR )
{
delete [] pDest;
pDest = NULL;
OT_ASSERT_MSG(false, "pDest is NULL in OTASCIIArmor::SetString\n");
return false; // not really necessary but just making sure.
}
else if ( nErr == EZ_DATA_ERROR )
{
delete [] pDest;
pDest = NULL;
OT_ASSERT_MSG(false, "corrupted pSrc passed to ezuncompress OTASCIIArmor::SetString\n");
return false; // not really necessary but just making sure.
}
else if ( nErr == EZ_MEM_ERROR )
{
delete [] pDest;
pDest = NULL;
OT_ASSERT_MSG(false, "Out of memory in OTASCIIArmor::SetString\n");
return false; // not really necessary but just making sure.
}
OT_ASSERT_MSG(pDest != NULL, "pDest NULL in OTASCIIArmor::SetString\n");
// Success
if (0 < nDestLen)
{
// Now let's base-64 encode it...
pString = OT_base64_encode((const uint8_t*)pDest, nDestLen, (bLineBreaks ? 1 : 0));
// pString = OT_base64_encode((const uint8_t*)theData.Get(), theData.GetLength()+1, (bLineBreaks ? 1 : 0)); // this was before we used compression.
delete [] pDest;
pDest = NULL;
if (pString)
{
Set(pString);
delete [] pString; pString=NULL;
return true;
}
else
{
OTLog::Error("pString NULL in OTASCIIArmor::SetString\n");
}
}
else
{
OTLog::Error("nDestLen 0 in OTASCIIArmor::SetString\n");
}
if (pDest)
delete [] pDest;
pDest = NULL;
return false;
}
bool OTASCIIArmor::SetAndPackStringMap(const std::map<std::string, std::string> & the_map, bool bLineBreaks/*=true*/)
{
char * pString = NULL;
Release();
if (the_map.size() < 1)
return true;
// --------------------------------------------------------
OTDB::OTPacker * pPacker = OTASCIIArmor::GetPacker(); // No need to check for failure, since this already ASSERTS. No need to cleanup either.
// Here I use the default storage context to create the object (the string map.)
// I also originally created OTASCIIArmor::GetPacker() using OTDB_DEFAULT_PACKER,
// so I know everything is compatible.
//
OTDB::StringMap * pStringMap = dynamic_cast<OTDB::StringMap *>(OTDB::CreateObject(OTDB::STORED_OBJ_STRING_MAP));
OT_ASSERT(NULL != pStringMap); // Beyond this point, responsible to delete pStringMap.
OTCleanup<OTDB::StringMap> theMapAngel(*pStringMap); // make sure memory is cleaned up.
// -----------------------------
pStringMap->the_map = the_map;
// -----------------------------
OTDB::PackedBuffer * pBuffer = pPacker->Pack(*pStringMap); // Now we PACK our data before compressing/encoding it.
if (NULL == pBuffer)
{
OTLog::Error("Failed packing data in OTASCIIArmor::SetAndPackStringMap. \n");
return false;
}
OTCleanup<OTDB::PackedBuffer> theBufferAngel(*pBuffer); // make sure memory is cleaned up.
// --------------------------------------------------------
const uint8_t* pUint = static_cast<const uint8_t*>(pBuffer->GetData());
const size_t theSize = pBuffer->GetSize();
if (NULL != pUint)
pString = OT_base64_encode(pUint, static_cast<int> (theSize), (bLineBreaks ? 1 : 0));
else
{
OTLog::Error("Error while base64_encoding in OTASCIIArmor::SetAndPackStringMap.\n");
return false;
}
// -------------------------------------
if (NULL != pString)
{
Set(pString);
delete [] pString; pString=NULL;
return true;
}
else
{
OTLog::Error("Error while base64_encoding in OTASCIIArmor::SetAndPackStringMap.\n");
return false;
}
}
