diff options
Diffstat (limited to 'src/components/connection_handler/src/connection_handler_impl.cc')
| -rw-r--r-- | src/components/connection_handler/src/connection_handler_impl.cc | 267 |
1 files changed, 200 insertions, 67 deletions
diff --git a/src/components/connection_handler/src/connection_handler_impl.cc b/src/components/connection_handler/src/connection_handler_impl.cc index f1dae841a..70a50c589 100644 --- a/src/components/connection_handler/src/connection_handler_impl.cc +++ b/src/components/connection_handler/src/connection_handler_impl.cc @@ -34,6 +34,7 @@ #include <string> #include <list> #include <algorithm> +#include <memory> #include "connection_handler/connection_handler_impl.h" #include "transport_manager/info.h" @@ -70,27 +71,29 @@ ConnectionHandlerImpl::ConnectionHandlerImpl() : connection_handler_observer_(NULL), transport_manager_(NULL), protocol_handler_(NULL), + connection_list_lock_(true), + connection_handler_observer_lock_(true), connection_list_deleter_(&connection_list_) { } ConnectionHandlerImpl::~ConnectionHandlerImpl() { - LOG4CXX_TRACE(logger_, "Destructing ConnectionHandlerImpl."); + LOG4CXX_AUTO_TRACE(logger_); } void ConnectionHandlerImpl::Stop() { - LOG4CXX_TRACE_ENTER(logger_); + LOG4CXX_AUTO_TRACE(logger_); ConnectionList::iterator itr = connection_list_.begin(); while (itr != connection_list_.end()) { RemoveConnection(itr->second->connection_handle()); itr = connection_list_.begin(); } - LOG4CXX_TRACE_EXIT(logger_); } void ConnectionHandlerImpl::set_connection_handler_observer( ConnectionHandlerObserver *observer) { LOG4CXX_DEBUG(logger_, "ConnectionHandlerImpl::set_connection_handler_observer() " << observer); + sync_primitives::AutoLock lock(connection_handler_observer_lock_); if (!observer) { LOG4CXX_WARN(logger_, "Set Null pointer to observer."); } @@ -120,13 +123,15 @@ void ConnectionHandlerImpl::set_protocol_handler( void ConnectionHandlerImpl::OnDeviceListUpdated( const std::vector<transport_manager::DeviceInfo>&) { - LOG4CXX_TRACE(logger_, "ConnectionHandlerImpl::OnDeviceListUpdated()"); + LOG4CXX_AUTO_TRACE(logger_); + sync_primitives::AutoLock lock(connection_handler_observer_lock_); if (connection_handler_observer_) { connection_handler_observer_->OnDeviceListUpdated(device_list_); } } void ConnectionHandlerImpl::OnFindNewApplicationsRequest() { + sync_primitives::AutoLock lock(connection_handler_observer_lock_); if (connection_handler_observer_) { connection_handler_observer_->OnFindNewApplicationsRequest(); } @@ -134,17 +139,18 @@ void ConnectionHandlerImpl::OnFindNewApplicationsRequest() { void ConnectionHandlerImpl::OnDeviceFound( const transport_manager::DeviceInfo&) { - LOG4CXX_TRACE(logger_, "ConnectionHandlerImpl::OnDeviceFound()"); + LOG4CXX_AUTO_TRACE(logger_); } void ConnectionHandlerImpl::OnDeviceAdded( const transport_manager::DeviceInfo &device_info) { - LOG4CXX_TRACE(logger_, "ConnectionHandlerImpl::OnDeviceAdded()"); + LOG4CXX_AUTO_TRACE(logger_); device_list_.insert( DeviceMap::value_type( device_info.device_handle(), Device(device_info.device_handle(), device_info.name(), device_info.mac_address(), device_info.connection_type()))); + sync_primitives::AutoLock lock(connection_handler_observer_lock_); if (connection_handler_observer_) { connection_handler_observer_->OnDeviceListUpdated(device_list_); } @@ -152,7 +158,7 @@ void ConnectionHandlerImpl::OnDeviceAdded( void ConnectionHandlerImpl::OnDeviceRemoved( const transport_manager::DeviceInfo &device_info) { - LOG4CXX_TRACE(logger_, "ConnectionHandlerImpl::OnDeviceRemoved()"); + LOG4CXX_AUTO_TRACE(logger_); // Device has been removed. Perform all needed actions. // 1. Delete all the connections and sessions of this device // 2. Delete device from a list @@ -176,6 +182,7 @@ void ConnectionHandlerImpl::OnDeviceRemoved( } device_list_.erase(device_info.device_handle()); + sync_primitives::AutoLock lock(connection_handler_observer_lock_); if (connection_handler_observer_) { connection_handler_observer_->RemoveDevice(device_info.device_handle()); connection_handler_observer_->OnDeviceListUpdated(device_list_); @@ -183,7 +190,7 @@ void ConnectionHandlerImpl::OnDeviceRemoved( } void ConnectionHandlerImpl::OnScanDevicesFinished() { - LOG4CXX_TRACE(logger_, "Scan devices finished successfully."); + LOG4CXX_AUTO_TRACE(logger_); } void ConnectionHandlerImpl::OnScanDevicesFailed( @@ -194,14 +201,14 @@ void ConnectionHandlerImpl::OnScanDevicesFailed( void ConnectionHandlerImpl::OnConnectionEstablished( const transport_manager::DeviceInfo &device_info, const transport_manager::ConnectionUID &connection_id) { - LOG4CXX_TRACE(logger_, "ConnectionHandlerImpl::OnConnectionEstablished()"); + LOG4CXX_AUTO_TRACE(logger_); DeviceMap::iterator it = device_list_.find(device_info.device_handle()); if (device_list_.end() == it) { LOG4CXX_ERROR(logger_, "Unknown device!"); return; } - LOG4CXX_INFO(logger_, "Add Connection:" << connection_id << " to the list."); + LOG4CXX_DEBUG(logger_, "Add Connection #" << connection_id << " to the list."); sync_primitives::AutoLock lock(connection_list_lock_); connection_list_.insert( ConnectionList::value_type( @@ -219,7 +226,7 @@ void ConnectionHandlerImpl::OnConnectionFailed( void ConnectionHandlerImpl::OnConnectionClosed( transport_manager::ConnectionUID connection_id) { - LOG4CXX_INFO(logger_, "ConnectionHandlerImpl::OnConnectionClosed"); + LOG4CXX_AUTO_TRACE(logger_); OnConnectionEnded(connection_id); } @@ -296,7 +303,7 @@ uint32_t ConnectionHandlerImpl::OnSessionStartedCallback( const transport_manager::ConnectionUID &connection_handle, const uint8_t session_id, const protocol_handler::ServiceType &service_type, const bool is_protected, uint32_t* hash_id) { - LOG4CXX_TRACE_ENTER(logger_); + LOG4CXX_AUTO_TRACE(logger_); if (hash_id) { *hash_id = protocol_handler::HASH_ID_WRONG; @@ -306,12 +313,10 @@ uint32_t ConnectionHandlerImpl::OnSessionStartedCallback( return 0; } #endif // ENABLE_SECURITY - sync_primitives::AutoLock lock(connection_list_lock_); ConnectionList::iterator it = connection_list_.find(connection_handle); if (connection_list_.end() == it) { LOG4CXX_ERROR(logger_, "Unknown connection!"); - LOG4CXX_TRACE_EXIT(logger_); return 0; } uint32_t new_session_id = 0; @@ -321,7 +326,6 @@ uint32_t ConnectionHandlerImpl::OnSessionStartedCallback( new_session_id = connection->AddNewSession(); if (0 == new_session_id) { LOG4CXX_ERROR(logger_, "Couldn't start new session!"); - LOG4CXX_TRACE_EXIT(logger_); return 0; } if (hash_id) { @@ -335,7 +339,6 @@ uint32_t ConnectionHandlerImpl::OnSessionStartedCallback( #endif // ENABLE_SECURITY << " service " << static_cast<int>(service_type) << " for session " << static_cast<int>(session_id)); - LOG4CXX_TRACE_EXIT(logger_); return 0; } new_session_id = session_id; @@ -343,38 +346,69 @@ uint32_t ConnectionHandlerImpl::OnSessionStartedCallback( *hash_id = protocol_handler::HASH_ID_NOT_SUPPORTED; } } - + sync_primitives::AutoLock lock2(connection_handler_observer_lock_); if (connection_handler_observer_) { const uint32_t session_key = KeyFromPair(connection_handle, new_session_id); const bool success = connection_handler_observer_->OnServiceStartedCallback( - connection->connection_device_handle(), session_key, service_type); + connection->connection_device_handle(), session_key, service_type); if (!success) { if (protocol_handler::kRpc == service_type) { connection->RemoveSession(new_session_id); } else { connection->RemoveService(session_id, service_type); } - LOG4CXX_TRACE_EXIT(logger_); return 0; } } - LOG4CXX_TRACE_EXIT(logger_); return new_session_id; } +void ConnectionHandlerImpl::OnApplicationFloodCallBack( + const uint32_t &connection_key) { + LOG4CXX_AUTO_TRACE(logger_); + + transport_manager::ConnectionUID connection_handle = 0; + uint8_t session_id = 0; + PairFromKey(connection_key, &connection_handle, &session_id); + + LOG4CXX_INFO(logger_, "Disconnect flooding application"); + if (session_id != 0) { + CloseSession(connection_handle, session_id, kFlood); + } else { + CloseConnectionSessions(connection_handle, kCommon); + CloseConnection(connection_handle); + } +} + +void ConnectionHandlerImpl::OnMalformedMessageCallback( + const uint32_t &connection_key) { + LOG4CXX_AUTO_TRACE(logger_); + + transport_manager::ConnectionUID connection_handle = 0; + uint8_t session_id = 0; + PairFromKey(connection_key, &connection_handle, &session_id); + + LOG4CXX_INFO(logger_, "Disconnect malformed messaging application"); + CloseConnectionSessions(connection_handle, kCommon); + CloseConnection(connection_handle); +} + uint32_t ConnectionHandlerImpl::OnSessionEndedCallback( const uint32_t &connection_handle, const uint8_t session_id, const uint32_t &hashCode, const protocol_handler::ServiceType &service_type) { - LOG4CXX_TRACE(logger_, "ConnectionHandlerImpl::OnSessionEndedCallback()"); + LOG4CXX_AUTO_TRACE(logger_); - sync_primitives::AutoLock lock(connection_list_lock_); + connection_list_lock_.Acquire(); ConnectionList::iterator it = connection_list_.find(connection_handle); if (connection_list_.end() == it) { LOG4CXX_WARN(logger_, "Unknown connection!"); return 0; } - Connection *connection = it->second; + std::pair<int32_t, Connection*> connection_item = *it; + connection_list_lock_.Release(); + + Connection *connection = connection_item.second; const uint32_t session_key = KeyFromPair(connection_handle, session_id); if (protocol_handler::kRpc == service_type) { @@ -404,9 +438,10 @@ uint32_t ConnectionHandlerImpl::OnSessionEndedCallback( } } + sync_primitives::AutoLock lock2(connection_handler_observer_lock_); if (connection_handler_observer_) { - connection_handler_observer_->OnServiceEndedCallback(session_key, - service_type); + connection_handler_observer_->OnServiceEndedCallback( + session_key, service_type, CloseSessionReason::kCommon); } return session_key; } @@ -414,7 +449,7 @@ uint32_t ConnectionHandlerImpl::OnSessionEndedCallback( uint32_t ConnectionHandlerImpl::KeyFromPair( transport_manager::ConnectionUID connection_handle, uint8_t session_id) { const uint32_t key = connection_handle | (session_id << 16); - LOG4CXX_TRACE(logger_, "Key for ConnectionHandle:" + LOG4CXX_DEBUG(logger_, "Key for ConnectionHandle:" << static_cast<uint32_t>(connection_handle) << " Session:" << static_cast<uint32_t>(session_id) << " is: " << static_cast<uint32_t>(key)); @@ -430,7 +465,7 @@ void ConnectionHandlerImpl::PairFromKey(uint32_t key, uint8_t *session_id) { *connection_handle = key & 0xFF00FFFF; *session_id = key >> 16; - LOG4CXX_TRACE(logger_, "ConnectionHandle:" + LOG4CXX_DEBUG(logger_, "ConnectionHandle:" << static_cast<int32_t>(*connection_handle) << " Session:" << static_cast<int32_t>(*session_id) << " for key:" << static_cast<int32_t>(key)); @@ -439,7 +474,7 @@ void ConnectionHandlerImpl::PairFromKey(uint32_t key, int32_t ConnectionHandlerImpl::GetDataOnSessionKey( uint32_t key, uint32_t *app_id, std::list<int32_t> *sessions_list, uint32_t *device_id) { - LOG4CXX_TRACE(logger_, "ConnectionHandlerImpl::GetDataOnSessionKey"); + LOG4CXX_AUTO_TRACE(logger_); int32_t result = -1; transport_manager::ConnectionUID conn_handle = 0; @@ -520,7 +555,7 @@ int32_t ConnectionHandlerImpl::GetDataOnDeviceID( std::string *device_name, std::list<uint32_t> *applications_list, std::string *mac_address, std::string* connection_type ) { - LOG4CXX_TRACE(logger_, "ConnectionHandlerImpl::GetDataOnDeviceID"); + LOG4CXX_AUTO_TRACE(logger_); int32_t result = -1; DeviceMap::iterator it = device_list_.find(device_handle); @@ -564,7 +599,7 @@ int32_t ConnectionHandlerImpl::GetDataOnDeviceID( #ifdef ENABLE_SECURITY int ConnectionHandlerImpl::SetSSLContext( const uint32_t &key, security_manager::SSLContext *context) { - LOG4CXX_TRACE(logger_, "ConnectionHandlerImpl::SetSSLContext"); + LOG4CXX_AUTO_TRACE(logger_); transport_manager::ConnectionUID connection_handle = 0; uint8_t session_id = 0; PairFromKey(key, &connection_handle, &session_id); @@ -581,7 +616,7 @@ int ConnectionHandlerImpl::SetSSLContext( security_manager::SSLContext *ConnectionHandlerImpl::GetSSLContext( const uint32_t &key, const protocol_handler::ServiceType &service_type) { - LOG4CXX_TRACE(logger_, "ConnectionHandlerImpl::GetSSLContext"); + LOG4CXX_AUTO_TRACE(logger_); transport_manager::ConnectionUID connection_handle = 0; uint8_t session_id = 0; PairFromKey(key, &connection_handle, &session_id); @@ -598,7 +633,7 @@ security_manager::SSLContext *ConnectionHandlerImpl::GetSSLContext( void ConnectionHandlerImpl::SetProtectionFlag( const uint32_t &key, const protocol_handler::ServiceType &service_type) { - LOG4CXX_TRACE(logger_, "ConnectionHandlerImpl::SetProtectionFlag"); + LOG4CXX_AUTO_TRACE(logger_); transport_manager::ConnectionUID connection_handle = 0; uint8_t session_id = 0; PairFromKey(key, &connection_handle, &session_id); @@ -615,13 +650,14 @@ void ConnectionHandlerImpl::SetProtectionFlag( #endif // ENABLE_SECURITY void ConnectionHandlerImpl::StartDevicesDiscovery() { - LOG4CXX_TRACE(logger_, "ConnectionHandlerImpl::StartDevicesDiscovery()"); + LOG4CXX_AUTO_TRACE(logger_); if (NULL == transport_manager_) { LOG4CXX_ERROR(logger_, "Null pointer to TransportManager."); return; } transport_manager_->SearchDevices(); + sync_primitives::AutoLock lock(connection_handler_observer_lock_); if (connection_handler_observer_) { connection_handler_observer_->OnDeviceListUpdated(device_list_); } @@ -666,7 +702,7 @@ void ConnectionHandlerImpl::StartTransportManager() { } void ConnectionHandlerImpl::CloseRevokedConnection(uint32_t connection_key) { - LOG4CXX_TRACE(logger_, "ConnectionHandlerImpl::CloseRevokedConnection"); + LOG4CXX_AUTO_TRACE(logger_); uint32_t connection_handle = 0; uint8_t session_id = 0; @@ -677,7 +713,7 @@ void ConnectionHandlerImpl::CloseRevokedConnection(uint32_t connection_key) { void ConnectionHandlerImpl::CloseConnection( ConnectionHandle connection_handle) { - LOG4CXX_TRACE(logger_, "ConnectionHandlerImpl::CloseConnection"); + LOG4CXX_AUTO_TRACE(logger_); if (!transport_manager_) { LOG4CXX_ERROR(logger_, "Null pointer to TransportManager."); return; @@ -685,6 +721,14 @@ void ConnectionHandlerImpl::CloseConnection( transport_manager::ConnectionUID connection_uid = ConnectionUIDFromHandle(connection_handle); transport_manager_->DisconnectForce(connection_uid); + + sync_primitives::AutoLock connection_list_lock(connection_list_lock_); + + ConnectionList::iterator connection_list_itr = + connection_list_.find(connection_uid); + if (connection_list_.end() != connection_list_itr) { + connection_list_.erase(connection_list_itr); + } } uint32_t ConnectionHandlerImpl::GetConnectionSessionsCount( @@ -703,45 +747,121 @@ uint32_t ConnectionHandlerImpl::GetConnectionSessionsCount( return 0; } -void ConnectionHandlerImpl::CloseSession(uint32_t key) { - LOG4CXX_TRACE(logger_, "ConnectionHandlerImpl::CloseSession"); - +void ConnectionHandlerImpl::CloseSession(uint32_t key, + CloseSessionReason close_reason) { uint32_t connection_handle = 0; uint8_t session_id = 0; PairFromKey(key, &connection_handle, &session_id); - CloseSession(connection_handle, session_id); + CloseSession(connection_handle, session_id, close_reason); } void ConnectionHandlerImpl::CloseSession(ConnectionHandle connection_handle, - uint8_t session_id) { - if (protocol_handler_) { + uint8_t session_id, + CloseSessionReason close_reason) { + LOG4CXX_AUTO_TRACE(logger_); + LOG4CXX_DEBUG(logger_, "Closing session with id: " << session_id); + + // In case of malformed message the connection should be broke up without + // any other notification to mobile. + if (close_reason != kMalformed && protocol_handler_) { protocol_handler_->SendEndSession(connection_handle, session_id); } transport_manager::ConnectionUID connection_id = ConnectionUIDFromHandle(connection_handle); - sync_primitives::AutoLock connection_list_lock(connection_list_lock_); - ConnectionList::iterator itr = connection_list_.find(connection_id); + SessionMap session_map; + { + sync_primitives::AutoLock connection_list_lock(connection_list_lock_); - if (connection_list_.end() != itr) { - if (connection_handler_observer_) { - SessionMap session_map = itr->second->session_map(); - SessionMap::iterator session_it = session_map.find(session_id); - if (session_it != session_map.end()) { - const Session &session = session_it->second; - const ServiceList &service_list = session.service_list; - ServiceList::const_iterator it = service_list.begin(); - for (;it != service_list.end(); ++it) { - const uint32_t session_key = KeyFromPair(connection_id, session_id); - const protocol_handler::ServiceType service_type = it->service_type; - connection_handler_observer_->OnServiceEndedCallback(session_key, - service_type); - } + ConnectionList::iterator connection_list_itr = + connection_list_.find(connection_id); + if (connection_list_.end() != connection_list_itr) { + session_map = connection_list_itr->second->session_map(); + connection_list_itr->second->RemoveSession(session_id); + } else { + LOG4CXX_ERROR(logger_, "Connection with id: " << connection_id + << " not found"); + return; + } + } + + if (!connection_handler_observer_) { + LOG4CXX_ERROR(logger_, "Connection handler observer not found"); + return; + } + + SessionMap::const_iterator session_map_itr = session_map.find(session_id); + if (session_map_itr != session_map.end()) { + const uint32_t session_key = KeyFromPair(connection_id, session_id); + const Session &session = session_map_itr->second; + const ServiceList &service_list = session.service_list; + + ServiceList::const_iterator service_list_itr = service_list.begin(); + for (;service_list_itr != service_list.end(); ++service_list_itr) { + const protocol_handler::ServiceType service_type = + service_list_itr->service_type; + connection_handler_observer_->OnServiceEndedCallback( + session_key, service_type, close_reason); + } + } else { + LOG4CXX_ERROR(logger_, "Session with id: " + << session_id << " not found"); + return; + } + LOG4CXX_DEBUG(logger_, "Session with id: " << session_id + << " has been closed successfully"); +} + +void ConnectionHandlerImpl::CloseConnectionSessions( + ConnectionHandle connection_handle, CloseSessionReason close_reason) { + + LOG4CXX_AUTO_TRACE(logger_); + + transport_manager::ConnectionUID connection_id = + ConnectionUIDFromHandle(connection_handle); + + LOG4CXX_DEBUG(logger_, "Closing all sessions for connection with id: " + << connection_id); + + typedef std::vector<uint8_t> SessionIdVector; + SessionIdVector session_id_vector; + { + sync_primitives::AutoLock connection_list_lock(connection_list_lock_); + + ConnectionList::iterator connection_list_itr = + connection_list_.find(connection_id); + if (connection_list_.end() != connection_list_itr) { + const SessionMap session_map = connection_list_itr->second->session_map(); + + SessionMap::const_iterator session_map_itr = session_map.begin(); + for (;session_map_itr != session_map.end(); ++session_map_itr) { + session_id_vector.push_back(session_map_itr->first); } + } else { + LOG4CXX_ERROR(logger_, "Connection with id: " << connection_id + << " not found"); + return; } - itr->second->RemoveSession(session_id); + } + SessionIdVector::const_iterator session_id_itr = session_id_vector.begin(); + for(;session_id_itr != session_id_vector.end(); ++session_id_itr) { + CloseSession(connection_handle, *session_id_itr, close_reason); + } + session_id_vector.clear(); + + LOG4CXX_DEBUG(logger_, "All sessions for connection with id: " << connection_id + << " have been closed successfully"); +} + +void ConnectionHandlerImpl::SendEndService(uint32_t key, + uint8_t service_type) { + if (protocol_handler_) { + uint32_t connection_handle = 0; + uint8_t session_id = 0; + PairFromKey(key, &connection_handle, &session_id); + protocol_handler_->SendEndService(connection_handle, session_id, service_type); } } @@ -765,7 +885,7 @@ void ConnectionHandlerImpl::SetHeartBeatTimeout(uint32_t connection_key, sync_primitives::AutoLock lock(connection_list_lock_); ConnectionList::iterator it = connection_list_.find(connection_handle); if (connection_list_.end() != it) { - it->second->SetHeartBeatTimeout(timeout); + it->second->SetHeartBeatTimeout(timeout, session_id); } } @@ -793,15 +913,18 @@ void ConnectionHandlerImpl::OnConnectionEnded( LOG4CXX_INFO(logger_, "Delete Connection: " << static_cast<int32_t>(connection_id) << " from the list."); - sync_primitives::AutoLock lock(connection_list_lock_); + connection_list_lock_.Acquire(); ConnectionList::iterator itr = connection_list_.find(connection_id); if (connection_list_.end() == itr) { LOG4CXX_ERROR(logger_, "Connection not found!"); return; } + std::auto_ptr<Connection> connection(itr->second); + connection_list_.erase(itr); + connection_list_lock_.Release(); - if (connection_handler_observer_) { - const Connection *connection = itr->second; + sync_primitives::AutoLock lock2(connection_handler_observer_lock_); + if (connection_handler_observer_ && connection.get() != NULL) { const SessionMap session_map = connection->session_map(); for (SessionMap::const_iterator session_it = session_map.begin(); @@ -811,17 +934,15 @@ void ConnectionHandlerImpl::OnConnectionEnded( for (ServiceList::const_iterator service_it = service_list.begin(), end = service_list.end(); service_it != end; ++service_it) { connection_handler_observer_->OnServiceEndedCallback( - session_key, service_it->service_type); + session_key, service_it->service_type, CloseSessionReason::kCommon); } } } - delete itr->second; - connection_list_.erase(itr); } void ConnectionHandlerImpl::BindProtocolVersionWithSession( uint32_t connection_key, uint8_t protocol_version) { - LOG4CXX_INFO(logger_, "ConnectionHandlerImpl::BindProtocolVersionWithSession()"); + LOG4CXX_AUTO_TRACE(logger_); uint32_t connection_handle = 0; uint8_t session_id = 0; PairFromKey(connection_key, &connection_handle, &session_id); @@ -835,7 +956,7 @@ void ConnectionHandlerImpl::BindProtocolVersionWithSession( bool ConnectionHandlerImpl::IsHeartBeatSupported( transport_manager::ConnectionUID connection_handle,uint8_t session_id) { - LOG4CXX_INFO(logger_, "ConnectionHandlerImpl::IsHeartBeatSupported()"); + LOG4CXX_AUTO_TRACE(logger_); sync_primitives::AutoLock lock(connection_list_lock_); uint32_t connection = static_cast<uint32_t>(connection_handle); ConnectionList::iterator it = connection_list_.find(connection); @@ -846,6 +967,18 @@ bool ConnectionHandlerImpl::IsHeartBeatSupported( return it->second->SupportHeartBeat(session_id); } +bool ConnectionHandlerImpl::ProtocolVersionUsed(uint32_t connection_id, + uint8_t session_id, uint8_t& protocol_version) { + LOG4CXX_AUTO_TRACE(logger_); + sync_primitives::AutoLock lock(connection_list_lock_); + ConnectionList::iterator it = connection_list_.find(connection_id); + if (connection_list_.end() != it) { + return it->second->ProtocolVersion(session_id, protocol_version); + } + LOG4CXX_WARN(logger_, "Connection not found !"); + return false; +} + #ifdef BUILD_TESTS ConnectionList &ConnectionHandlerImpl::getConnectionList() { return connection_list_; |