/***************************************************************************
* setStaticFieldFunctionObject
***************************************************************************/
bool CCilVm::setStaticFieldFunctionObject( const RID rid,
const RID ridMethod )
{
assert( TypeFromToken( ridMethod ) == MDT_METHODDEF );
//Create function object and store it to static field
CVmObject newobject;
RID ridObj = getFunctionObjectRID();
newobject.setRID( ridObj );
newobject.setObjectName( getMetaData().getObjectNameRID( ridObj ) );
newobject.setPrototypeObject( &getPrototypeObject( ridObj ) );
newobject.setConstructorProperty( ridMethod );
newobject.setCallProperty( ridMethod );
getObjectPool().push_back( newobject );
CVariable var;
var.setObjectRef( &getObjectPool().back() );
METHOD_DEF& method = getMetaData().getMethod( ridMethod );
int32_t iLength = method.iNumArgments;
assert( iLength >= 0 );
CVariable varInt( iLength, OPERAND_FLAG_DONTENUM );
var.refObject->setProperty( STRING_INTERNAL_LENGTH,
varInt );
//Store the ObjectRef to a static field
setStaticField( rid, var );
return true;
}
void HttpSessionFilter::write(const std::vector<ByteBuffer> &byteBuffers)
{
// If we write the response directly to network here, we ar at risk of a race
// condition as the next request may be read in on another connection, before
// the write completion on this connection has executed.
// So instead we make a copy of the write buffers, and send a write completion
// back up. The subsequent read operation will unhook the HTTP session and then
// write the response to the network.
if ( mNetworkSession.mCloseAfterWrite )
{
// Special case, if this is the last message being written before the connection closes.
mpPostFilter->write(byteBuffers);
}
else
{
std::size_t len = lengthByteBuffers(byteBuffers);
ReallocBufferPtr bufferPtr = getObjectPool().getReallocBufferPtr();
bufferPtr->resize(len);
copyByteBuffers(byteBuffers, bufferPtr->getPtr());
mWriteBuffers.resize(0);
mWriteBuffers.push_back(ByteBuffer(bufferPtr));
mpPreFilter->onWriteCompleted(len);
}
}
void PerformanceData::collect()
{
getObjectPool().enumerateBuffers(mInBufferSizes);
getObjectPool().enumerateOstrstreams(mOutBufferSizes);
std::size_t inBufferSize =
std::accumulate(mInBufferSizes.begin(), mInBufferSizes.end(), std::size_t(0));
std::size_t outBufferSize =
std::accumulate(mOutBufferSizes.begin(), mOutBufferSizes.end(), std::size_t(0));
Lock lock(mMutex);
mBufferCount = static_cast<boost::uint32_t>(
mInBufferSizes.size() + mOutBufferSizes.size());
mTotalBufferSize = static_cast<boost::uint32_t>(
inBufferSize + outBufferSize);
}
void AsioSessionState::onNetworkReadCompleted(
AsioErrorCode error, size_t bytesTransferred)
{
RCF_LOG_4()(this)(bytesTransferred) << "AsioSessionState - read from socket completed.";
ThreadTouchGuard threadTouchGuard;
mLastError = error;
mBytesReceivedCounter += bytesTransferred;
#ifdef BOOST_WINDOWS
if (error.value() == ERROR_OPERATION_ABORTED)
{
error = AsioErrorCode();
}
#endif
if (!error && !mTransport.mStopFlag)
{
if (bytesTransferred == 0 && mIssueZeroByteRead)
{
// TCP framing.
if (!mAppReadBufferPtr || !mAppReadBufferPtr.unique())
{
mAppReadBufferPtr = getObjectPool().getReallocBufferPtr();
}
mAppReadBufferPtr->resize(4);
mReadBufferRemaining = 4;
mIssueZeroByteRead = false;
beginRead();
}
else if (mReflecting)
{
AsioErrorCode ec;
onReflectedReadWriteCompleted(ec, bytesTransferred);
}
else
{
CurrentRcfSessionSentry guard(*mSessionPtr);
mNetworkReadByteBuffer = ByteBuffer(
mNetworkReadByteBuffer,
0,
bytesTransferred);
mTransportFilters.empty() ?
onAppReadWriteCompleted(bytesTransferred) :
mTransportFilters.back()->onReadCompleted(mNetworkReadByteBuffer);
}
}
}
void AsioSessionState::doRegularFraming(size_t bytesTransferred)
{
RCF_ASSERT_LTEQ(bytesTransferred , mReadBufferRemaining);
mReadBufferRemaining -= bytesTransferred;
if (mReadBufferRemaining > 0)
{
beginRead();
}
else if (mReadBufferRemaining == 0 && mIssueZeroByteRead)
{
if (!mAppReadBufferPtr || !mAppReadBufferPtr.unique())
{
mAppReadBufferPtr = getObjectPool().getReallocBufferPtr();
}
mAppReadBufferPtr->resize(4);
mReadBufferRemaining = 4;
mIssueZeroByteRead = false;
beginRead();
}
else
{
RCF_ASSERT_EQ(mReadBufferRemaining , 0);
if (mState == ReadingDataCount)
{
ReallocBuffer & readBuffer = *mAppReadBufferPtr;
RCF_ASSERT_EQ(readBuffer.size() , 4);
unsigned int packetLength = 0;
memcpy(&packetLength, &readBuffer[0], 4);
networkToMachineOrder(&packetLength, 4, 1);
if ( mTransport.getMaxMessageLength()
&& packetLength > mTransport.getMaxMessageLength())
{
sendServerError(RcfError_ServerMessageLength);
}
else
{
readBuffer.resize(packetLength);
mReadBufferRemaining = packetLength;
mState = ReadingData;
beginRead();
}
}
else if (mState == ReadingData)
{
mState = Ready;
mTransport.getSessionManager().onReadCompleted(
getSessionPtr());
}
}
}
void AsioSessionState::doCustomFraming(size_t bytesTransferred)
{
RCF_ASSERT_LTEQ(bytesTransferred , mReadBufferRemaining);
mReadBufferRemaining -= bytesTransferred;
if (mReadBufferRemaining > 0)
{
beginRead();
}
else if (mReadBufferRemaining == 0 && mIssueZeroByteRead)
{
if (!mAppReadBufferPtr || !mAppReadBufferPtr.unique())
{
mAppReadBufferPtr = getObjectPool().getReallocBufferPtr();
}
mAppReadBufferPtr->resize(4);
mReadBufferRemaining = 4;
mIssueZeroByteRead = false;
beginRead();
}
else
{
RCF_ASSERT_EQ(mReadBufferRemaining , 0);
if (mState == ReadingDataCount)
{
ReallocBuffer & readBuffer = *mAppReadBufferPtr;
RCF_ASSERT_EQ(readBuffer.size() , 4);
std::size_t messageLength = mTransportFilters[0]->getFrameSize();
if ( mTransport.getMaxMessageLength()
&& messageLength > mTransport.getMaxMessageLength())
{
sendServerError(RcfError_ServerMessageLength);
}
else
{
RCF_ASSERT( messageLength > 4 );
readBuffer.resize(messageLength);
mReadBufferRemaining = messageLength - 4;
mState = ReadingData;
beginRead();
}
}
else if (mState == ReadingData)
{
mState = Ready;
mTransport.getSessionManager().onReadCompleted(
getSessionPtr());
}
}
}
void AsioSessionState::read(
const ByteBuffer &byteBuffer,
std::size_t bytesRequested)
{
if (byteBuffer.getLength() == 0 && bytesRequested > 0)
{
if (!mNetworkReadBufferPtr || mNetworkReadBufferPtr.unique())
{
mNetworkReadBufferPtr = getObjectPool().getReallocBufferPtr();
}
mNetworkReadBufferPtr->resize(bytesRequested);
mNetworkReadByteBuffer = ByteBuffer(mNetworkReadBufferPtr);
}
else
{
mNetworkReadByteBuffer = ByteBuffer(byteBuffer, 0, bytesRequested);
}
RCF_ASSERT_LTEQ(bytesRequested, mNetworkReadByteBuffer.getLength());
char *buffer = mNetworkReadByteBuffer.getPtr();
std::size_t bufferLen = mNetworkReadByteBuffer.getLength();
Lock lock(mSessionPtr->mDisableIoMutex);
if (!mSessionPtr->mDisableIo)
{
if (mSocketOpsMutexPtr)
{
Lock lock(*mSocketOpsMutexPtr);
implRead(buffer, bufferLen);
}
else
{
implRead(buffer, bufferLen);
}
}
}
