Session* Acceptor::getSession
( const std::string& msg, Responder& responder )
{
Message message;
if ( !message.setStringHeader( msg ) )
return 0;
BeginString beginString;
SenderCompID clSenderCompID;
TargetCompID clTargetCompID;
MsgType msgType;
try
{
message.getHeader().getField( beginString );
message.getHeader().getField( clSenderCompID );
message.getHeader().getField( clTargetCompID );
message.getHeader().getField( msgType );
if ( msgType != "A" ) return 0;
SenderCompID senderCompID( clTargetCompID );
TargetCompID targetCompID( clSenderCompID );
SessionID sessionID( beginString, senderCompID, targetCompID );
Sessions::iterator i = m_sessions.find( sessionID );
if ( i != m_sessions.end() )
{
i->second->setResponder( &responder );
return i->second;
}
}
catch ( FieldNotFound& ) {}
return 0;
}
int testSendOnThreadedSocket( int count, short port )
{
std::stringstream stream;
stream
<< "[DEFAULT]" << std::endl
<< "SocketConnectHost=localhost" << std::endl
<< "SocketConnectPort=" << (unsigned short)port << std::endl
<< "SocketAcceptPort=" << (unsigned short)port << std::endl
<< "SocketReuseAddress=Y" << std::endl
<< "StartTime=00:00:00" << std::endl
<< "EndTime=00:00:00" << std::endl
<< "UseDataDictionary=N" << std::endl
<< "BeginString=FIX.4.2" << std::endl
<< "PersistMessages=N" << std::endl
<< "[SESSION]" << std::endl
<< "ConnectionType=acceptor" << std::endl
<< "SenderCompID=SERVER" << std::endl
<< "TargetCompID=CLIENT" << std::endl
<< "[SESSION]" << std::endl
<< "ConnectionType=initiator" << std::endl
<< "SenderCompID=CLIENT" << std::endl
<< "TargetCompID=SERVER" << std::endl
<< "HeartBtInt=30" << std::endl;
FIX::ClOrdID clOrdID( "ORDERID" );
FIX::HandlInst handlInst( '1' );
FIX::Symbol symbol( "LNUX" );
FIX::Side side( FIX::Side_BUY );
FIX::TransactTime transactTime;
FIX::OrdType ordType( FIX::OrdType_MARKET );
FIX42::NewOrderSingle message( clOrdID, handlInst, symbol, side, transactTime, ordType );
FIX::SessionID sessionID( "FIX.4.2", "CLIENT", "SERVER" );
TestApplication application;
FIX::MemoryStoreFactory factory;
FIX::SessionSettings settings( stream );
FIX::ThreadedSocketAcceptor acceptor( application, factory, settings );
acceptor.start();
FIX::ThreadedSocketInitiator initiator( application, factory, settings );
initiator.start();
FIX::process_sleep( 1 );
int start = GetTickCount();
for ( int i = 0; i <= count; ++i )
FIX::Session::sendToTarget( message, sessionID );
while( application.getCount() < count )
FIX::process_sleep( 0.1 );
int ticks = GetTickCount() - start;
initiator.stop();
acceptor.stop();
return ticks;
}
memoryStoreFixture()
{
SessionID sessionID( BeginString( "FIX.4.2" ),
SenderCompID( "SETGET" ), TargetCompID( "TEST" ) );
object = factory.create( sessionID );
}
void spep::SessionCacheImpl::terminatePrincipalSession(const std::wstring esoeSessionID)
{
ScopedLock lock(_principalSessionsMutex);
// Loop up the principal session by ESOE session ID
ESOESessionMap::iterator esoeIter = _esoeSessions.find(esoeSessionID);
if ( esoeIter != _esoeSessions.end() )
{
// Go through the list of all local session identifiers for that principal session
// and terminate them all.
for( PrincipalSession::SessionIDListType::iterator sessionIDIter = esoeIter->second.getSessionIDList().begin();
sessionIDIter != esoeIter->second.getSessionIDList().end();
++sessionIDIter )
{
std::string sessionID( *sessionIDIter );
SessionIDMap::iterator removeIter = _sessionIDs.find( sessionID );
if( removeIter != _sessionIDs.end() )
{
_sessionIDs.erase( removeIter );
}
}
// After we're done, remove the ESOE session ID from the session cache.
_esoeSessions.erase( esoeIter );
}
}
bool NetworkResourceLoader::canUseCache(const ResourceRequest& request) const
{
if (!NetworkCache::singleton().isEnabled())
return false;
if (sessionID().isEphemeral())
return false;
if (!request.url().protocolIsInHTTPFamily())
return false;
return true;
}
void NetworkResourceLoader::sharedDidFinishLoading(double finishTime)
{
#if ENABLE(NETWORK_CACHE)
if (NetworkCache::singleton().isEnabled()) {
if (m_cacheEntryForValidation) {
// 304 Not Modified
ASSERT(m_response.httpStatusCode() == 304);
LOG(NetworkCache, "(NetworkProcess) revalidated");
didRetrieveCacheEntry(WTF::move(m_cacheEntryForValidation));
return;
}
bool allowStale = originalRequest().cachePolicy() >= ReturnCacheDataElseLoad;
bool hasCacheableRedirect = m_response.isHTTP() && WebCore::redirectChainAllowsReuse(m_redirectChainCacheStatus, allowStale ? WebCore::ReuseExpiredRedirection : WebCore::DoNotReuseExpiredRedirection);
if (hasCacheableRedirect && m_redirectChainCacheStatus.status == RedirectChainCacheStatus::CachedRedirection) {
// Maybe we should cache the actual redirects instead of the end result?
auto now = std::chrono::system_clock::now();
auto responseEndOfValidity = now + WebCore::computeFreshnessLifetimeForHTTPFamily(m_response, now) - WebCore::computeCurrentAge(m_response, now);
hasCacheableRedirect = responseEndOfValidity <= m_redirectChainCacheStatus.endOfValidity;
}
bool isPrivate = sessionID().isEphemeral();
if (m_bufferedDataForCache && hasCacheableRedirect && !isPrivate) {
// Keep the connection alive.
RefPtr<NetworkConnectionToWebProcess> connection(connectionToWebProcess());
RefPtr<NetworkResourceLoader> loader(this);
NetworkCache::singleton().store(originalRequest(), m_response, WTF::move(m_bufferedDataForCache), [loader, connection](NetworkCache::MappedBody& mappedBody) {
#if ENABLE(SHAREABLE_RESOURCE)
if (mappedBody.shareableResourceHandle.isNull())
return;
LOG(NetworkCache, "(NetworkProcess) sending DidCacheResource");
loader->send(Messages::NetworkProcessConnection::DidCacheResource(loader->originalRequest(), mappedBody.shareableResourceHandle, loader->sessionID()));
#endif
});
} else if (!hasCacheableRedirect) {
// Make sure we don't keep a stale entry in the cache.
NetworkCache::singleton().remove(originalRequest());
}
}
#endif
if (isSynchronous())
sendReplyToSynchronousRequest(*m_synchronousLoadData, m_bufferedData.get());
else {
if (m_bufferedData && m_bufferedData->size()) {
// FIXME: Pass a real value or remove the encoded data size feature.
bool shouldContinue = sendBufferMaybeAborting(*m_bufferedData, -1);
if (!shouldContinue)
return;
}
send(Messages::WebResourceLoader::DidFinishResourceLoad(finishTime));
}
cleanup();
}
bool NetworkResourceLoader::canUseCache(const ResourceRequest& request) const
{
if (!NetworkCache::singleton().isEnabled())
return false;
if (sessionID().isEphemeral())
return false;
if (!request.url().protocolIsInHTTPFamily())
return false;
if (originalRequest().cachePolicy() == WebCore::DoNotUseAnyCache)
return false;
return true;
}
CachedResource::~CachedResource()
{
ASSERT(!m_resourceToRevalidate); // Should be true because canDelete() checks this.
ASSERT(canDelete());
ASSERT(!inCache());
ASSERT(!m_deleted);
ASSERT(url().isNull() || memoryCache()->resourceForRequest(resourceRequest(), sessionID()) != this);
#ifndef NDEBUG
m_deleted = true;
cachedResourceLeakCounter.decrement();
#endif
if (m_owningCachedResourceLoader)
m_owningCachedResourceLoader->removeCachedResource(this);
}
void NetworkResourceLoader::start()
{
ASSERT(RunLoop::isMain());
if (m_defersLoading)
return;
// Explicit ref() balanced by a deref() in NetworkResourceLoader::cleanup()
ref();
m_networkingContext = RemoteNetworkingContext::create(sessionID(), m_parameters.shouldClearReferrerOnHTTPSToHTTPRedirect);
consumeSandboxExtensions();
m_currentRequest = originalRequest();
if (isSynchronous() || m_parameters.maximumBufferingTime > 0_ms)
m_bufferedData = WebCore::SharedBuffer::create();
bool shouldSniff = m_parameters.contentSniffingPolicy == SniffContent;
m_handle = ResourceHandle::create(m_networkingContext.get(), m_currentRequest, this, false /* defersLoading */, shouldSniff);
}
void NetworkResourceLoader::start()
{
ASSERT(RunLoop::isMain());
if (m_defersLoading)
return;
m_currentRequest = originalRequest();
#if ENABLE(NETWORK_CACHE)
if (!NetworkCache::singleton().isEnabled() || sessionID().isEphemeral() || !originalRequest().url().protocolIsInHTTPFamily()) {
startNetworkLoad();
return;
}
RefPtr<NetworkResourceLoader> loader(this);
NetworkCache::singleton().retrieve(originalRequest(), m_parameters.webPageID, [loader](std::unique_ptr<NetworkCache::Entry> entry) {
if (loader->hasOneRef()) {
// The loader has been aborted and is only held alive by this lambda.
return;
}
if (!entry) {
loader->startNetworkLoad();
return;
}
if (loader->m_parameters.needsCertificateInfo && !entry->response().containsCertificateInfo()) {
loader->startNetworkLoad();
return;
}
if (entry->needsValidation()) {
loader->validateCacheEntry(WTF::move(entry));
return;
}
loader->didRetrieveCacheEntry(WTF::move(entry));
});
#else
startNetworkLoad();
#endif
}
void NetworkResourceLoader::startNetworkLoad()
{
m_networkingContext = RemoteNetworkingContext::create(sessionID(), m_parameters.shouldClearReferrerOnHTTPSToHTTPRedirect);
consumeSandboxExtensions();
if (isSynchronous() || m_parameters.maximumBufferingTime > 0_ms)
m_bufferedData = WebCore::SharedBuffer::create();
#if ENABLE(NETWORK_CACHE)
if (NetworkCache::singleton().isEnabled())
m_bufferedDataForCache = WebCore::SharedBuffer::create();
#endif
bool shouldSniff = m_parameters.contentSniffingPolicy == SniffContent;
#if USE(NETWORK_SESSION)
UNUSED_PARAM(shouldSniff); // FIXME: Use this.
m_task = NetworkSession::singleton()->createDataTaskWithRequest(m_currentRequest, *this);
m_task->resume();
#else
m_handle = ResourceHandle::create(m_networkingContext.get(), m_currentRequest, this, m_defersLoading, shouldSniff);
#endif
}
bool NetworkResourceLoader::isAlwaysOnLoggingAllowed() const
{
return sessionID().isAlwaysOnLoggingAllowed();
}
