void FileIoThreadPool::registerOp(FileIoRequestPtr opPtr)
{
RCF::Lock lock(mOpsMutex);
// Lazy start of the thread pool.
if (!mThreadPool.isStarted())
{
mStopFlag = false;
mThreadPool.start(mStopFlag);
}
if ( std::find(mOpsQueued.begin(), mOpsQueued.end(), opPtr)
!= mOpsQueued.end())
{
RCF_ASSERT(0);
}
else if ( std::find(mOpsInProgress.begin(), mOpsInProgress.end(), opPtr)
!= mOpsInProgress.end())
{
RCF_ASSERT(0);
}
else
{
mOpsQueued.push_back(opPtr);
mOpsCondition.notify_all();
}
}
void ClientStub::onTimerExpired()
{
AsyncOpType opType = mAsyncOpType;
mAsyncOpType = None;
if (opType == Wait)
{
scheduleAmiNotification();
}
else
{
switch(opType)
{
case Connect:
RCF_ASSERT(mEndpoint.get());
onError(RCF::Exception(_RcfError_ClientConnectTimeout(
mConnectTimeoutMs,
mEndpoint->asString())));
break;
case Write:
onError(RCF::Exception(_RcfError_ClientWriteTimeout()));
break;
case Read:
onError(RCF::Exception(_RcfError_ClientReadTimeout()));
break;
default:
RCF_ASSERT(0)(opType);
};
}
}
void ClientStub::createFilterSequence(
std::vector<FilterPtr> & filters)
{
filters.clear();
// Setup compression if configured.
if (mEnableCompression)
{
#if RCF_FEATURE_ZLIB==1
FilterPtr filterPtr( new ZlibStatefulCompressionFilter() );
filters.push_back(filterPtr);
#else
RCF_ASSERT(0);
#endif
}
FilterPtr filterPtr;
if (mTransportProtocol != Tp_Clear && mTransportProtocol != Tp_Unspecified)
{
switch (mTransportProtocol)
{
#if RCF_FEATURE_SSPI==1
case Tp_Ntlm: filterPtr.reset( new NtlmFilter(this) ); break;
case Tp_Kerberos: filterPtr.reset( new KerberosFilter(this) ); break;
case Tp_Negotiate: filterPtr.reset( new NegotiateFilter(this) ); break;
#endif
#if RCF_FEATURE_OPENSSL==1 && RCF_FEATURE_SSPI==1
case Tp_Ssl: if (mSslImplementation == Si_Schannel)
{
filterPtr.reset( new SchannelFilter(this) );
}
else
{
RCF_ASSERT(mSslImplementation == Si_OpenSsl);
filterPtr.reset( new OpenSslEncryptionFilter(this) );
}
break;
#elif RCF_FEATURE_OPENSSL==1
case Tp_Ssl: filterPtr.reset( new OpenSslEncryptionFilter(this) ); break;
#elif RCF_FEATURE_SSPI==1
case Tp_Ssl: filterPtr.reset( new SchannelFilter(this) ); break;
#else
// Single case just to keep the compiler warnings quiet.
case Tp_Ssl:
#endif
default:
RCF_THROW( Exception( _RcfError_TransportProtocolNotSupported( getTransportProtocolName(mTransportProtocol)) ) );
}
}
if (filterPtr)
{
filters.push_back(filterPtr);
}
}
void AsioSessionState::onAppReadWriteCompleted(
size_t bytesTransferred)
{
RCF_ASSERT(!mReflecting);
switch(mState)
{
case ReadingDataCount:
case ReadingData:
if (mTransport.mCustomFraming)
{
doCustomFraming(bytesTransferred);
}
else
{
doRegularFraming(bytesTransferred);
}
break;
case WritingData:
RCF_ASSERT_LTEQ(bytesTransferred , mWriteBufferRemaining);
mWriteBufferRemaining -= bytesTransferred;
if (mWriteBufferRemaining > 0)
{
beginWrite();
}
else
{
if (mCloseAfterWrite)
{
// For TCP sockets, call shutdown() so client receives
// the message before we close the connection.
implCloseAfterWrite();
}
else
{
mState = Ready;
mSlicedWriteByteBuffers.resize(0);
mWriteByteBuffers.resize(0);
mTransport.getSessionManager().onWriteCompleted(
getSessionPtr());
}
}
break;
default:
RCF_ASSERT(0);
}
}
void ObjectPool::put(VecPtr & vecPtr)
{
RCF_ASSERT(vecPtr);
RCF_ASSERT(vecPtr.unique());
vecPtr->resize(0);
Lock lock(mVecPtrPoolMutex);
mVecPtrPool.push_back(vecPtr);
vecPtr.reset();
}
HttpsClientTransport::HttpsClientTransport(const HttpsEndpoint & httpsEndpoint) :
TcpClientTransport(httpsEndpoint.getIp(), httpsEndpoint.getPort())
{
std::vector<FilterPtr> wireFilters;
// HTTP framing.
wireFilters.push_back( FilterPtr( new HttpFrameFilter(
getRemoteAddr().getIp(),
getRemoteAddr().getPort())));
// SSL.
ClientStub * pClientStub = getTlsClientStubPtr();
RCF_ASSERT(pClientStub);
FilterPtr sslFilterPtr;
#if RCF_FEATURE_SSPI==1 && RCF_FEATURE_OPENSSL==1
if (pClientStub->getSslImplementation() == Si_Schannel)
{
sslFilterPtr.reset( new SchannelFilter(pClientStub) );
}
else
{
RCF_ASSERT(pClientStub->getSslImplementation() == Si_OpenSsl);
sslFilterPtr.reset( new OpenSslEncryptionFilter(pClientStub) );
}
#elif RCF_FEATURE_SSPI==1
sslFilterPtr.reset( new SchannelFilter(pClientStub) );
#elif RCF_FEATURE_OPENSSL==1
sslFilterPtr.reset( new OpenSslEncryptionFilter(pClientStub) );
#endif
if (!sslFilterPtr)
{
RCF_THROW( Exception(_RcfError_SslNotSupported()) );
}
wireFilters.push_back(sslFilterPtr);
// HTTP CONNECT filter for passing through a proxy.
wireFilters.push_back( FilterPtr( new HttpConnectFilter(
getRemoteAddr().getIp(),
getRemoteAddr().getPort())));
setWireFilters(wireFilters);
}
void ServerObjectService::customDeleter(const std::string & objectKey, void * pt)
{
RCF_UNUSED_VARIABLE(pt);
Lock lock(mMutex);
ServerObjectMap::iterator iter = mServerObjectMap.find(objectKey);
RCF_ASSERT(iter != mServerObjectMap.end());
ServerObjectHolder & holder = iter->second;
RCF_ASSERT(holder.mUseCount > 0);
--holder.mUseCount;
holder.mLastTouchMs = getCurrentTimeMs();
}
void ObjectPool::put(OstrStreamPtr & ostrStreamPtr)
{
RCF_ASSERT(ostrStreamPtr);
RCF_ASSERT(ostrStreamPtr.unique());
ostrStreamPtr->clear(); // freezing may have set error state
ostrStreamPtr->rdbuf()->freeze(false);
ostrStreamPtr->rdbuf()->pubseekoff(0, std::ios::beg, std::ios::out);
Lock lock(mOstrStreamPtrPoolMutex);
mOstrStreamPtrPool.push_back(ostrStreamPtr);
ostrStreamPtr.reset();
}
bool AsioServerTransport::cycle(
int timeoutMs,
const volatile bool &,// stopFlag
bool returnEarly)
{
RCF2_TRACE("Entering cycle()");
RCF_ASSERT(timeoutMs >= -1)(timeoutMs);
mInterrupt = returnEarly;
if (timeoutMs != -1)
{
mCycleTimerPtr->mImpl.cancel();
mCycleTimerPtr->mImpl.expires_from_now(
boost::posix_time::milliseconds(timeoutMs));
mCycleTimerPtr->mImpl.async_wait( boost::bind(
&AsioServerTransport::stopCycle,
this,
boost::asio::placeholders::error));
}
mDemuxerPtr->reset();
mDemuxerPtr->run();
RCF2_TRACE("Exiting cycle()");
return false;
}
void AsioSessionState::read(
const ByteBuffer &byteBuffer,
std::size_t bytesRequested)
{
RCF2_TRACE("")(this);
if (byteBuffer.getLength() == 0)
{
std::vector<char> &vec = getUniqueReadBufferSecondary();
vec.resize(bytesRequested);
mTempByteBuffer = getReadByteBufferSecondary();
}
else
{
mTempByteBuffer = ByteBuffer(byteBuffer, 0, bytesRequested);
}
RCF_ASSERT(
bytesRequested <= mTempByteBuffer.getLength())
(bytesRequested)(mTempByteBuffer.getLength());
char *buffer = mTempByteBuffer.getPtr();
std::size_t bufferLen = mTempByteBuffer.getLength();
Lock lock(mMutex);
if (!mHasBeenClosed)
{
implRead(buffer, bufferLen);
}
}
void SubscriptionService::onServerStop(RcfServer &server)
{
RCF_UNUSED_VARIABLE(server);
mPeriodicTimer.stop();
Subscriptions subs;
{
Lock writeLock(mSubscriptionsMutex);
subs = mSubscriptions;
}
for (Subscriptions::iterator iter = subs.begin();
iter != subs.end();
++iter)
{
SubscriptionPtr subscriptionPtr = iter->lock();
if (subscriptionPtr)
{
subscriptionPtr->close();
}
}
{
Lock writeLock(mSubscriptionsMutex);
RCF_ASSERT(mSubscriptions.empty());
}
mSubscriptions.clear();
subs.clear();
mpServer = NULL;
}
void Win32NamedPipeSessionState::reconnect()
{
RCF_ASSERT(mEnableReconnect && mOwnFd);
BOOL ok = DisconnectNamedPipe(mhPipe);
DWORD dwErr = GetLastError();
RCF_ASSERT(ok)(dwErr);
mSessionPtr.reset();
mSessionPtr = mTransport.mpSessionManager->createSession();
mSessionPtr->setProactor(*this);
resetState();
accept();
}
std::string getWorkingDir()
{
std::vector<char> vec(1024);
char * szRet = getcwd(&vec[0], static_cast<int>( vec.size() ));
RCF_ASSERT(szRet);
return std::string(&vec[0]);
}
std::size_t Win32NamedPipeClientTransport::implWrite(
const std::vector<ByteBuffer> &byteBuffers)
{
// For now, can't go back to sync calls after doing an async call.
// Limitations with Windows IOCP.
RCF_ASSERT(!mAsyncMode);
// Not using overlapped I/O here because it interferes with the
// server session that might be coupled to this transport.
const ByteBuffer & byteBuffer = byteBuffers.front();
DWORD count = 0;
DWORD dwBytesToWrite = static_cast<DWORD>(byteBuffer.getLength());
BOOL ok = WriteFile(
mhPipe,
byteBuffer.getPtr(),
dwBytesToWrite,
&count,
NULL);
DWORD dwErr = GetLastError();
RCF_VERIFY(ok, Exception(_RcfError_ClientWriteFail(), dwErr));
// Strangely, WriteFile() sometimes returns 1, but at the same time a much too big value in count.
RCF_VERIFY(count <= dwBytesToWrite, Exception(_RcfError_ClientWriteFail(), dwErr))(count)(dwBytesToWrite);
RCF_VERIFY(count > 0, Exception(_RcfError_ClientWriteFail(), dwErr))(count)(dwBytesToWrite);
onTimedSendCompleted( RCF_MIN(count, dwBytesToWrite), 0);
return count;
}
void SubscriptionService::createSubscriptionImplBegin(
RcfClientPtr rcfClientPtr,
const SubscriptionParms & parms,
const std::string & defaultPublisherName)
{
ClientStub & clientStub = const_cast<ClientStub &>(parms.mClientStub);
OnSubscriptionDisconnect onDisconnect = parms.mOnDisconnect;
std::string publisherName = parms.mPublisherName;
OnAsyncSubscribeCompleted onCompletion = parms.mOnAsyncSubscribeCompleted;
if (publisherName.empty())
{
publisherName = defaultPublisherName;
}
RCF_ASSERT(onCompletion);
if (clientStub.getRuntimeVersion() <= 11)
{
doRequestSubscriptionAsync_Legacy(
clientStub,
publisherName,
rcfClientPtr,
parms);
}
else
{
doRequestSubscriptionAsync(
clientStub,
publisherName,
rcfClientPtr,
parms);
}
}
T & createSessionObject()
{
deleteSessionObject<T>();
T * pt = getSessionObjectImpl<T>(true);
RCF_ASSERT(pt);
return *pt;
}
void read(T &t)
{
try
{
switch (mProtocol)
{
case 1: mInProtocol1 >> t; break;
case 2: mInProtocol2 >> t; break;
case 3: mInProtocol3 >> t; break;
case 4: mInProtocol4 >> t; break;
#ifdef RCF_USE_BOOST_XML_SERIALIZATION
case 5: mInProtocol5 >> boost::serialization::make_nvp("Dummy", t); break;
#else
case 5: mInProtocol5 >> t; break;
#endif
default: RCF_ASSERT(0)(mProtocol);
}
}
catch(const RCF::Exception &e)
{
RCF_UNUSED_VARIABLE(e);
throw;
}
catch(const std::exception &e)
{
RCF::SerializationException se( _RcfError_Deserialization(
typeid(t).name(),
typeid(e).name(),
e.what()));
RCF_THROW(se);
}
}
T * getSessionObjectImpl(bool createIfDoesntExist)
{
typedef boost::shared_ptr<T> TPtr;
const std::type_info & whichType = typeid(T);
const std::type_info * pWhichType = &whichType;
SessionObjectMap::iterator iter = mSessionObjects.find(pWhichType);
if (iter != mSessionObjects.end())
{
boost::any & a = iter->second;
TPtr * ptPtr = boost::any_cast<TPtr>(&a);
RCF_ASSERT(ptPtr && *ptPtr);
return ptPtr->get();
}
else if (createIfDoesntExist)
{
TPtr tPtr( new T() );
mSessionObjects[pWhichType] = tPtr;
return tPtr.get();
}
else
{
return NULL;
}
}
void PublishingService::onServerStop(RcfServer &server)
{
RCF_UNUSED_VARIABLE(server);
mPeriodicTimer.stop();
// Close all publishers.
Publishers publishers;
{
Lock writeLock(mPublishersMutex);
publishers = mPublishers;
}
Publishers::iterator iter;
for (iter = publishers.begin(); iter != publishers.end(); ++iter)
{
PublisherPtr publisherPtr = iter->second.lock();
if (publisherPtr)
{
publisherPtr->close();
}
}
{
Lock writeLock(mPublishersMutex);
RCF_ASSERT(mPublishers.empty());
}
}
UInt32 IStream::read_int(UInt32 &n)
{
if (mRuntimeVersion < 9)
{
UInt32 bytesRead = read( reinterpret_cast<SF::Byte8 *>(&n), 4);
RCF::networkToMachineOrder( &n, 4, 1);
return bytesRead;
}
else
{
// Integers less than 128 are stored as a single byte.
Byte8 byte = 0;
boost::uint8_t ubyte = 0;
UInt32 bytesRead = read_byte(byte);
ubyte = byte;
if (ubyte < 128)
{
n = ubyte;
}
else
{
RCF_ASSERT(ubyte == 128);
bytesRead += read( reinterpret_cast<SF::Byte8 *>(&n), 4);
RCF::networkToMachineOrder( &n, 4, 1);
}
return bytesRead;
}
}
void read(T &t)
{
try
{
switch (mProtocol)
{
case 1: mInProtocol1 >> t; break;
case 2: mInProtocol2 >> t; break;
case 3: mInProtocol3 >> t; break;
case 4: mInProtocol4 >> t; break;
case 5: mInProtocol5 >> t; break;
default: RCF_ASSERT(0)(mProtocol);
}
}
catch(const RCF::Exception &e)
{
RCF_UNUSED_VARIABLE(e);
throw;
}
catch(const std::exception &e)
{
RCF::SerializationException se( _RcfError_Deserialization(
typeid(t).name(),
typeid(e).name(),
e.what()));
RCF_THROW(se);
}
}
std::auto_ptr<I_ServerTransport> TcpEndpoint::createServerTransport() const
{
// On non Windows platforms, server side RCF code requires
// RCF_USE_BOOST_ASIO to be defined, and the Boost.Asio library to
// be available.
RCF_ASSERT(0);
return std::auto_ptr<I_ServerTransport>();
}
void CallbackConnectionService::CreateCallbackConnection()
{
// TODO: regular error message.
// ...
RCF_ASSERT( mOnCallbackConnectionCreated );
RCF::convertRcfSessionToRcfClient( mOnCallbackConnectionCreated );
}
void InProcessTransport::setTimer(
boost::uint32_t timeoutMs,
I_ClientTransportCallback * pClientStub)
{
RCF_ASSERT(0);
RCF_UNUSED_VARIABLE(timeoutMs);
RCF_UNUSED_VARIABLE(pClientStub);
}
boost::shared_ptr<T> getServerObjectImpl(
const std::string & objectKey,
boost::uint32_t timeoutMs,
bool createIfDoesntExist)
{
typedef boost::shared_ptr<T> TPtr;
Lock lock(mMutex);
ServerObjectMap::iterator iter = mServerObjectMap.find(objectKey);
if (iter != mServerObjectMap.end())
{
ServerObjectHolder & holder = iter->second;
boost::any & a = holder.mServerObject;
TPtr * ptPtr = boost::any_cast<TPtr>(&a);
RCF_ASSERT(ptPtr);
TPtr tPtr = *ptPtr;
T * pt = tPtr.get();
RCF_ASSERT(pt);
// Return shared_ptr with custom deleter.
holder.mLastTouchMs = getCurrentTimeMs();
RCF_ASSERT(holder.mUseCount >= 0);
++holder.mUseCount;
TPtr ptr(pt, boost::bind(&ServerObjectService::customDeleter, this, objectKey, _1));
return ptr;
}
else if (createIfDoesntExist)
{
T * pt = new T();
TPtr tPtr(pt);
mServerObjectMap[objectKey] = ServerObjectHolder(boost::any(tPtr), timeoutMs);
ServerObjectHolder & holder = mServerObjectMap[objectKey];
// Return shared_ptr with custom deleter.
holder.mLastTouchMs = getCurrentTimeMs();
RCF_ASSERT(holder.mUseCount >= 0);
++holder.mUseCount;
TPtr ptr(pt, boost::bind(&ServerObjectService::customDeleter, this, objectKey, _1));
return ptr;
}
else
{
return TPtr();
}
}
std::string getRelativeTestDataPath()
{
std::string checkoutRoot = getRelativePathToCheckoutRoot();
RCF_ASSERT(checkoutRoot.size() > 0)(checkoutRoot);
std::string testDataPath = checkoutRoot + "/RCF/test/data/";
return testDataPath;
}
void UdpClientTransport::setTransportFilters(
const std::vector<FilterPtr> &filters)
{
if (!filters.empty())
{
RCF_ASSERT(0);
}
}
static void initZlibCompressionFilterDescriptions()
{
RCF_ASSERT(!ZlibStatelessCompressionFilter::spFilterDescription);
RCF_ASSERT(!ZlibStatefulCompressionFilter::spFilterDescription);
ZlibStatelessCompressionFilter::spFilterDescription =
new FilterDescription(
"Zlib stateless compression filter",
RcfFilter_ZlibCompressionStateless,
false);
ZlibStatefulCompressionFilter::spFilterDescription =
new FilterDescription(
"Zlib stateful compression filter",
RcfFilter_ZlibCompressionStateful,
false);
}
void AsioSessionState::onAccept(
const boost::system::error_code& error)
{
RCF2_TRACE("")(this);
if (mTransport.mStopFlag)
{
return;
}
if (!error)
{
// save the remote address in the SessionState object
bool clientAddrAllowed = implOnAccept();
mState = WritingData;
// create a new SessionState, and do an accept on that
mTransport.createSessionState()->invokeAsyncAccept();
// set current RCF session
SetCurrentSessionGuard guard(mSessionPtr);
if (clientAddrAllowed)
{
// Check the connection limit.
bool allowConnect = true;
std::size_t connectionLimit = mTransport.getConnectionLimit();
if (connectionLimit)
{
Lock lock(mTransport.mSessionsMutex);
RCF_ASSERT(
mTransport.mSessions.size() <= 1 + 1 + connectionLimit);
if (mTransport.mSessions.size() == 1 + 1 + connectionLimit)
{
allowConnect = false;
}
}
if (allowConnect)
{
// start things rolling by faking a completed write operation
onReadWrite(0, boost::system::error_code());
}
else
{
sendServerError(RcfError_ConnectionLimitExceeded);
}
}
}
else if (
error == boost::asio::error::connection_aborted ||
error == boost::asio::error::operation_aborted)
{
invokeAsyncAccept();
}
}
void ContextRead::add(void *ptr, const std::type_info &objType, void *pObj)
{
RCF_ASSERT(mEnabled);
if (mTypeToObjMap.get() == NULL)
{
mTypeToObjMap.reset( new std::map<std::string, std::map< void *, void * > >() );
}
(*mTypeToObjMap)[ objType.name() ][ ptr ] = pObj;
}
