std::string getOpenSslErrors()
{
boost::shared_ptr<BIO> bio( BIO_new( BIO_s_mem() ), BIO_free );
ERR_print_errors(bio.get());
std::vector<char> buffer(256);
unsigned int startPos = 0;
unsigned int bytesRead = 0;
while (true)
{
RCF_ASSERT_GT(buffer.size() , startPos);
int ret = BIO_read(
bio.get(),
&buffer[startPos],
static_cast<int>(buffer.size()-startPos));
if (ret > 0)
{
bytesRead += ret;
}
if (bytesRead < buffer.size())
{
break;
}
startPos = static_cast<unsigned int>(buffer.size());
buffer.resize( 2*buffer.size() );
}
return std::string(&buffer[0], bytesRead);
}
void DataPtr::terminatebufferwithzero() const
{
if (ptr_ && ptr_[length_] != 0)
{
RCF_ASSERT_GT(allocatedLength_ , length_);
ptr_[length_] = 0;
}
}
bool FileIoThreadPool::ioTask()
{
FileIoRequestPtr opPtr;
{
RCF::Lock lock(mOpsMutex);
while (mOpsQueued.empty() && !mStopFlag)
{
mOpsCondition.timed_wait(lock, 1000);
}
if (mOpsQueued.empty() || mStopFlag)
{
return false;
}
RCF_ASSERT_GT(mOpsQueued.size() , 0);
mOpsInProgress.push_back( mOpsQueued.front() );
mOpsQueued.pop_front();
opPtr = mOpsInProgress.back();
}
RCF::ThreadInfoPtr threadInfoPtr = RCF::getThreadInfoPtr();
if (threadInfoPtr)
{
threadInfoPtr->notifyBusy();
}
// This is the part that blocks.
opPtr->doTransfer();
// Unregister op.
unregisterOp(opPtr);
// Notify completion.
{
RCF::Lock lock(mCompletionMutex);
opPtr->mCompleted = true;
mCompletionCondition.notify_all();
}
return false;
}
void ZlibCompressionWriteFilter::compress()
{
mPostBuffers.resize(0);
// TODO: buffer size
std::size_t bufferSize = 2*(lengthByteBuffers(mPreBuffers)+7+7);
std::size_t leftMargin = mPreBuffers.front().getLeftMargin();
if (mVecPtr.get() == NULL || !mVecPtr.unique())
{
mVecPtr.reset( new ReallocBuffer());
}
mVecPtr->resize(leftMargin + bufferSize);
if (leftMargin > 0)
{
mPostBuffers.push_back(
ByteBuffer(
&(*mVecPtr)[0] + leftMargin,
mVecPtr->size() - leftMargin,
leftMargin,
mVecPtr));
}
else
{
mPostBuffers.push_back(
ByteBuffer(
&(*mVecPtr)[0],
mVecPtr->size(),
mVecPtr));
}
ByteBuffer &outBuffer = mPostBuffers.back();
std::size_t outPos = 0;
std::size_t outRemaining = outBuffer.getLength() - outPos;
mTotalBytesIn = 0;
mTotalBytesOut = 0;
for (std::size_t i=0; i<mPreBuffers.size(); ++i)
{
RCF_ASSERT_LT(outPos , outBuffer.getLength());
ByteBuffer &inBuffer = mPreBuffers[i];
mCstream.next_in = (Bytef*) inBuffer.getPtr();
mCstream.avail_in = static_cast<uInt>(inBuffer.getLength());
mCstream.next_out = (Bytef*) &outBuffer.getPtr()[outPos];
mCstream.avail_out = static_cast<uInt>(outRemaining);
mZerr = (i<mPreBuffers.size()-1) ?
deflate(&mCstream, Z_NO_FLUSH) :
deflate(&mCstream, Z_SYNC_FLUSH);
RCF_VERIFY(
mZerr == Z_OK || mZerr == Z_BUF_ERROR,
FilterException(
_RcfError_Zlib(), mZerr, RcfSubsystem_Zlib,
"deflate() failed"))
(mZerr)(inBuffer.getLength())(outBuffer.getLength());
RCF_ASSERT_GTEQ(mCstream.avail_out , 0);
std::size_t bytesIn = inBuffer.getLength() - mCstream.avail_in;
std::size_t bytesOut = outRemaining - mCstream.avail_out;
mTotalBytesIn += bytesIn;
mTotalBytesOut += bytesOut;
outPos += bytesOut;
outRemaining -= bytesOut;
}
if (!mStateful)
{
mCstream.next_in = NULL;
mCstream.avail_in = 0;
mCstream.next_out = (Bytef*) &outBuffer.getPtr()[outPos];
mCstream.avail_out = static_cast<uInt>(outRemaining);
mZerr = deflate(&mCstream, Z_FINISH);
RCF_VERIFY(
mZerr == Z_BUF_ERROR || mZerr == Z_STREAM_END,
FilterException(
_RcfError_Zlib(), mZerr, RcfSubsystem_Zlib,
"deflate() failed"))
(mZerr)(outPos)(outRemaining);
RCF_ASSERT_GT(mCstream.avail_out , 0);
std::size_t bytesOut = outRemaining - mCstream.avail_out;
mTotalBytesOut += bytesOut;
outPos += bytesOut;
outRemaining -= bytesOut;
}
mPreBuffers.resize(0);
outBuffer = ByteBuffer(outBuffer, 0, mTotalBytesOut);
}
