void AsioSessionState::postWrite(
std::vector<ByteBuffer> &byteBuffers)
{
if (mLastError)
{
return;
}
BOOST_STATIC_ASSERT(sizeof(unsigned int) == 4);
mSlicedWriteByteBuffers.resize(0);
mWriteByteBuffers.resize(0);
std::copy(
byteBuffers.begin(),
byteBuffers.end(),
std::back_inserter(mWriteByteBuffers));
byteBuffers.resize(0);
if (!mTransport.mCustomFraming)
{
// Add frame (4 byte length prefix).
int messageSize =
static_cast<int>(RCF::lengthByteBuffers(mWriteByteBuffers));
ByteBuffer &byteBuffer = mWriteByteBuffers.front();
RCF_ASSERT_GTEQ(byteBuffer.getLeftMargin() , 4);
byteBuffer.expandIntoLeftMargin(4);
memcpy(byteBuffer.getPtr(), &messageSize, 4);
RCF::machineToNetworkOrder(byteBuffer.getPtr(), 4, 1);
}
mState = AsioSessionState::WritingData;
mWriteBufferRemaining = RCF::lengthByteBuffers(mWriteByteBuffers);
beginWrite();
}
void FileIoRequest::doTransfer()
{
if (mFinPtr)
{
RCF_LOG_4() << "FileIoRequest::doTransfer() - initiate read.";
char * szBuffer = mBuffer.getPtr();
std::size_t szBufferLen = mBuffer.getLength();
mFinPtr->read(szBuffer, szBufferLen);
mBytesTransferred = mFinPtr->gcount();
mFinPtr.reset();
RCF_LOG_4()(mBytesTransferred) << "FileIoRequest::doTransfer() - read complete.";
}
else if (mFoutPtr)
{
RCF_LOG_4() << "FileIoRequest::doTransfer() - initiate write.";
char * szBuffer = mBuffer.getPtr();
std::size_t szBufferLen = mBuffer.getLength();
boost::uint64_t pos0 = mFoutPtr->tellp();
mFoutPtr->write(szBuffer, szBufferLen);
boost::uint64_t pos1 = mFoutPtr->tellp();
RCF_ASSERT_GTEQ(pos1 , pos0);
mBytesTransferred = pos1 - pos0;
RCF_ASSERT_EQ(mBytesTransferred , szBufferLen);
mFoutPtr.reset();
RCF_LOG_4()(mBytesTransferred) << "FileIoRequest::doTransfer() - write complete.";
}
else
{
RCF_ASSERT(0);
mBytesTransferred = 0;
}
}
// return -2 for timeout, -1 for error, 0 for ready
int pollSocket(unsigned int endTimeMs, int fd, int &err, bool bRead)
{
ClientStub & clientStub = *getTlsClientStubPtr();
while (true)
{
fd_set fdSet;
FD_ZERO(&fdSet);
FD_SET( static_cast<SOCKET>(fd), &fdSet);
unsigned int timeoutMs = generateTimeoutMs(endTimeMs);
timeoutMs = clientStub.generatePollingTimeout(timeoutMs);
timeval timeout = {0};
timeout.tv_sec = timeoutMs/1000;
timeout.tv_usec = 1000*(timeoutMs%1000);
RCF_ASSERT_GTEQ(timeout.tv_usec , 0);
int selectRet = bRead ?
Platform::OS::BsdSockets::select(fd+1, &fdSet, NULL, NULL, &timeout) :
Platform::OS::BsdSockets::select(fd+1, NULL, &fdSet, NULL, &timeout);
err = Platform::OS::BsdSockets::GetLastError();
// Handle timeout.
if (selectRet == 0)
{
clientStub.onPollingTimeout();
if (generateTimeoutMs(endTimeMs) != 0)
{
continue;
}
}
// Some socket gymnastics to determine whether a nonblocking connect
// has failed or not.
if (selectRet == 1 && !bRead)
{
int errorOpt = 0;
Platform::OS::BsdSockets::socklen_t len = sizeof(int);
int ret = getsockopt(fd, SOL_SOCKET, SO_ERROR, (char*)(&errorOpt), &len);
err = Platform::OS::BsdSockets::GetLastError();
RCF_VERIFY(
ret == 0,
Exception(_RcfError_Socket("getsockopt()"), err, RcfSubsystem_Os));
if (errorOpt == 0)
{
return 0;
}
else if ( errorOpt == Platform::OS::BsdSockets::ERR_EWOULDBLOCK
|| errorOpt == Platform::OS::BsdSockets::ERR_EINPROGRESS)
{
continue;
}
else
{
err = errorOpt;
return -1;
}
}
switch (selectRet)
{
case 0: return -2;
case 1: return 0;
default: return -1;
};
}
}
inline void serializeEncodedString(SF::Archive & ar, std::basic_string<C,T,A> & ws)
{
if (ar.getRuntimeVersion() < 8)
{
serializeString(ar, ws);
return;
}
RCF_ASSERT_GTEQ(ar.getRuntimeVersion() , 8);
if (ar.isRead())
{
int encodingType = 0;
ar & encodingType;
if (encodingType == 8)
{
// UTF-8 serialization.
std::string s;
ar & s;
ws = RcfBoost::boost::from_utf8(s);
}
else
{
// Native wchar_t serialization.
RCF_VERIFY(
encodingType == sizeof(wchar_t),
RCF::Exception(
RCF::_RcfError_WcharSizeMismatch(sizeof(wchar_t), encodingType)));
serializeString(ar, ws);
}
}
else if (ar.isWrite())
{
bool useNativeWstringSerialization = SF::getCurrentNativeWstringSerialization();
int encodingType = sizeof(wchar_t);
if (useNativeWstringSerialization)
{
encodingType = sizeof(wchar_t);
}
else
{
encodingType = 8;
}
ar & encodingType;
if (encodingType == 8)
{
// UTF-8 serialization.
std::string s = RcfBoost::boost::to_utf8(ws);
ar & s;
}
else
{
// Native wchar_t serialization.
RCF_VERIFY(
encodingType == sizeof(wchar_t),
RCF::Exception(
RCF::_RcfError_WcharSizeMismatch(sizeof(wchar_t), encodingType)));
serializeString(ar, ws);
}
}
}
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);
}
