FilterPtr RcfServer::createFilter(int filterId)
{
ReadLock lock(mServicesMutex);
if (mFilterServicePtr)
{
FilterFactoryPtr filterFactoryPtr =
mFilterServicePtr->getFilterFactoryPtr(filterId);
if (filterFactoryPtr)
{
return filterFactoryPtr->createFilter();
}
}
return FilterPtr();
}
FilterPtr RcfServer::createFilter(int filterId)
{
if (mFilterServicePtr)
{
FilterFactoryPtr filterFactoryPtr =
mFilterServicePtr->getFilterFactoryPtr(filterId);
if (filterFactoryPtr)
{
return filterFactoryPtr->createFilter(*this);
}
}
RCF_THROW( Exception( _RcfError_UnknownFilter()) );
return FilterPtr();
}
// remotely accessible
boost::int32_t FilterService::RequestTransportFilters(const std::vector<boost::int32_t> &filterIds)
{
RCF_LOG_3()(filterIds) << "FilterService::RequestTransportFilters() - entry";
ReadLock readLock(mFilterFactoryMapMutex);
for (unsigned int i=0; i<filterIds.size(); ++i)
{
int filterId = filterIds[i];
if (mFilterFactoryMap.find(filterId) == mFilterFactoryMap.end())
{
RCF_LOG_3()(filterId) << "FilterService::RequestTransportFilters() - unknown filter.";
return RcfError_UnknownFilter;
}
}
boost::shared_ptr< std::vector<FilterPtr> > filters(
new std::vector<FilterPtr>());
for (unsigned int i=0; i<filterIds.size(); ++i)
{
int filterId = filterIds[i];
FilterFactoryPtr filterFactoryPtr = mFilterFactoryMap[filterId];
FilterPtr filterPtr( filterFactoryPtr->createFilter() );
filters->push_back(filterPtr);
}
RcfSession & session = getCurrentRcfSession();
if (session.transportFiltersLocked())
{
RCF_LOG_3() << "FilterService::RequestTransportFilters() - filter sequence already locked.";
return RcfError_FiltersLocked;
}
else
{
session.addOnWriteCompletedCallback( boost::bind(
&FilterService::setTransportFilters,
this,
_1,
filters) );
}
RCF_LOG_3() << "FilterService::RequestTransportFilters() - exit";
return RcfError_Ok;
}
void FilterService::addFilterFactory(
FilterFactoryPtr filterFactoryPtr,
const std::vector<int> &filterIds)
{
FilterDescription filterDescription = filterFactoryPtr->getFilterDescription();
WriteLock writeLock(mFilterFactoryMapMutex);
for (std::size_t i=0; i<filterIds.size(); ++i)
{
mFilterFactoryMap[ filterIds[i] ] = filterFactoryPtr;
}
}
void FilterService::addFilterFactory(FilterFactoryPtr filterFactoryPtr)
{
FilterDescription filterDescription = filterFactoryPtr->getFilterDescription();
WriteLock writeLock(mFilterFactoryMapMutex);
mFilterFactoryMap[ filterDescription.getId() ] = filterFactoryPtr;
}
// remotely accessible
boost::int32_t FilterService::RequestTransportFilters(const std::vector<boost::int32_t> &filterIds)
{
RCF_LOG_3()(filterIds) << "FilterService::RequestTransportFilters() - entry";
RcfSession & session = getCurrentRcfSession();
RcfServer & server = session.getRcfServer();
boost::shared_ptr< std::vector<FilterPtr> > filters(
new std::vector<FilterPtr>());
ReadLock readLock(mFilterFactoryMapMutex);
for (unsigned int i=0; i<filterIds.size(); ++i)
{
int filterId = filterIds[i];
if (filterId == RcfFilter_SspiSchannel || filterId == RcfFilter_OpenSsl)
{
if (server.getSslImplementation() == RCF::Si_Schannel)
{
filterId = RcfFilter_SspiSchannel;
}
else
{
filterId = RcfFilter_OpenSsl;
}
}
if (mFilterFactoryMap.find(filterId) == mFilterFactoryMap.end())
{
RCF_LOG_3()(filterId) << "FilterService::RequestTransportFilters() - filter not supported.";
return RcfError_UnknownFilter;
}
FilterFactoryPtr filterFactoryPtr = mFilterFactoryMap[filterId];
FilterPtr filterPtr( filterFactoryPtr->createFilter(server) );
filters->push_back(filterPtr);
}
// Determine which protocol, if any, the filter sequence represents.
session.mEnableCompression = false;
FilterPtr filterPtr;
if (filters->size() > 0)
{
if ( (*filters)[0]->getFilterId() == RcfFilter_ZlibCompressionStateful )
{
session.mEnableCompression = true;
if (filters->size() > 1)
{
filterPtr = (*filters)[1];
}
}
else
{
if (filters->size() > 0)
{
filterPtr = (*filters)[0];
}
}
}
TransportProtocol protocol = Tp_Unspecified;
if (!filterPtr)
{
protocol = Tp_Clear;
}
else
{
int filterId = filterPtr->getFilterId();
switch (filterId)
{
case RcfFilter_SspiNtlm: protocol = Tp_Ntlm; break;
case RcfFilter_SspiKerberos: protocol = Tp_Kerberos; break;
case RcfFilter_SspiNegotiate: protocol = Tp_Negotiate; break;
case RcfFilter_SspiSchannel: protocol = Tp_Ssl; break;
case RcfFilter_OpenSsl: protocol = Tp_Ssl; break;
default: protocol = Tp_Unspecified; break;
}
}
// Check that the filter sequence is allowed.
const std::vector<TransportProtocol> & protocols = server.getSupportedTransportProtocols();
if (protocols.size() > 0)
{
if (std::find(protocols.begin(), protocols.end(), protocol) == protocols.end())
{
RCF_THROW( Exception(_RcfError_ProtocolNotSupported()) );
}
}
if (protocol != Tp_Unspecified)
{
session.mTransportProtocol = protocol;
}
if (session.transportFiltersLocked())
{
RCF_LOG_3() << "FilterService::RequestTransportFilters() - filter sequence already locked.";
return RcfError_FiltersLocked;
}
else
{
session.addOnWriteCompletedCallback( boost::bind(
&FilterService::setTransportFilters,
this,
_1,
filters) );
}
RCF_LOG_3() << "FilterService::RequestTransportFilters() - exit";
return RcfError_Ok;
}
void FilterService::addFilterFactory(FilterFactoryPtr filterFactoryPtr)
{
int filterId = filterFactoryPtr->getFilterId();
WriteLock writeLock(mFilterFactoryMapMutex);
mFilterFactoryMap[ filterId ] = filterFactoryPtr;
}