diff options
Diffstat (limited to 'src/components/connection_handler')
18 files changed, 1625 insertions, 1172 deletions
diff --git a/src/components/connection_handler/CMakeLists.txt b/src/components/connection_handler/CMakeLists.txt index 657c90d108..dc1b2d24d6 100644 --- a/src/components/connection_handler/CMakeLists.txt +++ b/src/components/connection_handler/CMakeLists.txt @@ -34,7 +34,6 @@ set(CH_SRC_DIR ${COMPONENTS_DIR}/connection_handler/src) include_directories ( include ${COMPONENTS_DIR}/protocol_handler/include/ - ${COMPONENTS_DIR}/config_profile/include/ ${COMPONENTS_DIR}/utils/include/ ${ENCRYPTION_INCLUDE_DIRECTORY} ${LOG4CXX_INCLUDE_DIRECTORY} @@ -48,7 +47,6 @@ set (SOURCES ) set(LIBRARIES - ConfigProfile ProtocolLibrary ) @@ -57,4 +55,4 @@ target_link_libraries(connectionHandler encryption) if(BUILD_TESTS) add_subdirectory(test) -endif()
\ No newline at end of file +endif() diff --git a/src/components/connection_handler/include/connection_handler/connection.h b/src/components/connection_handler/include/connection_handler/connection.h index d20ddc1c00..aafc562505 100644 --- a/src/components/connection_handler/include/connection_handler/connection.h +++ b/src/components/connection_handler/include/connection_handler/connection.h @@ -73,13 +73,10 @@ struct Service { protocol_handler::ServiceType service_type; bool is_protected_; Service() - : service_type(protocol_handler::kInvalidServiceType), - is_protected_(false) { - } + : service_type(protocol_handler::kInvalidServiceType) + , is_protected_(false) {} explicit Service(protocol_handler::ServiceType service_type) - : service_type(service_type), - is_protected_(false) { - } + : service_type(service_type), is_protected_(false) {} bool operator==(const protocol_handler::ServiceType service_type) const { return this->service_type == service_type; } @@ -94,23 +91,26 @@ struct Session { ServiceList service_list; uint8_t protocol_version; #ifdef ENABLE_SECURITY - security_manager::SSLContext *ssl_context; + security_manager::SSLContext* ssl_context; #endif // ENABLE_SECURITY Session() - : service_list() + : service_list() #ifdef ENABLE_SECURITY - , ssl_context(NULL) + , ssl_context(NULL) #endif // ENABLE_SECURITY - {} - explicit Session(const ServiceList &services, uint8_t protocol_version) - : service_list(services), - protocol_version(protocol_version) + { + } + explicit Session(const ServiceList& services, uint8_t protocol_version) + : service_list(services) + , protocol_version(protocol_version) #ifdef ENABLE_SECURITY , ssl_context(NULL) #endif // ENABLE_SECURITY - {} - Service *FindService(const protocol_handler::ServiceType &service_type); - const Service *FindService(const protocol_handler::ServiceType &service_type) const; + { + } + Service* FindService(const protocol_handler::ServiceType& service_type); + const Service* FindService( + const protocol_handler::ServiceType& service_type) const; }; /** @@ -128,8 +128,8 @@ class Connection { */ Connection(ConnectionHandle connection_handle, DeviceHandle connection_device_handle, - ConnectionHandler *connection_handler, - int32_t heartbeat_timeout); + ConnectionHandler* connection_handler, + uint32_t heartbeat_timeout); /** * @brief Destructor @@ -146,7 +146,7 @@ class Connection { * @brief Returns connection device handle * @return ConnectionDeviceHandle */ - DeviceHandle connection_device_handle(); + DeviceHandle connection_device_handle() const; /** * @brief Adds session to connection @@ -187,8 +187,7 @@ class Connection { * @param context SSL for connection * @return \c true in case of service is protected or \c false otherwise */ - int SetSSLContext(uint8_t session_id, - security_manager::SSLContext *context); + int SetSSLContext(uint8_t session_id, security_manager::SSLContext* context); /** * @brief Gets crypto context of session, use service_type to get NULL * SSLContext for not protected services or ControlService (0x0) @@ -197,23 +196,22 @@ class Connection { * @param service_type Type of service * @return \ref SSLContext of connection */ - security_manager::SSLContext *GetSSLContext( - const uint8_t session_id, - const protocol_handler::ServiceType &service_type) const; + security_manager::SSLContext* GetSSLContext( + const uint8_t session_id, + const protocol_handler::ServiceType& service_type) const; /** * @brief Set protection flag to service in session by key * to get current SSLContext of connection * @param session_id Identifier of the session * @param service_type Type of service */ - void SetProtectionFlag( - const uint8_t session_id, - const protocol_handler::ServiceType &service_type); + void SetProtectionFlag(const uint8_t session_id, + const protocol_handler::ServiceType& service_type); #endif // ENABLE_SECURITY - /** - * @brief Returns map of sessions which have been opened in - * current connection. - */ + /** + * @brief Returns map of sessions which have been opened in + * current connection. + */ const SessionMap session_map() const; /** @@ -242,16 +240,17 @@ class Connection { /** * @brief Sets heart beat timeout - * @param timeout in seconds + * @param timeout in milliseconds */ - void SetHeartBeatTimeout(int32_t timeout, uint8_t session_id); + void SetHeartBeatTimeout(uint32_t timeout, uint8_t session_id); /** * @brief changes protocol version in session * @param session_id session id * @param protocol_version protocol version registered application */ - void UpdateProtocolVersionSession(uint8_t session_id, uint8_t protocol_version); + void UpdateProtocolVersionSession(uint8_t session_id, + uint8_t protocol_version); /** * @brief checks if session supports heartbeat @@ -267,14 +266,13 @@ class Connection { * @return TRUE if session exists otherwise * return FALSE */ - bool ProtocolVersion(uint8_t session_id, uint8_t& protocol_version); - + bool ProtocolVersion(uint8_t session_id, uint8_t& protocol_version); private: /** * @brief Current connection handler. */ - ConnectionHandler *connection_handler_; + ConnectionHandler* connection_handler_; /** * @brief Current connection handle. @@ -289,7 +287,7 @@ class Connection { /** * @brief session/services map */ - SessionMap session_map_; + SessionMap session_map_; mutable sync_primitives::Lock session_map_lock_; @@ -297,7 +295,8 @@ class Connection { * @brief monitor that closes connection if there is no traffic over it */ HeartBeatMonitor* heartbeat_monitor_; - threads::Thread *heart_beat_monitor_thread_; + uint32_t heartbeat_timeout_; + threads::Thread* heart_beat_monitor_thread_; DISALLOW_COPY_AND_ASSIGN(Connection); }; diff --git a/src/components/connection_handler/include/connection_handler/connection_handler.h b/src/components/connection_handler/include/connection_handler/connection_handler.h index 4a79658878..cb22b87bbb 100644 --- a/src/components/connection_handler/include/connection_handler/connection_handler.h +++ b/src/components/connection_handler/include/connection_handler/connection_handler.h @@ -33,6 +33,7 @@ #ifndef SRC_COMPONENTS_CONNECTION_HANDLER_INCLUDE_CONNECTION_HANDLER_CONNECTION_HANDLER_H_ #define SRC_COMPONENTS_CONNECTION_HANDLER_INCLUDE_CONNECTION_HANDLER_CONNECTION_HANDLER_H_ +#include "connection_handler/connection_handler_settings.h" #include "transport_manager/transport_manager_listener.h" #include "protocol_handler/session_observer.h" #include "connection_handler/device.h" @@ -45,14 +46,9 @@ */ namespace connection_handler { - enum CloseSessionReason { - kCommon = 0, - kFlood, - kMalformed, - kUnauthorizedApp - }; +enum CloseSessionReason { kCommon = 0, kFlood, kMalformed, kUnauthorizedApp }; - class ConnectionHandlerObserver; +class ConnectionHandlerObserver; /** * \class ConnectionHandler @@ -65,14 +61,7 @@ class ConnectionHandler { * \param observer Pointer to observer object. **/ virtual void set_connection_handler_observer( - ConnectionHandlerObserver *observer) = 0; - - /** - * \brief Sets pointer to TransportManager. - * \param transportManager Pointer to TransportManager object. - **/ - virtual void set_transport_manager( - transport_manager::TransportManager *transport_manager) = 0; + ConnectionHandlerObserver* observer) = 0; virtual void StartTransportManager() = 0; @@ -88,7 +77,8 @@ class ConnectionHandler { virtual void CloseRevokedConnection(uint32_t connection_key) = 0; /** - * \brief Close all associated sessions and close the connection pointed by handle + * \brief Close all associated sessions and close the connection pointed by + * handle */ virtual void CloseConnection(ConnectionHandle connection_handle) = 0; @@ -103,8 +93,8 @@ class ConnectionHandler { * @param mac_address * @return true if successfully */ - virtual bool GetDeviceID(const std::string &mac_address, - DeviceHandle *device_handle) = 0; + virtual bool GetDeviceID(const std::string& mac_address, + DeviceHandle* device_handle) = 0; /** * Close session associated with the key @@ -118,13 +108,13 @@ class ConnectionHandler { uint8_t session_id, CloseSessionReason close_reason) = 0; - /** - * @brief SendEndService allows to end up specific service. - * - * @param key application identifier whose service should be closed. - * - * @param service_type the service that should be closed. - */ + /** + * @brief SendEndService allows to end up specific service. + * + * @param key application identifier whose service should be closed. + * + * @param service_type the service that should be closed. + */ virtual void SendEndService(uint32_t key, uint8_t service_type) = 0; /** @@ -138,15 +128,22 @@ class ConnectionHandler { * \brief Send heartbeat to mobile app */ virtual void SendHeartBeat(ConnectionHandle connection_handle, - uint8_t session_id) = 0; + uint8_t session_id) = 0; /** * Sets heart beat timeout for specified session * @param connection_key pair of connection and session id - * @param timeout in seconds + * @param timeout in milliseconds */ virtual void SetHeartBeatTimeout(uint32_t connection_key, - int32_t timeout) = 0; + uint32_t timeout) = 0; + + /** + * \brief Keep connection associated with the key from being closed by + * heartbeat monitor + */ + virtual void KeepConnectionAlive(uint32_t connection_key, + uint8_t session_id) = 0; /** * \brief binds protocol version with session @@ -158,12 +155,42 @@ class ConnectionHandler { virtual void BindProtocolVersionWithSession(uint32_t connection_key, uint8_t protocol_version) = 0; + /** + * \brief information about given Connection Key. + * \param key Unique key used by other components as session identifier + * \param app_id Returned: ApplicationID + * \param sessions_list Returned: List of session keys + * \param device_id Returned: DeviceID + * \return int32_t -1 in case of error or 0 in case of success + */ + virtual int32_t GetDataOnSessionKey(uint32_t key, + uint32_t* app_id, + std::list<int32_t>* sessions_list, + uint32_t* device_id) const = 0; + /** + * @brief GetConnectedDevicesMAC allows to obtain MAC adresses for all + * currently connected devices. + * + * @param device_macs collection of MAC adresses for connected devices. + */ + virtual void GetConnectedDevicesMAC( + std::vector<std::string>& device_macs) const = 0; + + /** + * \brief Connection handler settings getter + * \return pointer to connection handler settings class + */ + virtual const ConnectionHandlerSettings& get_settings() const = 0; + + virtual const protocol_handler::SessionObserver& get_session_observer() = 0; + + virtual DevicesDiscoveryStarter& get_device_discovery_starter() = 0; + protected: /** * \brief Destructor */ - virtual ~ConnectionHandler() { - } + virtual ~ConnectionHandler() {} }; } // namespace connection_handler diff --git a/src/components/connection_handler/include/connection_handler/connection_handler_impl.h b/src/components/connection_handler/include/connection_handler/connection_handler_impl.h index 4ead673663..d061e55491 100644 --- a/src/components/connection_handler/include/connection_handler/connection_handler_impl.h +++ b/src/components/connection_handler/include/connection_handler/connection_handler_impl.h @@ -46,11 +46,11 @@ #include "connection_handler/connection.h" #include "connection_handler/devices_discovery_starter.h" #include "connection_handler/connection_handler.h" + #include "utils/logger.h" #include "utils/macro.h" #include "utils/lock.h" #include "utils/stl_utils.h" -#include "utils/singleton.h" #include "utils/rwlock.h" /** @@ -65,53 +65,51 @@ namespace connection_handler { * stores information regarding connections * and sessions and provides it to AppManager. */ -class ConnectionHandlerImpl : public ConnectionHandler, - public transport_manager::TransportManagerListenerEmpty, - public protocol_handler::SessionObserver, - public DevicesDiscoveryStarter, - public utils::Singleton<ConnectionHandlerImpl> { +class ConnectionHandlerImpl + : public ConnectionHandler, + public transport_manager::TransportManagerListenerEmpty, + public protocol_handler::SessionObserver, + public DevicesDiscoveryStarter { public: /** + * @brief ConnectionHandlerImpl + */ + ConnectionHandlerImpl(const ConnectionHandlerSettings& settings, + transport_manager::TransportManager& tm); + /** * \brief Destructor */ - virtual ~ConnectionHandlerImpl(); + ~ConnectionHandlerImpl(); - void Stop(); + void Stop(); /** * \brief Sets observer pointer for connection_handler. * \param observer Pointer to observer object. */ - virtual void set_connection_handler_observer( - ConnectionHandlerObserver *observer); - - /** - * \brief Sets pointer to TransportManager. - * \param transport_mngr Pointer to TransportManager object. - **/ - virtual void set_transport_manager( - transport_manager::TransportManager *transport_mngr); + void set_connection_handler_observer( + ConnectionHandlerObserver* observer) OVERRIDE; /** * \brief Sets pointer to ProtocolHandler. * \param protocol_handler Pointer to ProtocolHandler object. **/ void set_protocol_handler( - protocol_handler::ProtocolHandler *protocol_handler); + protocol_handler::ProtocolHandler* protocol_handler); /** * \brief Connects to all services of device * \param deviceHandle Handle of device to connect to */ - virtual void ConnectToDevice(connection_handler::DeviceHandle device_handle); + void ConnectToDevice(connection_handler::DeviceHandle device_handle) OVERRIDE; - virtual void ConnectToAllDevices(); + void ConnectToAllDevices() OVERRIDE; - virtual void StartTransportManager(); + void StartTransportManager() OVERRIDE; - virtual void OnDeviceListUpdated( - const std::vector<transport_manager::DeviceInfo> &); + void OnDeviceListUpdated( + const std::vector<transport_manager::DeviceInfo>&) OVERRIDE; - virtual void OnFindNewApplicationsRequest(); + void OnFindNewApplicationsRequest() OVERRIDE; /** * \brief Available devices list updated. @@ -121,87 +119,93 @@ class ConnectionHandlerImpl : public ConnectionHandler, * * \param DeviceList New list of available devices. **/ - virtual void OnDeviceFound(const transport_manager::DeviceInfo &device_info); - virtual void OnDeviceAdded(const transport_manager::DeviceInfo &device_info); - virtual void OnDeviceRemoved(const transport_manager::DeviceInfo &device_info); + void OnDeviceFound(const transport_manager::DeviceInfo& device_info) OVERRIDE; + void OnDeviceAdded(const transport_manager::DeviceInfo& device_info) OVERRIDE; + void OnDeviceRemoved( + const transport_manager::DeviceInfo& device_info) OVERRIDE; - virtual void OnScanDevicesFinished(); - virtual void OnScanDevicesFailed( - const transport_manager::SearchDeviceError &error); + void OnScanDevicesFinished() OVERRIDE; + void OnScanDevicesFailed( + const transport_manager::SearchDeviceError& error) OVERRIDE; /** * \brief Notifies about established connection. * * \param connection_id ID of new connection. **/ - virtual void OnConnectionEstablished( - const transport_manager::DeviceInfo &device_info, - const transport_manager::ConnectionUID &connection_id); - virtual void OnConnectionFailed( - const transport_manager::DeviceInfo &device_info, - const transport_manager::ConnectError &error); - virtual void OnConnectionClosed( - transport_manager::ConnectionUID connection_id); - virtual void OnConnectionClosedFailure( - transport_manager::ConnectionUID connection_id, - const transport_manager::DisconnectError &error); - virtual void OnUnexpectedDisconnect( - transport_manager::ConnectionUID connection_id, - const transport_manager::CommunicationError &error); - virtual void OnDeviceConnectionLost( - const connection_handler::DeviceHandle &device, - const transport_manager::DisconnectDeviceError &error); + void OnConnectionEstablished( + const transport_manager::DeviceInfo& device_info, + const transport_manager::ConnectionUID connection_id) OVERRIDE; + void OnConnectionFailed( + const transport_manager::DeviceInfo& device_info, + const transport_manager::ConnectError& error) OVERRIDE; + void OnConnectionClosed( + transport_manager::ConnectionUID connection_id) OVERRIDE; + void OnConnectionClosedFailure( + transport_manager::ConnectionUID connection_id, + const transport_manager::DisconnectError& error) OVERRIDE; + void OnUnexpectedDisconnect( + transport_manager::ConnectionUID connection_id, + const transport_manager::CommunicationError& error) OVERRIDE; + void OnDeviceConnectionLost( + const connection_handler::DeviceHandle& device, + const transport_manager::DisconnectDeviceError& error) OVERRIDE; /** * \brief Informs about failure during DisconnectDevice procedure of TM * \param device Information about disconnected device * \param error Information about possible reason of loosing connection */ - virtual void OnDisconnectFailed( - const connection_handler::DeviceHandle &device, - const transport_manager::DisconnectDeviceError &error); + void OnDisconnectFailed( + const connection_handler::DeviceHandle& device, + const transport_manager::DisconnectDeviceError& error) OVERRIDE; /** * \brief Callback function used by ProtocolHandler * when Mobile Application initiates start of new session. - * \param connection_handle Connection identifier within which session has to be started. + * \param connection_handle Connection identifier within which session has to + * be started. * \param session_id Identifier of the session to be started * \param service_type Type of service * \param is_protected would be service protected * \param hash_id pointer for session hash identifier * \return uint32_t Id (number) of new session if successful, otherwise 0. */ - virtual uint32_t 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); + virtual uint32_t 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); /** * \brief Callback function used by ProtocolHandler * when Mobile Application initiates session ending. * \param connection_handle Connection identifier within which session exists * \param sessionId Identifier of the session to be ended - * \param hashCode Hash used only in second version of SmartDeviceLink protocol. + * \param hashCode Hash used only in second version of SmartDeviceLink + * protocol. * If not equal to hash assigned to session on start then operation fails. * \return uint32_t 0 if operation fails, session key otherwise */ - virtual uint32_t OnSessionEndedCallback( - const transport_manager::ConnectionUID &connection_handle, - const uint8_t session_id, const uint32_t &hashCode, - const protocol_handler::ServiceType &service_type); + uint32_t OnSessionEndedCallback( + const transport_manager::ConnectionUID connection_handle, + const uint8_t session_id, + const uint32_t& hashCode, + const protocol_handler::ServiceType& service_type) OVERRIDE; /** * \brief Callback function used by ProtocolHandler * when Mobile Application start message flood * \param connection_key used by other components as application identifier */ - void OnApplicationFloodCallBack(const uint32_t &connection_key) OVERRIDE; + void OnApplicationFloodCallBack(const uint32_t& connection_key) OVERRIDE; /** * \brief Callback function used by ProtocolHandler * when Mobile Application sends malformed message * \param connection_key used by other components as application identifier */ - void OnMalformedMessageCallback(const uint32_t &connection_key) OVERRIDE; + void OnMalformedMessageCallback(const uint32_t& connection_key) OVERRIDE; /** * \brief Creates unique identifier of session (can be used as hash) @@ -211,31 +215,20 @@ class ConnectionHandlerImpl : public ConnectionHandler, * \param sessionId Identifier of the session * \return int32_t Unique key for session */ - virtual uint32_t KeyFromPair( - transport_manager::ConnectionUID connection_handle, - uint8_t session_id); + uint32_t KeyFromPair(transport_manager::ConnectionUID connection_handle, + uint8_t session_id) const OVERRIDE; /** - * \brief Returns connection identifier and session number from given session key + * \brief Returns connection identifier and session number from given session + * key * \param key Unique key used by other components as session identifier - * \param connection_handle Returned: Connection identifier within which session exists + * \param connection_handle Returned: Connection identifier within which + * session exists * \param sessionId Returned: Number of session */ - virtual void PairFromKey(uint32_t key, - transport_manager::ConnectionUID *connection_handle, - uint8_t *session_id); - - /** - * \brief information about given Connection Key. - * \param key Unique key used by other components as session identifier - * \param app_id Returned: ApplicationID - * \param sessions_list Returned: List of session keys - * \param device_id Returned: DeviceID - * \return int32_t -1 in case of error or 0 in case of success - */ - virtual int32_t GetDataOnSessionKey(uint32_t key, uint32_t *app_id = 0, - std::list<int32_t> *sessions_list = NULL, - uint32_t *device_id = 0); + void PairFromKey(uint32_t key, + transport_manager::ConnectionUID* connection_handle, + uint8_t* session_id) const OVERRIDE; /** * \brief information about device @@ -246,11 +239,21 @@ class ConnectionHandlerImpl : public ConnectionHandler, * \param connection_type Returned: type of connection (USB, BT, etc.) * \return int32_t -1 in case of error or 0 in case of success */ - virtual int32_t GetDataOnDeviceID(connection_handler::DeviceHandle device_handle, - std::string *device_name = NULL, - std::list<uint32_t> *applications_list = NULL, - std::string *mac_address = NULL, - std::string* connection_type = NULL); + int32_t GetDataOnDeviceID(connection_handler::DeviceHandle device_handle, + std::string* device_name = NULL, + std::list<uint32_t>* applications_list = NULL, + std::string* mac_address = NULL, + std::string* connection_type = NULL) const OVERRIDE; + + /** + * @brief GetConnectedDevicesMAC allows to obtain MAC adresses for all + * currently connected devices. + * + * @param device_macs collection of MAC adresses for connected devices. + */ + void GetConnectedDevicesMAC( + std::vector<std::string>& device_macs) const OVERRIDE; + #ifdef ENABLE_SECURITY /** * \brief Sets crypto context of connection @@ -258,9 +261,8 @@ class ConnectionHandlerImpl : public ConnectionHandler, * \param context SSLContext to be set * \return \c SecurityQuery::ProtectSessionResult value */ - int SetSSLContext( - const uint32_t &key, - security_manager::SSLContext *context) OVERRIDE; + int SetSSLContext(const uint32_t& key, + security_manager::SSLContext* context) OVERRIDE; /** * \brief Gets crypto context of connection, use service_type to get NULL @@ -270,17 +272,20 @@ class ConnectionHandlerImpl : public ConnectionHandler, * \param service_type Type of service * \return \ref SSLContext of connection */ - security_manager::SSLContext *GetSSLContext( - const uint32_t &key, - const protocol_handler::ServiceType &service_type) OVERRIDE; + security_manager::SSLContext* GetSSLContext( + const uint32_t& key, + const protocol_handler::ServiceType& service_type) OVERRIDE; /** * \brief Set protection flag to service in session by key * \param key Unique key used by other components as session identifier * \param service_type Type of service */ void SetProtectionFlag( - const uint32_t &key, - const protocol_handler::ServiceType &service_type) OVERRIDE; + const uint32_t& key, + const protocol_handler::ServiceType& service_type) OVERRIDE; + + security_manager::SSLContext::HandshakeContext GetHandshakeContext( + uint32_t key) const OVERRIDE; #endif // ENABLE_SECURITY /** @@ -289,40 +294,40 @@ class ConnectionHandlerImpl : public ConnectionHandler, * \param device_handle * \return true on sucess otherwise false. */ - virtual bool GetDeviceID(const std::string &mac_address, - DeviceHandle *device_handle); + bool GetDeviceID(const std::string& mac_address, + DeviceHandle* device_handle) OVERRIDE; /** * \brief Method which should start devices discovering */ - virtual void StartDevicesDiscovery(); + void StartDevicesDiscovery() OVERRIDE; /** * @brief Close the connection revoked by Policy * @param connection_key pair of connection and session id */ - virtual void CloseRevokedConnection(uint32_t connection_key); + void CloseRevokedConnection(uint32_t connection_key) OVERRIDE; /** * @brief Close the connection pointed by handle * @param connection_handle Connection unique id */ - virtual void CloseConnection(ConnectionHandle connection_handle) OVERRIDE; + void CloseConnection(ConnectionHandle connection_handle) OVERRIDE; /** * \brief Close session associated with the key * \param key Unique key used by other components as session identifier */ - virtual void CloseSession(uint32_t key, CloseSessionReason close_reason); + void CloseSession(uint32_t key, CloseSessionReason close_reason) OVERRIDE; /** * \brief Function used by HearbeatMonitior to close session on HB timeout * \param connection_handle Connection handler within which session exists * \param session_id Identifier of the session to be ended */ - virtual void CloseSession(ConnectionHandle connection_handle, - uint8_t session_id, - CloseSessionReason close_reason); + void CloseSession(ConnectionHandle connection_handle, + uint8_t session_id, + CloseSessionReason close_reason) OVERRIDE; /** * \brief Function used by OnApplicationFloodCallback and @@ -331,20 +336,20 @@ class ConnectionHandlerImpl : public ConnectionHandler, * \param connection_handle Connection identifier within which session exists * \param close_reason The reason of connection closing */ - virtual void CloseConnectionSessions( - ConnectionHandle connection_handle, CloseSessionReason close_reason); + virtual void CloseConnectionSessions(ConnectionHandle connection_handle, + CloseSessionReason close_reason); /** * \brief Return count of session for specified connection * \param connection_key pair of connection handle and session id */ - virtual uint32_t GetConnectionSessionsCount(uint32_t connection_key); + uint32_t GetConnectionSessionsCount(uint32_t connection_key) OVERRIDE; /** * \brief Send heartbeat message to mobile app */ - virtual void SendHeartBeat(ConnectionHandle connection_handle, - uint8_t session_id); + void SendHeartBeat(ConnectionHandle connection_handle, + uint8_t session_id) OVERRIDE; /** * @brief SendEndService allows to end up specific service. @@ -353,25 +358,25 @@ class ConnectionHandlerImpl : public ConnectionHandler, * * @param service_type the service that should be closed. */ - virtual void SendEndService(uint32_t key, - uint8_t service_type); + void SendEndService(uint32_t key, uint8_t service_type) OVERRIDE; /** * \brief Start heartbeat for specified session * * \param connection_key pair of connection and session id */ - virtual void StartSessionHeartBeat(uint32_t connection_key); + void StartSessionHeartBeat(uint32_t connection_key) OVERRIDE; /** * Sets heart beat timeout for specified session * @param connection_key pair of connection and session id - * @param timeout in seconds + * @param timeout in milliseconds */ - virtual void SetHeartBeatTimeout(uint32_t connection_key, int32_t timeout); + void SetHeartBeatTimeout(uint32_t connection_key, uint32_t timeout) OVERRIDE; /** - * \brief Keep connection associated with the key from being closed by heartbeat monitor + * \brief Keep connection associated with the key from being closed by + * heartbeat monitor */ void KeepConnectionAlive(uint32_t connection_key, uint8_t session_id); @@ -382,18 +387,20 @@ class ConnectionHandlerImpl : public ConnectionHandler, * \param protocol_version contains protocol version of * \registered application. */ - virtual void BindProtocolVersionWithSession(uint32_t connection_key, - uint8_t protocol_version); + void BindProtocolVersionWithSession(uint32_t connection_key, + uint8_t protocol_version) OVERRIDE; /** - * \brief returns TRUE if session supports sending HEART BEAT ACK to mobile side - * \param connection_handle Connection identifier whithin which session exists + * \brief returns TRUE if session supports sending HEART BEAT ACK to mobile + * side + * \param connection_handle Connection identifier whithin which session + * exists * \param sessionId Identifier of the session - * \return TRUE if session has protocol version which supports heartbeat otherwise returns FALSE + * \return TRUE if session has protocol version which supports heartbeat + * otherwise returns FALSE */ - virtual bool IsHeartBeatSupported( - transport_manager::ConnectionUID connection_handle, - uint8_t session_id); + bool IsHeartBeatSupported(transport_manager::ConnectionUID connection_handle, + uint8_t session_id) const OVERRIDE; /** * @brief returns protocol version which application supports @@ -402,14 +409,21 @@ class ConnectionHandlerImpl : public ConnectionHandler, * @param method writes value protocol version to protocol_version * @return TRUE if session and connection exist otherwise returns FALSE */ - virtual bool ProtocolVersionUsed(uint32_t connection_id, - uint8_t session_id, uint8_t& protocol_version); - private: - /** - * \brief Default class constructor - */ - ConnectionHandlerImpl(); + bool ProtocolVersionUsed(uint32_t connection_id, + uint8_t session_id, + uint8_t& protocol_version) const OVERRIDE; + + int32_t GetDataOnSessionKey(uint32_t key, + uint32_t* app_id, + std::list<int32_t>* sessions_list, + uint32_t* device_id) const OVERRIDE; + + const ConnectionHandlerSettings& get_settings() const OVERRIDE; + const protocol_handler::SessionObserver& get_session_observer(); + DevicesDiscoveryStarter& get_device_discovery_starter(); + + private: /** * \brief Disconnect application. * @@ -418,20 +432,20 @@ class ConnectionHandlerImpl : public ConnectionHandler, **/ void RemoveConnection(const ConnectionHandle connection_handle); - void OnConnectionEnded( - const transport_manager::ConnectionUID &connection_id); + void OnConnectionEnded(const transport_manager::ConnectionUID connection_id); + const ConnectionHandlerSettings& settings_; /** * \brief Pointer to observer */ - ConnectionHandlerObserver *connection_handler_observer_; + ConnectionHandlerObserver* connection_handler_observer_; /** * \brief Pointer to TransportManager */ - transport_manager::TransportManager *transport_manager_; + transport_manager::TransportManager& transport_manager_; - protocol_handler::ProtocolHandler *protocol_handler_; + protocol_handler::ProtocolHandler* protocol_handler_; /** * \brief List of devices @@ -446,7 +460,7 @@ class ConnectionHandlerImpl : public ConnectionHandler, /** * \brief Lock for applications list */ - mutable sync_primitives::Lock connection_list_lock_; + mutable sync_primitives::RWLock connection_list_lock_; mutable sync_primitives::RWLock connection_handler_observer_lock_; /** @@ -457,13 +471,13 @@ class ConnectionHandlerImpl : public ConnectionHandler, #ifdef BUILD_TESTS // Methods for test usage public: - ConnectionList &getConnectionList(); + const DeviceMap& getDeviceList(); + ConnectionList& getConnectionList(); void addDeviceConnection( - const transport_manager::DeviceInfo &device_info, - const transport_manager::ConnectionUID &connection_id); + const transport_manager::DeviceInfo& device_info, + const transport_manager::ConnectionUID connection_id); #endif private: - FRIEND_BASE_SINGLETON_CLASS(ConnectionHandlerImpl); DISALLOW_COPY_AND_ASSIGN(ConnectionHandlerImpl); }; } // namespace connection_handler diff --git a/src/components/connection_handler/include/connection_handler/connection_handler_observer.h b/src/components/connection_handler/include/connection_handler/connection_handler_observer.h index 556a2dc4e2..54b8d3a92e 100644 --- a/src/components/connection_handler/include/connection_handler/connection_handler_observer.h +++ b/src/components/connection_handler/include/connection_handler/connection_handler_observer.h @@ -38,6 +38,10 @@ #include "connection_handler/connection_handler.h" #include "protocol/service_type.h" +#ifdef ENABLE_SECURITY +#include "security_manager/ssl_context.h" +#endif // ENABLE_SECURITY + /** * \namespace connection_handler * \brief SmartDeviceLink connection_handler namespace. @@ -49,7 +53,7 @@ namespace connection_handler { * \brief ConnectionHandlerObserver class */ class ConnectionHandlerObserver { - public: + public: /** * \brief Available devices list updated. * @@ -59,7 +63,7 @@ class ConnectionHandlerObserver { * \param DeviceList New list of available devices. **/ virtual void OnDeviceListUpdated( - const connection_handler::DeviceMap &device_list) = 0; + const connection_handler::DeviceMap& device_list) = 0; /** * @brief Reaction to "Find new applications" request @@ -74,19 +78,20 @@ class ConnectionHandlerObserver { * \param DeviceHandle Handle of removed device. **/ virtual void RemoveDevice( - const connection_handler::DeviceHandle &device_handle) = 0; + const connection_handler::DeviceHandle& device_handle) = 0; /** * \brief Callback function used by connection_handler * when Mobile Application initiates start of new service. - * \param deviceHandle Device identifier within which session has to be started. + * \param deviceHandle Device identifier within which session has to be + * started. * \param sessionKey Key of started session. * \param type Established service type */ virtual bool OnServiceStartedCallback( - const connection_handler::DeviceHandle &device_handle, - const int32_t &session_key, - const protocol_handler::ServiceType &type) = 0; + const connection_handler::DeviceHandle& device_handle, + const int32_t& session_key, + const protocol_handler::ServiceType& type) = 0; /** * \brief Callback function used by connection_handler @@ -100,12 +105,15 @@ class ConnectionHandlerObserver { const protocol_handler::ServiceType& type, const connection_handler::CloseSessionReason& close_reason) = 0; +#ifdef ENABLE_SECURITY + virtual security_manager::SSLContext::HandshakeContext GetHandshakeContext( + uint32_t key) const = 0; +#endif // ENABLE_SECURITY protected: /** * \brief Destructor */ - virtual ~ConnectionHandlerObserver() { - } + virtual ~ConnectionHandlerObserver() {} }; } // namespace connection_handler diff --git a/src/components/connection_handler/include/connection_handler/device.h b/src/components/connection_handler/include/connection_handler/device.h index c37c4cc62c..cee0bf8875 100644 --- a/src/components/connection_handler/include/connection_handler/device.h +++ b/src/components/connection_handler/include/connection_handler/device.h @@ -58,8 +58,10 @@ class Device { /** * \brief Class constructor */ - Device(DeviceHandle device_handle, const std::string &user_friendly_name, - const std::string &mac_address = "", const std::string& connection_type = ""); + Device(DeviceHandle device_handle, + const std::string& user_friendly_name, + const std::string& mac_address = "", + const std::string& connection_type = ""); /** * \brief Returns device handle diff --git a/src/components/connection_handler/include/connection_handler/devices_discovery_starter.h b/src/components/connection_handler/include/connection_handler/devices_discovery_starter.h index bd5885a273..0bb3da0772 100644 --- a/src/components/connection_handler/include/connection_handler/devices_discovery_starter.h +++ b/src/components/connection_handler/include/connection_handler/devices_discovery_starter.h @@ -49,7 +49,7 @@ class DevicesDiscoveryStarter { /** * \brief Method which should start devices discoveryng */ - virtual void StartDevicesDiscovery()=0; + virtual void StartDevicesDiscovery() = 0; /** * \brief Connects to all services of device @@ -64,8 +64,7 @@ class DevicesDiscoveryStarter { /** * \brief Destructor */ - virtual ~DevicesDiscoveryStarter() { - } + virtual ~DevicesDiscoveryStarter() {} }; } // namespace connection_handler diff --git a/src/components/connection_handler/include/connection_handler/heartbeat_monitor.h b/src/components/connection_handler/include/connection_handler/heartbeat_monitor.h index 0233e269dd..f6ef9a9829 100644 --- a/src/components/connection_handler/include/connection_handler/heartbeat_monitor.h +++ b/src/components/connection_handler/include/connection_handler/heartbeat_monitor.h @@ -48,10 +48,9 @@ class Connection; /* * Starts hearbeat timer for session and when it elapses closes it */ -class HeartBeatMonitor: public threads::ThreadDelegate { +class HeartBeatMonitor : public threads::ThreadDelegate { public: - HeartBeatMonitor(int32_t heartbeat_timeout_seconds, - Connection *connection); + HeartBeatMonitor(uint32_t heartbeat_timeout_mseconds, Connection* connection); /** * Thread procedure. @@ -73,34 +72,38 @@ class HeartBeatMonitor: public threads::ThreadDelegate { * \brief Thread exit procedure. */ virtual void exitThreadMain(); - - void set_heartbeat_timeout_seconds(int32_t timeout, uint8_t session_id); + /** + * @brief Update heart beat timeout for session + * @param timeout contains timeout for updating + * @param session_id contain id session for which update timeout + * timeout + **/ + void set_heartbeat_timeout_milliseconds(uint32_t timeout, uint8_t session_id); private: - - // \brief Heartbeat timeout, should be read from profile - int32_t default_heartbeat_timeout_; + // \brief Heartbeat timeout + uint32_t default_heartbeat_timeout_; // \brief Connection that must be closed when timeout elapsed - Connection *connection_; + Connection* connection_; - //Default HeartBeat cycle timeout (in miliseconds) + // Default HeartBeat cycle timeout (in miliseconds) static const int32_t kDefaultCycleTimeout = 100; class SessionState { - public: - explicit SessionState(int32_t heartbeat_timeout_seconds = 0); - void UpdateTimeout(int32_t heartbeat_timeout_seconds); - void PrepareToClose(); - bool IsReadyToClose() const; - void KeepAlive(); - bool HasTimeoutElapsed(); - private: - void RefreshExpiration(); - - int32_t heartbeat_timeout_seconds_; - TimevalStruct heartbeat_expiration; - bool is_heartbeat_sent; - + public: + explicit SessionState(uint32_t heartbeat_timeout_mseconds = 0); + void UpdateTimeout(uint32_t heartbeat_timeout_mseconds); + void PrepareToClose(); + bool IsReadyToClose() const; + void KeepAlive(); + bool HasTimeoutElapsed(); + + private: + void RefreshExpiration(); + + uint32_t heartbeat_timeout_mseconds_; + TimevalStruct heartbeat_expiration_; + bool is_heartbeat_sent_; }; // \brief monitored sessions collection @@ -108,7 +111,7 @@ class HeartBeatMonitor: public threads::ThreadDelegate { typedef std::map<uint8_t, SessionState> SessionMap; SessionMap sessions_; - sync_primitives::Lock sessions_list_lock_; // recurcive + sync_primitives::Lock sessions_list_lock_; // recurcive sync_primitives::Lock main_thread_lock_; mutable sync_primitives::Lock heartbeat_timeout_seconds_lock_; sync_primitives::ConditionalVariable heartbeat_monitor_; @@ -120,6 +123,6 @@ class HeartBeatMonitor: public threads::ThreadDelegate { DISALLOW_COPY_AND_ASSIGN(HeartBeatMonitor); }; -} // namespace connection_handler +} // namespace connection_handler #endif // SRC_COMPONENTS_CONNECTION_HANDLER_INCLUDE_HEARTBEAT_MONITOR_H_ diff --git a/src/components/connection_handler/src/connection.cc b/src/components/connection_handler/src/connection.cc index de8c7edb03..7bb54d4493 100644 --- a/src/components/connection_handler/src/connection.cc +++ b/src/components/connection_handler/src/connection.cc @@ -37,7 +37,6 @@ #include "connection_handler/connection.h" #include "connection_handler/connection_handler.h" #include "protocol_handler/protocol_packet.h" -#include "config_profile/profile.h" #include "utils/logger.h" #include "utils/macro.h" @@ -46,7 +45,6 @@ #include "security_manager/security_manager.h" #endif // ENABLE_SECURITY - /** * \namespace connection_handler * \brief SmartDeviceLink ConnectionHandler namespace. @@ -55,19 +53,21 @@ namespace connection_handler { CREATE_LOGGERPTR_GLOBAL(logger_, "ConnectionHandler") -Service *Session::FindService(const protocol_handler::ServiceType &service_type) { +Service* Session::FindService( + const protocol_handler::ServiceType& service_type) { ServiceList::iterator service_it = std::find(service_list.begin(), service_list.end(), service_type); - if(service_it != service_list.end()){ + if (service_it != service_list.end()) { return &(*service_it); } return NULL; } -const Service *Session::FindService(const protocol_handler::ServiceType &service_type) const { +const Service* Session::FindService( + const protocol_handler::ServiceType& service_type) const { ServiceList::const_iterator service_it = std::find(service_list.begin(), service_list.end(), service_type); - if(service_it != service_list.end()){ + if (service_it != service_list.end()) { return &(*service_it); } return NULL; @@ -75,18 +75,19 @@ const Service *Session::FindService(const protocol_handler::ServiceType &service Connection::Connection(ConnectionHandle connection_handle, DeviceHandle connection_device_handle, - ConnectionHandler *connection_handler, - int32_t heartbeat_timeout) - : connection_handler_(connection_handler), - connection_handle_(connection_handle), - connection_device_handle_(connection_device_handle), - session_map_lock_(true) { + ConnectionHandler* connection_handler, + uint32_t heartbeat_timeout) + : connection_handler_(connection_handler) + , connection_handle_(connection_handle) + , connection_device_handle_(connection_device_handle) + , session_map_lock_(true) + , heartbeat_timeout_(heartbeat_timeout) { LOG4CXX_AUTO_TRACE(logger_); DCHECK(connection_handler_); - heartbeat_monitor_ = new HeartBeatMonitor(heartbeat_timeout, this); - heart_beat_monitor_thread_ = threads::CreateThread("HeartBeatMonitor", - heartbeat_monitor_); + heartbeat_monitor_ = new HeartBeatMonitor(heartbeat_timeout_, this); + heart_beat_monitor_thread_ = + threads::CreateThread("HeartBeatMonitor", heartbeat_monitor_); heart_beat_monitor_thread_->start(); } @@ -103,7 +104,7 @@ Connection::~Connection() { // Returns 0 if that key not found namespace { template <class T> -uint32_t findGap(const std::map<unsigned char, T> &map) { +uint32_t findGap(const std::map<unsigned char, T>& map) { for (uint32_t i = 1; i <= UCHAR_MAX; ++i) { if (map.find(i) == map.end()) { return i; @@ -143,7 +144,7 @@ bool Connection::AddNewService(uint8_t session_id, const bool request_protection) { // Ignore wrong services if (protocol_handler::kControl == service_type || - protocol_handler::kInvalidServiceType == service_type ) { + protocol_handler::kInvalidServiceType == service_type) { LOG4CXX_WARN(logger_, "Wrong service " << static_cast<int>(service_type)); return false; } @@ -154,19 +155,23 @@ bool Connection::AddNewService(uint8_t session_id, LOG4CXX_WARN(logger_, "Session not found in this connection!"); return false; } - Session &session = session_it->second; - Service *service = session.FindService(service_type); + Session& session = session_it->second; + Service* service = session.FindService(service_type); // if service already exists if (service) { #ifdef ENABLE_SECURITY - if(!request_protection) { - LOG4CXX_WARN(logger_, "Session " << static_cast<int>(session_id) << - " already has unprotected service "<< static_cast<int>(service_type)); + if (!request_protection) { + LOG4CXX_WARN(logger_, + "Session " << static_cast<int>(session_id) + << " already has unprotected service " + << static_cast<int>(service_type)); return false; } if (service->is_protected_) { - LOG4CXX_WARN(logger_, "Session " << static_cast<int>(session_id) << - " already has protected service "<< static_cast<int>(service_type)); + LOG4CXX_WARN(logger_, + "Session " << static_cast<int>(session_id) + << " already has protected service " + << static_cast<int>(service_type)); return false; } // For unproteced service could be start protection @@ -187,18 +192,18 @@ inline bool is_incorrect_for_remove_service( // Control type is internal part of session protocol_handler::kControl == service_type || // RPC and bulk service is necessary part of session - protocol_handler::kRpc == service_type || + protocol_handler::kRpc == service_type || protocol_handler::kBulk == service_type || // Invalid service is not part of session protocol_handler::kInvalidServiceType == service_type; } -bool Connection::RemoveService( - uint8_t session_id, protocol_handler::ServiceType service_type) { +bool Connection::RemoveService(uint8_t session_id, + protocol_handler::ServiceType service_type) { // Ignore wrong and required for Session services if (is_incorrect_for_remove_service(service_type)) { - LOG4CXX_WARN(logger_, "Could not remove service " - << static_cast<int>(service_type)); + LOG4CXX_WARN(logger_, + "Could not remove service " << static_cast<int>(service_type)); return false; } sync_primitives::AutoLock lock(session_map_lock_); @@ -209,12 +214,13 @@ bool Connection::RemoveService( return false; } - ServiceList &service_list = session_it->second.service_list; + ServiceList& service_list = session_it->second.service_list; ServiceList::iterator service_it = find(service_list.begin(), service_list.end(), service_type); if (service_list.end() == service_it) { - LOG4CXX_WARN(logger_, "Session " << session_id << " didn't established" - " service " << service_type); + LOG4CXX_WARN(logger_, + "Session " << session_id << " didn't established" + " service " << service_type); return false; } service_list.erase(service_it); @@ -223,20 +229,21 @@ bool Connection::RemoveService( #ifdef ENABLE_SECURITY int Connection::SetSSLContext(uint8_t session_id, - security_manager::SSLContext *context) { + security_manager::SSLContext* context) { sync_primitives::AutoLock lock(session_map_lock_); SessionMap::iterator session_it = session_map_.find(session_id); if (session_it == session_map_.end()) { LOG4CXX_WARN(logger_, "Session not found in this connection!"); return security_manager::SecurityManager::ERROR_INTERNAL; } - Session &session = session_it->second; + Session& session = session_it->second; session.ssl_context = context; return security_manager::SecurityManager::ERROR_SUCCESS; } -security_manager::SSLContext *Connection::GetSSLContext( - const uint8_t session_id, const protocol_handler::ServiceType &service_type) const { +security_manager::SSLContext* Connection::GetSSLContext( + const uint8_t session_id, + const protocol_handler::ServiceType& service_type) const { LOG4CXX_AUTO_TRACE(logger_); sync_primitives::AutoLock lock(session_map_lock_); SessionMap::const_iterator session_it = session_map_.find(session_id); @@ -244,11 +251,11 @@ security_manager::SSLContext *Connection::GetSSLContext( LOG4CXX_WARN(logger_, "Session not found in this connection!"); return NULL; } - const Session &session = session_it->second; + const Session& session = session_it->second; // for control services return current SSLContext value if (protocol_handler::kControl == service_type) return session.ssl_context; - const Service *service = session.FindService(service_type); + const Service* service = session.FindService(service_type); if (!service) { LOG4CXX_WARN(logger_, "Service not found in this session!"); return NULL; @@ -260,7 +267,8 @@ security_manager::SSLContext *Connection::GetSSLContext( } void Connection::SetProtectionFlag( - const uint8_t session_id, const protocol_handler::ServiceType &service_type) { + const uint8_t session_id, + const protocol_handler::ServiceType& service_type) { LOG4CXX_AUTO_TRACE(logger_); sync_primitives::AutoLock lock(session_map_lock_); SessionMap::iterator session_it = session_map_.find(session_id); @@ -268,8 +276,8 @@ void Connection::SetProtectionFlag( LOG4CXX_WARN(logger_, "Session not found in this connection!"); return; } - Session &session = session_it->second; - Service *service = session.FindService(service_type); + Session& session = session_it->second; + Service* service = session.FindService(service_type); if (!service) { LOG4CXX_WARN(logger_, "Service not found in this session!"); return; @@ -277,11 +285,11 @@ void Connection::SetProtectionFlag( service->is_protected_ = true; // Rpc and bulk shall be protected as one service if (service->service_type == protocol_handler::kRpc) { - Service *service_bulk = session.FindService(protocol_handler::kBulk); + Service* service_bulk = session.FindService(protocol_handler::kBulk); DCHECK(service_bulk); service_bulk->is_protected_ = true; } else if (service->service_type == protocol_handler::kBulk) { - Service *service_rpc = session.FindService(protocol_handler::kRpc); + Service* service_rpc = session.FindService(protocol_handler::kRpc); DCHECK(service_rpc); service_rpc->is_protected_ = true; } @@ -292,7 +300,7 @@ ConnectionHandle Connection::connection_handle() const { return connection_handle_; } -DeviceHandle Connection::connection_device_handle() { +DeviceHandle Connection::connection_device_handle() const { return connection_device_handle_; } @@ -313,25 +321,24 @@ void Connection::CloseSession(uint8_t session_id) { size = session_map_.size(); } - connection_handler_->CloseSession(connection_handle_, - session_id, - connection_handler::kCommon); + connection_handler_->CloseSession( + connection_handle_, session_id, connection_handler::kCommon); - //Close connection if it is last session + // Close connection if it is last session if (1 == size) { connection_handler_->CloseConnection(connection_handle_); } } -void Connection::UpdateProtocolVersionSession( - uint8_t session_id, uint8_t protocol_version) { +void Connection::UpdateProtocolVersionSession(uint8_t session_id, + uint8_t protocol_version) { sync_primitives::AutoLock lock(session_map_lock_); SessionMap::iterator session_it = session_map_.find(session_id); if (session_map_.end() == session_it) { LOG4CXX_WARN(logger_, "Session not found in this connection!"); return; } - Session &session = session_it->second; + Session& session = session_it->second; session.protocol_version = protocol_version; } @@ -343,20 +350,21 @@ bool Connection::SupportHeartBeat(uint8_t session_id) { LOG4CXX_WARN(logger_, "Session not found in this connection!"); return false; } - Session &session = session_it->second; - - return ((::protocol_handler::PROTOCOL_VERSION_3 == session.protocol_version || - ::protocol_handler::PROTOCOL_VERSION_4 == session.protocol_version) && - (profile::Profile::instance()->heart_beat_timeout())); + Session& session = session_it->second; + return ( + (::protocol_handler::PROTOCOL_VERSION_3 == session.protocol_version || + ::protocol_handler::PROTOCOL_VERSION_4 == session.protocol_version) && + (0 != heartbeat_timeout_)); } -bool Connection::ProtocolVersion(uint8_t session_id, uint8_t& protocol_version) { +bool Connection::ProtocolVersion(uint8_t session_id, + uint8_t& protocol_version) { LOG4CXX_AUTO_TRACE(logger_); sync_primitives::AutoLock lock(session_map_lock_); SessionMap::iterator session_it = session_map_.find(session_id); if (session_map_.end() == session_it) { LOG4CXX_WARN(logger_, "Session not found in this connection!"); - return false; + return false; } protocol_version = (session_it->second).protocol_version; return true; @@ -374,8 +382,8 @@ void Connection::KeepAlive(uint8_t session_id) { heartbeat_monitor_->KeepAlive(session_id); } -void Connection::SetHeartBeatTimeout(int32_t timeout, uint8_t session_id) { - heartbeat_monitor_->set_heartbeat_timeout_seconds(timeout, session_id); +void Connection::SetHeartBeatTimeout(uint32_t timeout, uint8_t session_id) { + heartbeat_monitor_->set_heartbeat_timeout_milliseconds(timeout, session_id); } } // namespace connection_handler diff --git a/src/components/connection_handler/src/connection_handler_impl.cc b/src/components/connection_handler/src/connection_handler_impl.cc index 0fdb0c68bf..d8c05e6e6e 100644 --- a/src/components/connection_handler/src/connection_handler_impl.cc +++ b/src/components/connection_handler/src/connection_handler_impl.cc @@ -38,18 +38,11 @@ #include "connection_handler/connection_handler_impl.h" #include "transport_manager/info.h" -#include "config_profile/profile.h" #ifdef ENABLE_SECURITY #include "security_manager/security_manager.h" #endif // ENABLE_SECURITY -namespace { -int32_t HeartBeatTimeout() { - return profile::Profile::instance()->heart_beat_timeout(); -} -} // namespace - /** * \namespace connection_handler * \brief SmartDeviceLink ConnectionHandler namespace. @@ -67,14 +60,16 @@ transport_manager::ConnectionUID ConnectionUIDFromHandle( return transport_manager::ConnectionUID(handle); } -ConnectionHandlerImpl::ConnectionHandlerImpl() - : connection_handler_observer_(NULL), - transport_manager_(NULL), - protocol_handler_(NULL), - connection_list_lock_(true), - connection_handler_observer_lock_(), - connection_list_deleter_(&connection_list_) { -} +ConnectionHandlerImpl::ConnectionHandlerImpl( + const ConnectionHandlerSettings& settings, + transport_manager::TransportManager& tm) + : settings_(settings) + , connection_handler_observer_(NULL) + , transport_manager_(tm) + , protocol_handler_(NULL) + , connection_list_lock_() + , connection_handler_observer_lock_() + , connection_list_deleter_(&connection_list_) {} ConnectionHandlerImpl::~ConnectionHandlerImpl() { LOG4CXX_AUTO_TRACE(logger_); @@ -90,9 +85,10 @@ void ConnectionHandlerImpl::Stop() { } void ConnectionHandlerImpl::set_connection_handler_observer( - ConnectionHandlerObserver *observer) { - LOG4CXX_DEBUG(logger_, "ConnectionHandlerImpl::set_connection_handler_observer() " - << observer); + ConnectionHandlerObserver* observer) { + LOG4CXX_DEBUG(logger_, + "ConnectionHandlerImpl::set_connection_handler_observer() " + << observer); sync_primitives::AutoWriteLock write_lock(connection_handler_observer_lock_); if (!observer) { LOG4CXX_WARN(logger_, "Set Null pointer to observer."); @@ -100,21 +96,11 @@ void ConnectionHandlerImpl::set_connection_handler_observer( connection_handler_observer_ = observer; } -void ConnectionHandlerImpl::set_transport_manager( - transport_manager::TransportManager *transport_mngr) { - LOG4CXX_DEBUG(logger_, "ConnectionHandlerImpl::set_transport_manager() " - << transport_mngr); - if (!transport_mngr) { - LOG4CXX_ERROR(logger_, "Null pointer to TransportManager."); - return; - } - transport_manager_ = transport_mngr; -} - void ConnectionHandlerImpl::set_protocol_handler( - protocol_handler::ProtocolHandler *protocol_handler) { - LOG4CXX_DEBUG(logger_, "ConnectionHandlerImpl::set_protocol_handler()" - << protocol_handler); + protocol_handler::ProtocolHandler* protocol_handler) { + LOG4CXX_DEBUG(logger_, + "ConnectionHandlerImpl::set_protocol_handler()" + << protocol_handler); if (!protocol_handler) { LOG4CXX_WARN(logger_, "Set Null pointer to protocol handler."); } @@ -143,13 +129,14 @@ void ConnectionHandlerImpl::OnDeviceFound( } void ConnectionHandlerImpl::OnDeviceAdded( - const transport_manager::DeviceInfo &device_info) { + const transport_manager::DeviceInfo& device_info) { 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()))); + 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::AutoReadLock read_lock(connection_handler_observer_lock_); if (connection_handler_observer_) { connection_handler_observer_->OnDeviceListUpdated(device_list_); @@ -157,7 +144,7 @@ void ConnectionHandlerImpl::OnDeviceAdded( } void ConnectionHandlerImpl::OnDeviceRemoved( - const transport_manager::DeviceInfo &device_info) { + const transport_manager::DeviceInfo& device_info) { LOG4CXX_AUTO_TRACE(logger_); // Device has been removed. Perform all needed actions. // 1. Delete all the connections and sessions of this device @@ -166,9 +153,10 @@ void ConnectionHandlerImpl::OnDeviceRemoved( std::vector<ConnectionHandle> connections_to_remove; { - sync_primitives::AutoLock lock(connection_list_lock_); + sync_primitives::AutoReadLock lock(connection_list_lock_); for (ConnectionList::iterator it = connection_list_.begin(); - it != connection_list_.end(); ++it) { + it != connection_list_.end(); + ++it) { if (device_info.device_handle() == (*it).second->connection_device_handle()) { connections_to_remove.push_back((*it).first); @@ -185,7 +173,6 @@ void ConnectionHandlerImpl::OnDeviceRemoved( sync_primitives::AutoReadLock read_lock(connection_handler_observer_lock_); if (connection_handler_observer_) { connection_handler_observer_->RemoveDevice(device_info.device_handle()); - connection_handler_observer_->OnDeviceListUpdated(device_list_); } } @@ -194,13 +181,13 @@ void ConnectionHandlerImpl::OnScanDevicesFinished() { } void ConnectionHandlerImpl::OnScanDevicesFailed( - const transport_manager::SearchDeviceError &error) { + const transport_manager::SearchDeviceError& error) { LOG4CXX_WARN(logger_, "Scan devices failed. " << error.text()); } void ConnectionHandlerImpl::OnConnectionEstablished( - const transport_manager::DeviceInfo &device_info, - const transport_manager::ConnectionUID &connection_id) { + const transport_manager::DeviceInfo& device_info, + const transport_manager::ConnectionUID connection_id) { LOG4CXX_AUTO_TRACE(logger_); DeviceMap::iterator it = device_list_.find(device_info.device_handle()); @@ -208,18 +195,20 @@ void ConnectionHandlerImpl::OnConnectionEstablished( LOG4CXX_ERROR(logger_, "Unknown device!"); return; } - LOG4CXX_DEBUG(logger_, "Add Connection #" << connection_id << " to the list."); - sync_primitives::AutoLock lock(connection_list_lock_); - connection_list_.insert( - ConnectionList::value_type( - connection_id, - new Connection(connection_id, device_info.device_handle(), this, - HeartBeatTimeout()))); + LOG4CXX_DEBUG(logger_, + "Add Connection #" << connection_id << " to the list."); + sync_primitives::AutoWriteLock lock(connection_list_lock_); + connection_list_.insert(ConnectionList::value_type( + connection_id, + new Connection(connection_id, + device_info.device_handle(), + this, + get_settings().heart_beat_timeout()))); } void ConnectionHandlerImpl::OnConnectionFailed( - const transport_manager::DeviceInfo &device_info, - const transport_manager::ConnectError &error) { + const transport_manager::DeviceInfo& device_info, + const transport_manager::ConnectError& error) { // TODO(PV): implement LOG4CXX_ERROR(logger_, "Failed connecting."); } @@ -233,87 +222,79 @@ void ConnectionHandlerImpl::OnConnectionClosed( void ConnectionHandlerImpl::OnConnectionClosedFailure( transport_manager::ConnectionUID connection_id, - const transport_manager::DisconnectError &error) { + const transport_manager::DisconnectError& error) { // TODO(PV): implement LOG4CXX_ERROR(logger_, "ConnectionHandlerImpl::OnConnectionClosedFailure"); } void ConnectionHandlerImpl::OnUnexpectedDisconnect( transport_manager::ConnectionUID connection_id, - const transport_manager::CommunicationError &error) { - LOG4CXX_ERROR(logger_, "ConnectionHandlerImpl::OnUnexpectedDisconnect"); + const transport_manager::CommunicationError& error) { + LOG4CXX_AUTO_TRACE(logger_); OnConnectionEnded(connection_id); } void ConnectionHandlerImpl::OnDeviceConnectionLost( - const transport_manager::DeviceHandle &device, - const transport_manager::DisconnectDeviceError &error) { + const transport_manager::DeviceHandle& device, + const transport_manager::DisconnectDeviceError& error) { // TODO(PV): implement LOG4CXX_ERROR(logger_, "Lost connection with device " << device); } void ConnectionHandlerImpl::OnDisconnectFailed( - const transport_manager::DeviceHandle &device, - const transport_manager::DisconnectDeviceError &error) { + const transport_manager::DeviceHandle& device, + const transport_manager::DisconnectDeviceError& error) { // TODO(PV): implement LOG4CXX_ERROR(logger_, "Trying to Disconnect device failed."); } void ConnectionHandlerImpl::RemoveConnection( const ConnectionHandle connection_handle) { - LOG4CXX_INFO(logger_, "ConnectionHandlerImpl::RemoveConnection()"); + LOG4CXX_AUTO_TRACE(logger_); OnConnectionEnded(connection_handle); } #ifdef ENABLE_SECURITY -namespace { -bool AllowProtection(const protocol_handler::ServiceType &service_type, - const bool is_protected) { - if (is_protected) { - // Check deliver-specific services (which shall not be protected) - const std::list<int> force_unprotected_list = - profile::Profile::instance()->ReadIntContainer( - "Security Manager", "ForceUnprotectedService", NULL); - if (std::find(force_unprotected_list.begin(), force_unprotected_list.end(), service_type) != - force_unprotected_list.end()) { - LOG4CXX_ERROR(logger_, "Service " << static_cast<int>(service_type) - << " is forbidden to be protected"); - return false; - } - } else { - // Check deliver-specific services (which shall be protected) - const std::list<int> force_protected_list = - profile::Profile::instance()->ReadIntContainer( - "Security Manager", "ForceProtectedService", NULL); - if (std::find(force_protected_list.begin(), force_protected_list.end(), service_type) != - force_protected_list.end()) { - LOG4CXX_ERROR(logger_, "Service " << static_cast<int>(service_type) - << " shall be protected"); - return false; - } +bool AllowProtection(const ConnectionHandlerSettings& settings, + const protocol_handler::ServiceType& service_type, + const bool is_protected) { + const std::vector<int>& force_unprotected_list = + is_protected ? settings.force_unprotected_service() + : settings.force_protected_service(); + + if (std::find(force_unprotected_list.begin(), + force_unprotected_list.end(), + service_type) != force_unprotected_list.end()) { + LOG4CXX_ERROR(logger_, + "Service " << static_cast<int>(service_type) + << " shall be protected"); + return false; } + LOG4CXX_DEBUG(logger_, + "Service " << static_cast<int>(service_type) << " allowed"); return true; } -} // namespace #endif // ENABLE_SECURITY 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) { + 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_AUTO_TRACE(logger_); if (hash_id) { *hash_id = protocol_handler::HASH_ID_WRONG; } #ifdef ENABLE_SECURITY - if (!AllowProtection(service_type, is_protected)) { + if (!AllowProtection(get_settings(), service_type, is_protected)) { return 0; } #endif // ENABLE_SECURITY - sync_primitives::AutoLock lock(connection_list_lock_); + sync_primitives::AutoReadLock lock(connection_list_lock_); ConnectionList::iterator it = connection_list_.find(connection_handle); if (connection_list_.end() == it) { LOG4CXX_ERROR(logger_, "Unknown connection!"); @@ -321,7 +302,7 @@ uint32_t ConnectionHandlerImpl::OnSessionStartedCallback( } uint32_t new_session_id = 0; - Connection *connection = it->second; + Connection* connection = it->second; if ((0 == session_id) && (protocol_handler::kRpc == service_type)) { new_session_id = connection->AddNewSession(); if (0 == new_session_id) { @@ -333,12 +314,13 @@ uint32_t ConnectionHandlerImpl::OnSessionStartedCallback( } } else { // Could be create new service or protected exists one if (!connection->AddNewService(session_id, service_type, is_protected)) { - LOG4CXX_ERROR(logger_, "Couldn't establish " + LOG4CXX_ERROR(logger_, + "Couldn't establish " #ifdef ENABLE_SECURITY - << (is_protected ? "protected" : "non-protected") + << (is_protected ? "protected" : "non-protected") #endif // ENABLE_SECURITY - << " service " << static_cast<int>(service_type) - << " for session " << static_cast<int>(session_id)); + << " service " << static_cast<int>(service_type) + << " for session " << static_cast<int>(session_id)); return 0; } new_session_id = session_id; @@ -350,8 +332,10 @@ uint32_t ConnectionHandlerImpl::OnSessionStartedCallback( 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) { + LOG4CXX_WARN(logger_, + "Service starting forbidden by connection_handler_observer"); if (protocol_handler::kRpc == service_type) { connection->RemoveSession(new_session_id); } else { @@ -364,7 +348,7 @@ uint32_t ConnectionHandlerImpl::OnSessionStartedCallback( } void ConnectionHandlerImpl::OnApplicationFloodCallBack( - const uint32_t &connection_key) { + const uint32_t& connection_key) { LOG4CXX_AUTO_TRACE(logger_); transport_manager::ConnectionUID connection_handle = 0; @@ -381,7 +365,7 @@ void ConnectionHandlerImpl::OnApplicationFloodCallBack( } void ConnectionHandlerImpl::OnMalformedMessageCallback( - const uint32_t &connection_key) { + const uint32_t& connection_key) { LOG4CXX_AUTO_TRACE(logger_); transport_manager::ConnectionUID connection_handle = 0; @@ -389,17 +373,18 @@ void ConnectionHandlerImpl::OnMalformedMessageCallback( PairFromKey(connection_key, &connection_handle, &session_id); LOG4CXX_INFO(logger_, "Disconnect malformed messaging application"); - CloseConnectionSessions(connection_handle, kCommon); + CloseConnectionSessions(connection_handle, kMalformed); 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) { + const transport_manager::ConnectionUID connection_handle, + const uint8_t session_id, + const uint32_t& hashCode, + const protocol_handler::ServiceType& service_type) { LOG4CXX_AUTO_TRACE(logger_); - connection_list_lock_.Acquire(); + connection_list_lock_.AcquireForReading(); ConnectionList::iterator it = connection_list_.find(connection_handle); if (connection_list_.end() == it) { LOG4CXX_WARN(logger_, "Unknown connection!"); @@ -408,32 +393,37 @@ uint32_t ConnectionHandlerImpl::OnSessionEndedCallback( std::pair<int32_t, Connection*> connection_item = *it; connection_list_lock_.Release(); - Connection *connection = connection_item.second; + Connection* connection = connection_item.second; const uint32_t session_key = KeyFromPair(connection_handle, session_id); if (protocol_handler::kRpc == service_type) { - LOG4CXX_INFO(logger_, "Session " << static_cast<uint32_t>(session_id) - << " to be removed"); + LOG4CXX_INFO(logger_, + "Session " << static_cast<uint32_t>(session_id) + << " to be removed"); // old version of protocol doesn't support hash if (protocol_handler::HASH_ID_NOT_SUPPORTED != hashCode) { if (protocol_handler::HASH_ID_WRONG == hashCode || session_key != hashCode) { - LOG4CXX_WARN(logger_, "Wrong hash_id for session " - << static_cast<uint32_t>(session_id)); + LOG4CXX_WARN(logger_, + "Wrong hash_id for session " + << static_cast<uint32_t>(session_id)); return 0; } } if (!connection->RemoveSession(session_id)) { - LOG4CXX_WARN(logger_, "Couldn't remove session " - << static_cast<uint32_t>(session_id)); + LOG4CXX_WARN(logger_, + "Couldn't remove session " + << static_cast<uint32_t>(session_id)); return 0; } } else { - LOG4CXX_INFO(logger_, "Service " << static_cast<uint32_t>(service_type) - << " to be removed"); + LOG4CXX_INFO(logger_, + "Service " << static_cast<uint32_t>(service_type) + << " to be removed"); if (!connection->RemoveService(session_id, service_type)) { - LOG4CXX_WARN(logger_, "Couldn't remove service " - << static_cast<uint32_t>(service_type)); + LOG4CXX_WARN(logger_, + "Couldn't remove service " + << static_cast<uint32_t>(service_type)); return 0; } } @@ -447,100 +437,110 @@ uint32_t ConnectionHandlerImpl::OnSessionEndedCallback( } uint32_t ConnectionHandlerImpl::KeyFromPair( - transport_manager::ConnectionUID connection_handle, uint8_t session_id) { + transport_manager::ConnectionUID connection_handle, + uint8_t session_id) const { const uint32_t key = connection_handle | (session_id << 16); - 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)); + 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)); if (protocol_handler::HASH_ID_WRONG == key) { - LOG4CXX_ERROR(logger_, "Connection key is WRONG_HASH_ID " + LOG4CXX_ERROR(logger_, + "Connection key is WRONG_HASH_ID " "(session id shall be greater 0)"); } return key; } -void ConnectionHandlerImpl::PairFromKey(uint32_t key, - uint32_t *connection_handle, - uint8_t *session_id) { +void ConnectionHandlerImpl::PairFromKey( + uint32_t key, + transport_manager::ConnectionUID* connection_handle, + uint8_t* session_id) const { *connection_handle = key & 0xFF00FFFF; *session_id = key >> 16; - LOG4CXX_DEBUG(logger_, "ConnectionHandle:" - << static_cast<int32_t>(*connection_handle) - << " Session:" << static_cast<int32_t>(*session_id) - << " for key:" << static_cast<int32_t>(key)); + LOG4CXX_DEBUG( + logger_, + "ConnectionHandle:" << static_cast<int32_t>(*connection_handle) + << " Session:" << static_cast<int32_t>(*session_id) + << " for key:" << static_cast<int32_t>(key)); } int32_t ConnectionHandlerImpl::GetDataOnSessionKey( - uint32_t key, uint32_t *app_id, std::list<int32_t> *sessions_list, - uint32_t *device_id) { + uint32_t key, + uint32_t* app_id, + std::list<int32_t>* sessions_list, + uint32_t* device_id) const { LOG4CXX_AUTO_TRACE(logger_); - int32_t result = -1; + const int32_t error_result = -1; transport_manager::ConnectionUID conn_handle = 0; uint8_t session_id = 0; PairFromKey(key, &conn_handle, &session_id); - ConnectionList::iterator it = connection_list_.find(conn_handle); + ConnectionList::const_iterator it = connection_list_.find(conn_handle); if (connection_list_.end() == it) { - LOG4CXX_ERROR(logger_, "Unknown connection!"); - return result; + LOG4CXX_ERROR(logger_, "Connection not found for key: " << key); + return error_result; + } + + const Connection& connection = *it->second; + const SessionMap session_map = connection.session_map(); + if (0 == session_id || session_map.end() == session_map.find(session_id)) { + LOG4CXX_ERROR(logger_, + "Session not found in connection: " + << static_cast<int32_t>(conn_handle)); + return error_result; } - Connection &connection = *it->second; if (device_id) { *device_id = connection.connection_device_handle(); } - + if (app_id) { + *app_id = KeyFromPair(conn_handle, session_id); + } if (sessions_list) { sessions_list->clear(); - } - if (0 == session_id) { - LOG4CXX_WARN( - logger_, - "No sessions in connection " << static_cast<int32_t>(conn_handle)); - if (app_id) { - *app_id = 0; - } - } else { - if (app_id) { - *app_id = KeyFromPair(conn_handle, session_id); + SessionMap::const_iterator session_it = session_map.begin(); + for (; session_map.end() != session_it; ++session_it) { + sessions_list->push_back(KeyFromPair(conn_handle, it->first)); } + } - LOG4CXX_INFO(logger_, "Connection " - << static_cast<int32_t>(conn_handle) - << " has " << connection.session_map().size() - << " sessions."); + LOG4CXX_INFO(logger_, + "Connection " << static_cast<int32_t>(conn_handle) << " has " + << session_map.size() << " sessions."); + return 0; +} - if (sessions_list) { - const SessionMap session_map = connection.session_map(); - for (SessionMap::const_iterator session_it = session_map.begin(); - session_map.end() != session_it; ++session_it) { - sessions_list->push_back(KeyFromPair(conn_handle, it->first)); - } - } +const ConnectionHandlerSettings& ConnectionHandlerImpl::get_settings() const { + return settings_; +} - result = 0; - } +const protocol_handler::SessionObserver& +ConnectionHandlerImpl::get_session_observer() { + return *this; +} - return result; +DevicesDiscoveryStarter& ConnectionHandlerImpl::get_device_discovery_starter() { + return *this; } struct CompareMAC { - explicit CompareMAC(const std::string &mac) : mac_(mac) {} - bool operator() (const DeviceMap::value_type &device) { + explicit CompareMAC(const std::string& mac) : mac_(mac) {} + bool operator()(const DeviceMap::value_type& device) { return strcasecmp(device.second.mac_address().c_str(), mac_.c_str()) == 0; } + private: std::string mac_; }; -bool ConnectionHandlerImpl::GetDeviceID(const std::string &mac_address, - DeviceHandle *device_handle) { - DeviceMap::const_iterator it = std::find_if(device_list_.begin(), - device_list_.end(), - CompareMAC(mac_address)); +bool ConnectionHandlerImpl::GetDeviceID(const std::string& mac_address, + DeviceHandle* device_handle) { + DeviceMap::const_iterator it = std::find_if( + device_list_.begin(), device_list_.end(), CompareMAC(mac_address)); if (it != device_list_.end()) { if (device_handle) { *device_handle = it->first; @@ -552,13 +552,14 @@ bool ConnectionHandlerImpl::GetDeviceID(const std::string &mac_address, int32_t ConnectionHandlerImpl::GetDataOnDeviceID( DeviceHandle device_handle, - std::string *device_name, - std::list<uint32_t> *applications_list, std::string *mac_address, - std::string* connection_type ) { + std::string* device_name, + std::list<uint32_t>* applications_list, + std::string* mac_address, + std::string* connection_type) const { LOG4CXX_AUTO_TRACE(logger_); int32_t result = -1; - DeviceMap::iterator it = device_list_.find(device_handle); + DeviceMap::const_iterator it = device_list_.find(device_handle); if (device_list_.end() == it) { LOG4CXX_ERROR(logger_, "Device not found!"); return result; @@ -572,16 +573,19 @@ int32_t ConnectionHandlerImpl::GetDataOnDeviceID( } if (applications_list) { applications_list->clear(); - sync_primitives::AutoLock connection_list_lock(connection_list_lock_); - for (ConnectionList::iterator itr = connection_list_.begin(); - itr != connection_list_.end(); ++itr) { + sync_primitives::AutoReadLock connection_list_lock(connection_list_lock_); + for (ConnectionList::const_iterator itr = connection_list_.begin(); + itr != connection_list_.end(); + ++itr) { if (device_handle == (*itr).second->connection_device_handle()) { - const SessionMap &session_map = (itr->second)->session_map(); + const SessionMap& session_map = (itr->second)->session_map(); for (SessionMap::const_iterator session_it = session_map.begin(); - session_map.end() != session_it; ++session_it) { - const transport_manager::ConnectionUID &connection_handle = itr->first; + session_map.end() != session_it; + ++session_it) { + const transport_manager::ConnectionUID connection_handle = itr->first; const uint32_t session_id = session_it->first; - const uint32_t application_id = KeyFromPair(connection_handle, session_id); + const uint32_t application_id = + KeyFromPair(connection_handle, session_id); applications_list->push_back(application_id); } } @@ -596,67 +600,80 @@ int32_t ConnectionHandlerImpl::GetDataOnDeviceID( return result; } + +void ConnectionHandlerImpl::GetConnectedDevicesMAC( + std::vector<std::string>& device_macs) const { + DeviceMap::const_iterator first = device_list_.begin(); + DeviceMap::const_iterator last = device_list_.end(); + + while (first != last) { + device_macs.push_back((*first).second.mac_address()); + ++first; + } +} + #ifdef ENABLE_SECURITY int ConnectionHandlerImpl::SetSSLContext( - const uint32_t &key, security_manager::SSLContext *context) { + const uint32_t& key, security_manager::SSLContext* context) { LOG4CXX_AUTO_TRACE(logger_); transport_manager::ConnectionUID connection_handle = 0; uint8_t session_id = 0; PairFromKey(key, &connection_handle, &session_id); - sync_primitives::AutoLock lock(connection_list_lock_); + sync_primitives::AutoReadLock lock(connection_list_lock_); ConnectionList::iterator it = connection_list_.find(connection_handle); if (connection_list_.end() == it) { LOG4CXX_ERROR(logger_, "Unknown connection!"); return security_manager::SecurityManager::ERROR_INTERNAL; } - Connection &connection = *it->second; + Connection& connection = *it->second; return connection.SetSSLContext(session_id, context); } -security_manager::SSLContext *ConnectionHandlerImpl::GetSSLContext( - const uint32_t &key, const protocol_handler::ServiceType &service_type) { +security_manager::SSLContext* ConnectionHandlerImpl::GetSSLContext( + const uint32_t& key, const protocol_handler::ServiceType& service_type) { LOG4CXX_AUTO_TRACE(logger_); transport_manager::ConnectionUID connection_handle = 0; uint8_t session_id = 0; PairFromKey(key, &connection_handle, &session_id); - sync_primitives::AutoLock lock(connection_list_lock_); + sync_primitives::AutoReadLock lock(connection_list_lock_); ConnectionList::iterator it = connection_list_.find(connection_handle); if (connection_list_.end() == it) { LOG4CXX_ERROR(logger_, "Unknown connection!"); return NULL; } - Connection &connection = *it->second; + Connection& connection = *it->second; return connection.GetSSLContext(session_id, service_type); } void ConnectionHandlerImpl::SetProtectionFlag( - const uint32_t &key, const protocol_handler::ServiceType &service_type) { + const uint32_t& key, const protocol_handler::ServiceType& service_type) { LOG4CXX_AUTO_TRACE(logger_); transport_manager::ConnectionUID connection_handle = 0; uint8_t session_id = 0; PairFromKey(key, &connection_handle, &session_id); - sync_primitives::AutoLock lock(connection_list_lock_); + sync_primitives::AutoReadLock lock(connection_list_lock_); ConnectionList::iterator it = connection_list_.find(connection_handle); if (connection_list_.end() == it) { LOG4CXX_ERROR(logger_, "Unknown connection!"); return; } - Connection &connection = *it->second; + Connection& connection = *it->second; connection.SetProtectionFlag(session_id, service_type); } + +security_manager::SSLContext::HandshakeContext +ConnectionHandlerImpl::GetHandshakeContext(uint32_t key) const { + return connection_handler_observer_->GetHandshakeContext(key); +} #endif // ENABLE_SECURITY void ConnectionHandlerImpl::StartDevicesDiscovery() { LOG4CXX_AUTO_TRACE(logger_); - if (NULL == transport_manager_) { - LOG4CXX_ERROR(logger_, "Null pointer to TransportManager."); - return; - } - transport_manager_->SearchDevices(); + transport_manager_.SearchDevices(); sync_primitives::AutoReadLock read_lock(connection_handler_observer_lock_); if (connection_handler_observer_) { connection_handler_observer_->OnDeviceListUpdated(device_list_); @@ -668,37 +685,29 @@ void ConnectionHandlerImpl::ConnectToDevice( connection_handler::DeviceMap::const_iterator it_in; it_in = device_list_.find(device_handle); if (device_list_.end() != it_in) { - LOG4CXX_INFO_EXT(logger_, - "Connecting to device with handle " << device_handle); - if (transport_manager_) { - if (transport_manager::E_SUCCESS - != transport_manager_->ConnectDevice(device_handle)) { - LOG4CXX_WARN(logger_, "Can't connect to device"); - } + LOG4CXX_INFO(logger_, "Connecting to device with handle " << device_handle); + if (transport_manager::E_SUCCESS != + transport_manager_.ConnectDevice(device_handle)) { + LOG4CXX_WARN(logger_, "Can't connect to device"); } else { - LOG4CXX_ERROR(logger_, "Null pointer to TransportManager."); + LOG4CXX_ERROR( + logger_, + "Application Manager wanted to connect to non-existing device"); } - } else { - LOG4CXX_ERROR( - logger_, "Application Manager wanted to connect to non-existing device"); } } void ConnectionHandlerImpl::ConnectToAllDevices() { - for (DeviceMap::iterator i = device_list_.begin(); i != device_list_.end(); ++i) { + for (DeviceMap::iterator i = device_list_.begin(); i != device_list_.end(); + ++i) { connection_handler::DeviceHandle device_handle = i->first; ConnectToDevice(device_handle); } } void ConnectionHandlerImpl::StartTransportManager() { - LOG4CXX_INFO(logger_, "ConnectionHandlerImpl::StartTransportManager()"); - if (NULL == transport_manager_) { - LOG4CXX_ERROR(logger_, "Null pointer to TransportManager."); - return; - } - - transport_manager_->Visibility(true); + LOG4CXX_AUTO_TRACE(logger_); + transport_manager_.Visibility(true); } void ConnectionHandlerImpl::CloseRevokedConnection(uint32_t connection_key) { @@ -714,15 +723,11 @@ void ConnectionHandlerImpl::CloseRevokedConnection(uint32_t connection_key) { void ConnectionHandlerImpl::CloseConnection( ConnectionHandle connection_handle) { LOG4CXX_AUTO_TRACE(logger_); - if (!transport_manager_) { - LOG4CXX_ERROR(logger_, "Null pointer to TransportManager."); - return; - } transport_manager::ConnectionUID connection_uid = ConnectionUIDFromHandle(connection_handle); - transport_manager_->DisconnectForce(connection_uid); + transport_manager_.DisconnectForce(connection_uid); - sync_primitives::AutoLock connection_list_lock(connection_list_lock_); + sync_primitives::AutoWriteLock connection_list_lock(connection_list_lock_); ConnectionList::iterator connection_list_itr = connection_list_.find(connection_uid); @@ -733,11 +738,12 @@ void ConnectionHandlerImpl::CloseConnection( uint32_t ConnectionHandlerImpl::GetConnectionSessionsCount( uint32_t connection_key) { + LOG4CXX_AUTO_TRACE(logger_); uint32_t connection_handle = 0; uint8_t session_id = 0; PairFromKey(connection_key, &connection_handle, &session_id); - sync_primitives::AutoLock lock(connection_list_lock_); + sync_primitives::AutoReadLock lock(connection_list_lock_); ConnectionList::iterator itr = connection_list_.find(connection_handle); if (connection_list_.end() != itr) { @@ -760,7 +766,8 @@ void ConnectionHandlerImpl::CloseSession(ConnectionHandle connection_handle, uint8_t session_id, CloseSessionReason close_reason) { LOG4CXX_AUTO_TRACE(logger_); - LOG4CXX_DEBUG(logger_, "Closing session with id: " << session_id); + LOG4CXX_DEBUG(logger_, + "Closing session with id: " << static_cast<int>(session_id)); // In case of malformed message the connection should be broke up without // any other notification to mobile. @@ -769,11 +776,11 @@ void ConnectionHandlerImpl::CloseSession(ConnectionHandle connection_handle, } transport_manager::ConnectionUID connection_id = - ConnectionUIDFromHandle(connection_handle); + ConnectionUIDFromHandle(connection_handle); SessionMap session_map; { - sync_primitives::AutoLock connection_list_lock(connection_list_lock_); + sync_primitives::AutoReadLock connection_list_lock(connection_list_lock_); ConnectionList::iterator connection_list_itr = connection_list_.find(connection_id); @@ -781,8 +788,8 @@ void ConnectionHandlerImpl::CloseSession(ConnectionHandle connection_handle, 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"); + LOG4CXX_ERROR(logger_, + "Connection with id: " << connection_id << " not found"); return; } } @@ -796,40 +803,42 @@ void ConnectionHandlerImpl::CloseSession(ConnectionHandle connection_handle, 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; + 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) { + ServiceList::const_reverse_iterator service_list_itr = + service_list.rbegin(); + for (; service_list_itr != service_list.rend(); ++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"); + LOG4CXX_ERROR(logger_, "Session with id: " << session_id << " not found"); return; } - LOG4CXX_DEBUG(logger_, "Session with id: " << session_id - << " has been closed successfully"); + + 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); + 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_); + sync_primitives::AutoReadLock connection_list_lock(connection_list_lock_); ConnectionList::iterator connection_list_itr = connection_list_.find(connection_id); @@ -837,41 +846,43 @@ void ConnectionHandlerImpl::CloseConnectionSessions( 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) { + 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"); + LOG4CXX_ERROR(logger_, + "Connection with id: " << connection_id << " not found"); return; } } SessionIdVector::const_iterator session_id_itr = session_id_vector.begin(); - for(;session_id_itr != session_id_vector.end(); ++session_id_itr) { + 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"); + 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) { +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); + protocol_handler_->SendEndService( + connection_handle, session_id, service_type); } } void ConnectionHandlerImpl::StartSessionHeartBeat(uint32_t connection_key) { + LOG4CXX_AUTO_TRACE(logger_); uint32_t connection_handle = 0; uint8_t session_id = 0; PairFromKey(connection_key, &connection_handle, &session_id); - sync_primitives::AutoLock lock(connection_list_lock_); + sync_primitives::AutoReadLock lock(connection_list_lock_); ConnectionList::iterator it = connection_list_.find(connection_handle); if (connection_list_.end() != it) { it->second->StartHeartBeat(session_id); @@ -879,11 +890,12 @@ void ConnectionHandlerImpl::StartSessionHeartBeat(uint32_t connection_key) { } void ConnectionHandlerImpl::SetHeartBeatTimeout(uint32_t connection_key, - int32_t timeout) { + uint32_t timeout) { + LOG4CXX_AUTO_TRACE(logger_); uint32_t connection_handle = 0; uint8_t session_id = 0; PairFromKey(connection_key, &connection_handle, &session_id); - sync_primitives::AutoLock lock(connection_list_lock_); + sync_primitives::AutoReadLock lock(connection_list_lock_); ConnectionList::iterator it = connection_list_.find(connection_handle); if (connection_list_.end() != it) { it->second->SetHeartBeatTimeout(timeout, session_id); @@ -901,8 +913,8 @@ void ConnectionHandlerImpl::SendHeartBeat(ConnectionHandle connection_handle, void ConnectionHandlerImpl::KeepConnectionAlive(uint32_t connection_key, uint8_t session_id) { - sync_primitives::AutoLock lock(connection_list_lock_); - + LOG4CXX_AUTO_TRACE(logger_); + sync_primitives::AutoReadLock lock(connection_list_lock_); ConnectionList::iterator it = connection_list_.find(connection_key); if (connection_list_.end() != it) { it->second->KeepAlive(session_id); @@ -910,11 +922,11 @@ void ConnectionHandlerImpl::KeepConnectionAlive(uint32_t connection_key, } void ConnectionHandlerImpl::OnConnectionEnded( - const transport_manager::ConnectionUID &connection_id) { - LOG4CXX_INFO(logger_, "Delete Connection: " << static_cast<int32_t>(connection_id) - << " from the list."); - - connection_list_lock_.Acquire(); + const transport_manager::ConnectionUID connection_id) { + LOG4CXX_INFO(logger_, + "Delete Connection: " << static_cast<int32_t>(connection_id) + << " from the list."); + connection_list_lock_.AcquireForWriting(); ConnectionList::iterator itr = connection_list_.find(connection_id); if (connection_list_.end() == itr) { LOG4CXX_ERROR(logger_, "Connection not found!"); @@ -929,11 +941,15 @@ void ConnectionHandlerImpl::OnConnectionEnded( const SessionMap session_map = connection->session_map(); for (SessionMap::const_iterator session_it = session_map.begin(); - session_map.end() != session_it; ++session_it) { - const uint32_t session_key = KeyFromPair(connection_id, session_it->first); - const ServiceList &service_list = session_it->second.service_list; - for (ServiceList::const_iterator service_it = service_list.begin(), end = - service_list.end(); service_it != end; ++service_it) { + session_map.end() != session_it; + ++session_it) { + const uint32_t session_key = + KeyFromPair(connection_id, session_it->first); + const ServiceList& service_list = session_it->second.service_list; + 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, CloseSessionReason::kCommon); } @@ -948,7 +964,7 @@ void ConnectionHandlerImpl::BindProtocolVersionWithSession( uint8_t session_id = 0; PairFromKey(connection_key, &connection_handle, &session_id); - sync_primitives::AutoLock lock(connection_list_lock_); + sync_primitives::AutoReadLock lock(connection_list_lock_); ConnectionList::iterator it = connection_list_.find(connection_handle); if (connection_list_.end() != it) { it->second->UpdateProtocolVersionSession(session_id, protocol_version); @@ -956,11 +972,12 @@ void ConnectionHandlerImpl::BindProtocolVersionWithSession( } bool ConnectionHandlerImpl::IsHeartBeatSupported( - transport_manager::ConnectionUID connection_handle,uint8_t session_id) { + transport_manager::ConnectionUID connection_handle, + uint8_t session_id) const { LOG4CXX_AUTO_TRACE(logger_); - sync_primitives::AutoLock lock(connection_list_lock_); + sync_primitives::AutoReadLock lock(connection_list_lock_); uint32_t connection = static_cast<uint32_t>(connection_handle); - ConnectionList::iterator it = connection_list_.find(connection); + ConnectionList::const_iterator it = connection_list_.find(connection); if (connection_list_.end() == it) { LOG4CXX_WARN(logger_, "Connection not found !"); return false; @@ -968,11 +985,13 @@ bool ConnectionHandlerImpl::IsHeartBeatSupported( return it->second->SupportHeartBeat(session_id); } -bool ConnectionHandlerImpl::ProtocolVersionUsed(uint32_t connection_id, - uint8_t session_id, uint8_t& protocol_version) { +bool ConnectionHandlerImpl::ProtocolVersionUsed( + uint32_t connection_id, + uint8_t session_id, + uint8_t& protocol_version) const { LOG4CXX_AUTO_TRACE(logger_); - sync_primitives::AutoLock lock(connection_list_lock_); - ConnectionList::iterator it = connection_list_.find(connection_id); + sync_primitives::AutoReadLock lock(connection_list_lock_); + ConnectionList::const_iterator it = connection_list_.find(connection_id); if (connection_list_.end() != it) { return it->second->ProtocolVersion(session_id, protocol_version); } @@ -981,13 +1000,17 @@ bool ConnectionHandlerImpl::ProtocolVersionUsed(uint32_t connection_id, } #ifdef BUILD_TESTS -ConnectionList &ConnectionHandlerImpl::getConnectionList() { +ConnectionList& ConnectionHandlerImpl::getConnectionList() { return connection_list_; } +const DeviceMap& ConnectionHandlerImpl::getDeviceList() { + return device_list_; +} + void ConnectionHandlerImpl::addDeviceConnection( - const transport_manager::DeviceInfo &device_info, - const transport_manager::ConnectionUID &connection_id) { + const transport_manager::DeviceInfo& device_info, + const transport_manager::ConnectionUID connection_id) { // Add Device OnDeviceAdded(device_info); // Add connection diff --git a/src/components/connection_handler/src/device.cc b/src/components/connection_handler/src/device.cc index 40a048654a..0ecb439172 100644 --- a/src/components/connection_handler/src/device.cc +++ b/src/components/connection_handler/src/device.cc @@ -46,23 +46,25 @@ namespace connection_handler { CREATE_LOGGERPTR_GLOBAL(logger_, "ConnectionHandler") Device::Device(DeviceHandle device_handle, - const std::string &user_friendly_name, - const std::string &mac_address, const std::string& connection_type) - : device_handle_(device_handle), - user_friendly_name_(user_friendly_name), - mac_address_(mac_address), - connection_type_(connection_type){ - LOG4CXX_INFO(logger_, "Device MAC address is: " << mac_address_); - mac_address_ = encryption::MakeHash(mac_address); - LOG4CXX_INFO(logger_, "Device MAC address hash is: " << mac_address_); + const std::string& user_friendly_name, + const std::string& mac_address, + const std::string& connection_type) + : device_handle_(device_handle) + , user_friendly_name_(user_friendly_name) + , mac_address_(mac_address) + , connection_type_(connection_type) { + mac_address_ = encryption::MakeHash(mac_address); + LOG4CXX_DEBUG(logger_, + "Device: MAC address - " << mac_address << ", hash - " + << mac_address_); } DeviceHandle Device::device_handle() const { - return device_handle_; + return device_handle_; } std::string Device::user_friendly_name() const { - return user_friendly_name_; + return user_friendly_name_; } std::string Device::mac_address() const { diff --git a/src/components/connection_handler/src/heartbeat_monitor.cc b/src/components/connection_handler/src/heartbeat_monitor.cc index 2349e0589f..f3a2322810 100644 --- a/src/components/connection_handler/src/heartbeat_monitor.cc +++ b/src/components/connection_handler/src/heartbeat_monitor.cc @@ -43,43 +43,46 @@ using namespace sync_primitives; CREATE_LOGGERPTR_GLOBAL(logger_, "HeartBeatMonitor") -HeartBeatMonitor::HeartBeatMonitor(int32_t heartbeat_timeout_seconds, - Connection *connection) - : default_heartbeat_timeout_(heartbeat_timeout_seconds), - connection_(connection), - sessions_list_lock_(true), - run_(true) { -} +HeartBeatMonitor::HeartBeatMonitor(uint32_t heartbeat_timeout_mseconds, + Connection* connection) + : default_heartbeat_timeout_(heartbeat_timeout_mseconds) + , connection_(connection) + , sessions_list_lock_(true) + , run_(true) {} void HeartBeatMonitor::Process() { - AutoLock auto_lock(sessions_list_lock_); - + sessions_list_lock_.Acquire(); SessionMap::iterator it = sessions_.begin(); while (it != sessions_.end()) { - SessionState &state = it->second; + SessionState& state = it->second; if (state.HasTimeoutElapsed()) { const uint8_t session_id = it->first; if (state.IsReadyToClose()) { LOG4CXX_WARN(logger_, "Will close session"); + sessions_list_lock_.Release(); + RemoveSession(session_id); connection_->CloseSession(session_id); + sessions_list_lock_.Acquire(); it = sessions_.begin(); continue; } else { LOG4CXX_DEBUG(logger_, - "Send heart beat into session with id " << static_cast<int32_t>(session_id)); + "Send heart beat into session with id " + << static_cast<int32_t>(session_id)); state.PrepareToClose(); connection_->SendHeartBeat(it->first); } } ++it; } + sessions_list_lock_.Release(); } void HeartBeatMonitor::threadMain() { AutoLock main_lock(main_thread_lock_); - LOG4CXX_DEBUG( - logger_, - "Start heart beat monitor. Timeout is " << default_heartbeat_timeout_); + LOG4CXX_DEBUG(logger_, + "Start heart beat monitor. Timeout is " + << default_heartbeat_timeout_); while (run_) { heartbeat_monitor_.WaitFor(main_lock, kDefaultCycleTimeout); Process(); @@ -87,45 +90,50 @@ void HeartBeatMonitor::threadMain() { } void HeartBeatMonitor::AddSession(uint8_t session_id) { - LOG4CXX_DEBUG(logger_, "Add session with id " << static_cast<int32_t>(session_id)); + LOG4CXX_DEBUG(logger_, + "Add session with id " << static_cast<int32_t>(session_id)); AutoLock auto_lock(sessions_list_lock_); if (sessions_.end() != sessions_.find(session_id)) { - LOG4CXX_WARN( - logger_, - "Session with id " << static_cast<int32_t>(session_id) << " already exists"); + LOG4CXX_WARN(logger_, + "Session with id " << static_cast<int32_t>(session_id) + << " already exists"); return; } - sessions_.insert(std::make_pair(session_id, - SessionState(default_heartbeat_timeout_))); + sessions_.insert( + std::make_pair(session_id, SessionState(default_heartbeat_timeout_))); LOG4CXX_INFO(logger_, "Start heartbeat for session " << session_id); } void HeartBeatMonitor::RemoveSession(uint8_t session_id) { + LOG4CXX_AUTO_TRACE(logger_); AutoLock auto_lock(sessions_list_lock_); LOG4CXX_DEBUG(logger_, - "Remove session with id " << static_cast<int>(session_id)); + "Remove session with id " << static_cast<int>(session_id)); if (sessions_.erase(session_id) == 0) { LOG4CXX_WARN(logger_, - "Remove session with id " << static_cast<int>(session_id) << - " was unsuccessful"); + "Remove session with id " << static_cast<int>(session_id) + << " was unsuccessful"); } } void HeartBeatMonitor::KeepAlive(uint8_t session_id) { + LOG4CXX_AUTO_TRACE(logger_); AutoLock auto_lock(sessions_list_lock_); if (sessions_.end() != sessions_.find(session_id)) { - LOG4CXX_INFO( logger_, "Resetting heart beat timer for session with id " << - static_cast<int32_t>(session_id)); + LOG4CXX_INFO(logger_, + "Resetting heart beat timer for session with id " + << static_cast<int32_t>(session_id)); sessions_[session_id].KeepAlive(); } } void HeartBeatMonitor::exitThreadMain() { - // FIXME (dchmerev@luxoft.com): thread requested to stop should stop as soon as possible, + // FIXME (dchmerev@luxoft.com): thread requested to stop should stop as soon + // as possible, // not running one more iteration before actual stop LOG4CXX_AUTO_TRACE(logger_); AutoLock main_lock(main_thread_lock_); @@ -133,10 +141,11 @@ void HeartBeatMonitor::exitThreadMain() { heartbeat_monitor_.NotifyOne(); } -void HeartBeatMonitor::set_heartbeat_timeout_seconds(int32_t timeout, - uint8_t session_id) { - LOG4CXX_DEBUG(logger_, "Set new heart beat timeout " << timeout << - "For session: " << session_id); +void HeartBeatMonitor::set_heartbeat_timeout_milliseconds(uint32_t timeout, + uint8_t session_id) { + LOG4CXX_DEBUG(logger_, + "Set new heart beat timeout " << timeout + << "For session: " << session_id); AutoLock session_locker(sessions_list_lock_); if (sessions_.end() != sessions_.find(session_id)) { @@ -144,46 +153,49 @@ void HeartBeatMonitor::set_heartbeat_timeout_seconds(int32_t timeout, } } -HeartBeatMonitor::SessionState::SessionState(int32_t heartbeat_timeout_seconds) - : heartbeat_timeout_seconds_(heartbeat_timeout_seconds), - is_heartbeat_sent(false) { +HeartBeatMonitor::SessionState::SessionState( + uint32_t heartbeat_timeout_mseconds) + : heartbeat_timeout_mseconds_(heartbeat_timeout_mseconds) + , is_heartbeat_sent_(false) { LOG4CXX_AUTO_TRACE(logger_); RefreshExpiration(); } -void HeartBeatMonitor::SessionState::RefreshExpiration () { - LOG4CXX_DEBUG(logger_, "Refresh expiration: " << heartbeat_timeout_seconds_); - heartbeat_expiration = date_time::DateTime::getCurrentTime(); - heartbeat_expiration.tv_sec += heartbeat_timeout_seconds_; +void HeartBeatMonitor::SessionState::RefreshExpiration() { + LOG4CXX_DEBUG(logger_, "Refresh expiration: " << heartbeat_timeout_mseconds_); + using namespace date_time; + TimevalStruct time = DateTime::getCurrentTime(); + DateTime::AddMilliseconds(time, heartbeat_timeout_mseconds_); + heartbeat_expiration_ = time; } void HeartBeatMonitor::SessionState::UpdateTimeout( - int32_t heartbeat_timeout_seconds) { - LOG4CXX_DEBUG(logger_, "Update timout with value " << - heartbeat_timeout_seconds_); - heartbeat_timeout_seconds_ = heartbeat_timeout_seconds; + uint32_t heartbeat_timeout_mseconds) { + LOG4CXX_DEBUG(logger_, + "Update timout with value " << heartbeat_timeout_mseconds_); + heartbeat_timeout_mseconds_ = heartbeat_timeout_mseconds; RefreshExpiration(); } void HeartBeatMonitor::SessionState::PrepareToClose() { - is_heartbeat_sent = true; + is_heartbeat_sent_ = true; LOG4CXX_DEBUG(logger_, "Prepare to close"); RefreshExpiration(); } bool HeartBeatMonitor::SessionState::IsReadyToClose() const { - return is_heartbeat_sent; + return is_heartbeat_sent_; } void HeartBeatMonitor::SessionState::KeepAlive() { - is_heartbeat_sent = false; - LOG4CXX_DEBUG(logger_, "keep alive"); + LOG4CXX_AUTO_TRACE(logger_); + is_heartbeat_sent_ = false; RefreshExpiration(); } bool HeartBeatMonitor::SessionState::HasTimeoutElapsed() { TimevalStruct now = date_time::DateTime::getCurrentTime(); - return date_time::DateTime::Greater(now, heartbeat_expiration); + return date_time::DateTime::Greater(now, heartbeat_expiration_); } } // namespace connection_handler diff --git a/src/components/connection_handler/test/CMakeLists.txt b/src/components/connection_handler/test/CMakeLists.txt index 7c0e1b2a98..32da4bdcd8 100644 --- a/src/components/connection_handler/test/CMakeLists.txt +++ b/src/components/connection_handler/test/CMakeLists.txt @@ -35,26 +35,22 @@ set(appMain_DIR ${CMAKE_SOURCE_DIR}/src/appMain) include_directories( ${GMOCK_INCLUDE_DIRECTORY} ${COMPONENTS_DIR}/connection_handler/include - ${COMPONENTS_DIR}/security_manager/test/include - ${COMPONENTS_DIR}/protocol_handler/test/include - ${COMPONENTS_DIR}/security_manager/include ${COMPONENTS_DIR}/connection_handler/test/include - ${COMPONENTS_DIR}/transport_manager/test/include + ${COMPONENTS_DIR}/resumption/include + ${JSONCPP_INCLUDE_DIRECTORY} ) set(LIBRARIES gmock connectionHandler - ConfigProfile ProtocolHandler - TransportManager ) set(SOURCES - #connection_handler_impl_test.cc + connection_handler_impl_test.cc connection_test.cc device_test.cc - #heart_beat_monitor_test.cc + heart_beat_monitor_test.cc ) file(COPY ${appMain_DIR}/smartDeviceLink.ini DESTINATION "./") diff --git a/src/components/connection_handler/test/connection_handler_impl_test.cc b/src/components/connection_handler/test/connection_handler_impl_test.cc index 94e4c816fa..3a8aaa70b4 100644 --- a/src/components/connection_handler/test/connection_handler_impl_test.cc +++ b/src/components/connection_handler/test/connection_handler_impl_test.cc @@ -30,38 +30,60 @@ * POSSIBILITY OF SUCH DAMAGE. */ -#include <gtest/gtest.h> +#include "gtest/gtest.h" #include <fstream> -#include <cstdint> +#include <stdint.h> +#include <vector> #include "connection_handler/connection_handler_impl.h" #include "protocol/common.h" -#include "config_profile/profile.h" // TODO(EZamakhov): move security test -#include "security_manager_mock.h" -#include "protocol_handler_mock.h" -#include "connection_handler_observer_mock.h" -#include "transport_manager_mock.h" +#include "security_manager/mock_security_manager.h" +#include "security_manager/mock_ssl_context.h" +#include "protocol_handler/mock_protocol_handler.h" +#include "connection_handler/connection_handler_observer_mock.h" +#include "connection_handler/mock_connection_handler_settings.h" +#include "transport_manager/mock_transport_manager.h" +#include "encryption/hashing.h" namespace test { namespace components { -namespace connection_handle_test { +namespace connection_handler_test { using namespace ::connection_handler; using ::protocol_handler::ServiceType; using namespace ::protocol_handler; using ::testing::_; using ::testing::InSequence; +using ::testing::Mock; +using ::testing::Return; +using ::testing::ReturnRefOfCopy; + // For service types and PROTECTION_ON/OFF +enum UnnamedService { kServedService1 = 0x06, kServedService2 = 0x08 }; + class ConnectionHandlerTest : public ::testing::Test { protected: void SetUp() OVERRIDE { - connection_handler_ = ConnectionHandlerImpl::instance(); + connection_handler_ = new ConnectionHandlerImpl( + mock_connection_handler_settings, mock_transport_manager); uid_ = 1u; connection_key_ = connection_handler_->KeyFromPair(0, 0u); + protected_services_.clear(); + unprotected_services_.clear(); + SetSpecificServices(); } void TearDown() OVERRIDE { - ConnectionHandlerImpl::destroy(); + delete connection_handler_; + } + + void SetSpecificServices() { +#ifdef ENABLE_SECURITY + ON_CALL(mock_connection_handler_settings, force_protected_service()) + .WillByDefault(ReturnRefOfCopy(protected_services_)); + ON_CALL(mock_connection_handler_settings, force_unprotected_service()) + .WillByDefault(ReturnRefOfCopy(unprotected_services_)); +#endif // ENABLE_SECURITY } // Additional SetUp void AddTestDeviceConnection() { @@ -71,19 +93,18 @@ class ConnectionHandlerTest : public ::testing::Test { device_name_ = "test_name"; mac_address_ = "test_address"; - const transport_manager::DeviceInfo device_info(device_handle_, - mac_address_, - device_name_, - connection_type_); + const transport_manager::DeviceInfo device_info( + device_handle_, mac_address_, device_name_, connection_type_); // Add Device and connection + ON_CALL(mock_connection_handler_settings, heart_beat_timeout()) + .WillByDefault(Return(1000u)); connection_handler_->addDeviceConnection(device_info, uid_); connection_key_ = connection_handler_->KeyFromPair(uid_, 0u); // Remove all specific services - SetSpecificServices("", ""); } void AddTestSession() { start_session_id_ = connection_handler_->OnSessionStartedCallback( - uid_, 0, kRpc, PROTECTION_OFF, &out_hash_id_); + uid_, 0, kRpc, PROTECTION_OFF, &out_hash_id_); EXPECT_NE(0u, start_session_id_); EXPECT_EQ(SessionHash(uid_, start_session_id_), out_hash_id_); connection_key_ = connection_handler_->KeyFromPair(uid_, start_session_id_); @@ -102,27 +123,12 @@ class ConnectionHandlerTest : public ::testing::Test { EXPECT_EQ(session_id, start_session_id_); } - // Additional SetUp - void SetSpecificServices(const std::string& protect, const std::string& not_protect) { - const char* config_file = "config.ini"; - std::ofstream file_config(config_file); - ASSERT_TRUE(file_config.is_open()); - const std::string non("NON"); - file_config << "[Security Manager]" << std::endl - << "; Force protected services (could be id's from 0x01 to 0xFF)" - << std::endl << "ForceProtectedService = " - << (protect.empty() ? non : protect) << std::endl - << "; Force unprotected services" << std::endl - << "ForceUnprotectedService = " - << (not_protect.empty() ? non : not_protect) << std::endl; - file_config.close(); - profile::Profile::instance()->config_file_name(config_file); - } // Check Service Wrapper // If session_id is NULL - check that there is no sessions in connection void CheckSessionExists(const int connectionId, const int session_id) { // Check all tree to find Session and check own protected value - const ConnectionList& connection_list = connection_handler_->getConnectionList(); + const ConnectionList& connection_list = + connection_handler_->getConnectionList(); ASSERT_FALSE(connection_list.empty()); ConnectionList::const_iterator conn_it = connection_list.find(connectionId); ASSERT_NE(conn_it, connection_list.end()); @@ -139,17 +145,21 @@ class ConnectionHandlerTest : public ::testing::Test { const ServiceList& service_list = session.service_list; ASSERT_FALSE(service_list.empty()); // Check RPC and bulk services in session - ASSERT_NE(service_list.end(), std::find(service_list.begin(), service_list.end(), kRpc)); - ASSERT_NE(service_list.end(), std::find(service_list.begin(), service_list.end(), kBulk)); + ASSERT_NE(service_list.end(), + std::find(service_list.begin(), service_list.end(), kRpc)); + ASSERT_NE(service_list.end(), + std::find(service_list.begin(), service_list.end(), kBulk)); } } // Check Service Wrapper - void CheckServiceExists(const int connectionId, const int session_id, + void CheckServiceExists(const int connectionId, + const int session_id, const ::protocol_handler::ServiceType serviceId, const bool exists) { // Check all trees to find Service and check own protected value - const ConnectionList& connection_list = connection_handler_->getConnectionList(); + const ConnectionList& connection_list = + connection_handler_->getConnectionList(); ASSERT_FALSE(connection_list.empty()); ConnectionList::const_iterator conn_it = connection_list.find(connectionId); ASSERT_NE(conn_it, connection_list.end()); @@ -162,7 +172,8 @@ class ConnectionHandlerTest : public ::testing::Test { const Session& session = sess_it->second; const ServiceList& service_list = session.service_list; ASSERT_FALSE(service_list.empty()); - ServiceList::const_iterator serv_it = std::find(service_list.begin(), service_list.end(), serviceId); + ServiceList::const_iterator serv_it = + std::find(service_list.begin(), service_list.end(), serviceId); if (exists) { ASSERT_NE(serv_it, service_list.end()); } else { @@ -170,12 +181,14 @@ class ConnectionHandlerTest : public ::testing::Test { } } // Check Service Wrapper - void CheckService(const int connectionId, const int session_id, + void CheckService(const int connectionId, + const int session_id, const ::protocol_handler::ServiceType serviceId, const ::security_manager::SSLContext* ssl_context, const bool is_protected) { // Check all tree to find Service and check own protected value - const ConnectionList& connection_list = connection_handler_->getConnectionList(); + const ConnectionList& connection_list = + connection_handler_->getConnectionList(); ASSERT_FALSE(connection_list.empty()); ConnectionList::const_iterator conn_it = connection_list.find(connectionId); ASSERT_NE(conn_it, connection_list.end()); @@ -191,7 +204,8 @@ class ConnectionHandlerTest : public ::testing::Test { #endif // ENABLE_SECURITY const ServiceList& service_list = session.service_list; ASSERT_FALSE(service_list.empty()); - ServiceList::const_iterator serv_it = std::find(service_list.begin(), service_list.end(), serviceId); + ServiceList::const_iterator serv_it = + std::find(service_list.begin(), service_list.end(), serviceId); ASSERT_NE(serv_it, service_list.end()); const Service& service = *serv_it; @@ -199,28 +213,36 @@ class ConnectionHandlerTest : public ::testing::Test { #ifdef ENABLE_SECURITY if (is_protected) { // Emulate success protection - check enable service flag - const uint32_t connection_key_ = connection_handler_->KeyFromPair( - connectionId, session_id); + const uint32_t connection_key_ = + connection_handler_->KeyFromPair(connectionId, session_id); connection_handler_->SetProtectionFlag(connection_key_, serviceId); } #endif // ENABLE_SECURITY } - void ChangeProtocol(const int connectionId, const int session_id, const uint8_t protocol_version) { + void ChangeProtocol(const int connectionId, + const int session_id, + const uint8_t protocol_version) { ConnectionList connection_list = connection_handler_->getConnectionList(); - ConnectionList::const_iterator conn_it = (connection_handler_->getConnectionList()).find(connectionId); + ConnectionList::const_iterator conn_it = + (connection_handler_->getConnectionList()).find(connectionId); ASSERT_NE(conn_it, connection_list.end()); - Connection * connection = conn_it->second; + Connection* connection = conn_it->second; ASSERT_TRUE(connection != NULL); connection->UpdateProtocolVersionSession(session_id, protocol_version); uint8_t check_protocol_version; - EXPECT_TRUE(connection->ProtocolVersion(session_id, check_protocol_version)); - EXPECT_EQ(check_protocol_version,protocol_version); - + EXPECT_TRUE( + connection->ProtocolVersion(session_id, check_protocol_version)); + EXPECT_EQ(check_protocol_version, protocol_version); } ConnectionHandlerImpl* connection_handler_; + testing::NiceMock<transport_manager_test::MockTransportManager> + mock_transport_manager; + testing::NiceMock<MockConnectionHandlerSettings> + mock_connection_handler_settings; + protocol_handler_test::MockProtocolHandler mock_protocol_handler_; transport_manager::DeviceHandle device_handle_; transport_manager::ConnectionUID uid_; uint32_t connection_key_; @@ -231,13 +253,17 @@ class ConnectionHandlerTest : public ::testing::Test { std::string device_name_; std::string mac_address_; + const uint32_t heartbeat_timeout = 100u; + std::vector<int> protected_services_; + std::vector<int> unprotected_services_; }; TEST_F(ConnectionHandlerTest, StartSession_NoConnection) { // Null sessionId for start new session const uint8_t sessionID = 0; // Start new session with RPC service - const uint32_t result_fail = connection_handler_->OnSessionStartedCallback(uid_, sessionID, kRpc, PROTECTION_ON, &out_hash_id_); + const uint32_t result_fail = connection_handler_->OnSessionStartedCallback( + uid_, sessionID, kRpc, PROTECTION_ON, &out_hash_id_); // Unknown connection error is '0' EXPECT_EQ(0u, result_fail); EXPECT_EQ(protocol_handler::HASH_ID_WRONG, out_hash_id_); @@ -251,12 +277,23 @@ TEST_F(ConnectionHandlerTest, StartSession) { AddTestSession(); } +TEST_F(ConnectionHandlerTest, AddConnection_StopConnection) { + // Add virtual device and connection + AddTestDeviceConnection(); + EXPECT_FALSE(connection_handler_->getConnectionList().empty()); + // Stop connection + connection_handler_->Stop(); + EXPECT_TRUE(connection_handler_->getConnectionList().empty()); +} + TEST_F(ConnectionHandlerTest, GetConnectionSessionsCount) { AddTestDeviceConnection(); - EXPECT_EQ(0u, connection_handler_->GetConnectionSessionsCount(connection_key_)); + EXPECT_EQ(0u, + connection_handler_->GetConnectionSessionsCount(connection_key_)); AddTestSession(); - EXPECT_EQ(1u, connection_handler_->GetConnectionSessionsCount(connection_key_)); + EXPECT_EQ(1u, + connection_handler_->GetConnectionSessionsCount(connection_key_)); } TEST_F(ConnectionHandlerTest, GetAppIdOnSessionKey) { @@ -266,51 +303,82 @@ TEST_F(ConnectionHandlerTest, GetAppIdOnSessionKey) { uint32_t app_id = 0; const uint32_t testid = SessionHash(uid_, start_session_id_); - EXPECT_EQ(0, connection_handler_->GetDataOnSessionKey(connection_key_, &app_id, NULL, NULL)); + EXPECT_EQ(0, + connection_handler_->GetDataOnSessionKey( + connection_key_, &app_id, NULL, NULL)); EXPECT_EQ(testid, app_id); } -TEST_F(ConnectionHandlerTest,GetDeviceID) { +TEST_F(ConnectionHandlerTest, GetAppIdOnSessionKey_SessionNotStarted) { + AddTestDeviceConnection(); + + uint32_t app_id = 0; + EXPECT_EQ(-1, + connection_handler_->GetDataOnSessionKey( + connection_key_, &app_id, NULL, NULL)); +} + +TEST_F(ConnectionHandlerTest, GetDeviceID) { AddTestDeviceConnection(); AddTestSession(); DeviceHandle test_handle; - const DeviceMap & devmap = connection_handler_->getDeviceList(); + const DeviceMap& devmap = connection_handler_->getDeviceList(); DeviceMap::const_iterator pos = devmap.find(device_handle_); ASSERT_NE(pos, devmap.end()); - const Device & devres = pos->second; + const Device& devres = pos->second; std::string test_mac_address = devres.mac_address(); EXPECT_TRUE(connection_handler_->GetDeviceID(test_mac_address, &test_handle)); EXPECT_EQ(device_handle_, test_handle); } -TEST_F(ConnectionHandlerTest,GetDeviceName) { +TEST_F(ConnectionHandlerTest, GetDeviceName) { AddTestDeviceConnection(); AddTestSession(); std::string test_device_name; DeviceHandle handle = 0; - EXPECT_EQ(0, connection_handler_->GetDataOnDeviceID(handle, &test_device_name)); + EXPECT_EQ(0, + connection_handler_->GetDataOnDeviceID(handle, &test_device_name)); EXPECT_EQ(device_name_, test_device_name); } -TEST_F(ConnectionHandlerTest,GetConnectionType) { +TEST_F(ConnectionHandlerTest, GetConnectionType) { AddTestDeviceConnection(); AddTestSession(); const DeviceHandle handle = 0; std::string test_connection_type; - EXPECT_EQ(0, connection_handler_->GetDataOnDeviceID(handle, NULL, NULL, NULL, &test_connection_type)); + EXPECT_EQ(0, + connection_handler_->GetDataOnDeviceID( + handle, NULL, NULL, NULL, &test_connection_type)); EXPECT_EQ(connection_type_, test_connection_type); } +TEST_F(ConnectionHandlerTest, GetApplicationsOnDevice) { + AddTestDeviceConnection(); + AddTestSession(); + + const DeviceHandle handle = 0; + std::list<uint32_t> applications_list; + EXPECT_EQ( + 0, + connection_handler_->GetDataOnDeviceID(handle, NULL, &applications_list)); + + uint32_t test_id = connection_handler_->KeyFromPair(uid_, start_session_id_); + EXPECT_EQ(1u, applications_list.size()); + + EXPECT_EQ(test_id, applications_list.front()); +} + TEST_F(ConnectionHandlerTest, GetDefaultProtocolVersion) { AddTestDeviceConnection(); AddTestSession(); uint8_t protocol_version = 0; - EXPECT_TRUE(connection_handler_->ProtocolVersionUsed(uid_, start_session_id_, protocol_version)); + EXPECT_TRUE(connection_handler_->ProtocolVersionUsed( + uid_, start_session_id_, protocol_version)); EXPECT_EQ(PROTOCOL_VERSION_2, protocol_version); } @@ -321,7 +389,8 @@ TEST_F(ConnectionHandlerTest, GetProtocolVersion) { ChangeProtocol(uid_, start_session_id_, PROTOCOL_VERSION_3); uint8_t protocol_version = 0; - EXPECT_TRUE(connection_handler_->ProtocolVersionUsed(uid_, start_session_id_, protocol_version)); + EXPECT_TRUE(connection_handler_->ProtocolVersionUsed( + uid_, start_session_id_, protocol_version)); EXPECT_EQ(PROTOCOL_VERSION_3, protocol_version); } @@ -330,12 +399,15 @@ TEST_F(ConnectionHandlerTest, GetProtocolVersionAfterBinding) { AddTestDeviceConnection(); AddTestSession(); uint8_t protocol_version = 0; - EXPECT_TRUE(connection_handler_->ProtocolVersionUsed(uid_, start_session_id_, protocol_version)); + EXPECT_TRUE(connection_handler_->ProtocolVersionUsed( + uid_, start_session_id_, protocol_version)); EXPECT_EQ(PROTOCOL_VERSION_2, protocol_version); - connection_handler_->BindProtocolVersionWithSession(connection_key_, PROTOCOL_VERSION_3); + connection_handler_->BindProtocolVersionWithSession(connection_key_, + PROTOCOL_VERSION_3); - EXPECT_TRUE(connection_handler_->ProtocolVersionUsed(uid_, start_session_id_, protocol_version)); + EXPECT_TRUE(connection_handler_->ProtocolVersionUsed( + uid_, start_session_id_, protocol_version)); EXPECT_EQ(PROTOCOL_VERSION_3, protocol_version); } @@ -353,49 +425,51 @@ TEST_F(ConnectionHandlerTest, GetPairFromKey) { TEST_F(ConnectionHandlerTest, IsHeartBeatSupported) { AddTestDeviceConnection(); AddTestSession(); - ChangeProtocol(uid_, start_session_id_, PROTOCOL_VERSION_3); - EXPECT_TRUE(connection_handler_->IsHeartBeatSupported(uid_, start_session_id_)); + EXPECT_TRUE( + connection_handler_->IsHeartBeatSupported(uid_, start_session_id_)); } -TEST_F(ConnectionHandlerTest,SendEndServiceWithoutSetProtocolHandler) { +TEST_F(ConnectionHandlerTest, SendEndServiceWithoutSetProtocolHandler) { AddTestDeviceConnection(); AddTestSession(); - protocol_handler_test::ProtocolHandlerMock mock_protocol_handler; - - EXPECT_CALL(mock_protocol_handler, SendEndService(_,_,kRpc)).Times(0); + EXPECT_CALL(mock_protocol_handler_, SendEndService(_, _, kRpc)).Times(0); connection_handler_->SendEndService(connection_key_, kRpc); } -TEST_F(ConnectionHandlerTest,SendEndService) { +TEST_F(ConnectionHandlerTest, SendEndService) { AddTestDeviceConnection(); AddTestSession(); - protocol_handler_test::ProtocolHandlerMock mock_protocol_handler; - - connection_handler_->set_protocol_handler(&mock_protocol_handler); - EXPECT_CALL(mock_protocol_handler, SendEndService(_,_,kRpc)); + connection_handler_->set_protocol_handler(&mock_protocol_handler_); + EXPECT_CALL(mock_protocol_handler_, SendEndService(_, _, kRpc)); connection_handler_->SendEndService(connection_key_, kRpc); } -TEST_F(ConnectionHandlerTest,OnFindNewApplicationsRequest) { +TEST_F(ConnectionHandlerTest, OnFindNewApplicationsRequest) { AddTestDeviceConnection(); AddTestSession(); - connection_handler_test::ConnectionHandlerObserverMock mock_connection_handler_observer; - connection_handler_->set_connection_handler_observer(&mock_connection_handler_observer); + connection_handler_test::ConnectionHandlerObserverMock + mock_connection_handler_observer; + connection_handler_->set_connection_handler_observer( + &mock_connection_handler_observer); EXPECT_CALL(mock_connection_handler_observer, OnFindNewApplicationsRequest()); connection_handler_->OnFindNewApplicationsRequest(); } -TEST_F(ConnectionHandlerTest,OnFindNewApplicationsRequestWithoutObserver) { - connection_handler_test::ConnectionHandlerObserverMock mock_connection_handler_observer; - EXPECT_CALL(mock_connection_handler_observer, OnFindNewApplicationsRequest()).Times(0); +TEST_F(ConnectionHandlerTest, OnFindNewApplicationsRequestWithoutObserver) { + connection_handler_test::ConnectionHandlerObserverMock + mock_connection_handler_observer; + EXPECT_CALL(mock_connection_handler_observer, OnFindNewApplicationsRequest()) + .Times(0); connection_handler_->OnFindNewApplicationsRequest(); } -TEST_F(ConnectionHandlerTest,OnFindNewApplicationsRequestWithoutSession) { - connection_handler_test::ConnectionHandlerObserverMock mock_connection_handler_observer; - connection_handler_->set_connection_handler_observer(&mock_connection_handler_observer); +TEST_F(ConnectionHandlerTest, OnFindNewApplicationsRequestWithoutSession) { + connection_handler_test::ConnectionHandlerObserverMock + mock_connection_handler_observer; + connection_handler_->set_connection_handler_observer( + &mock_connection_handler_observer); EXPECT_CALL(mock_connection_handler_observer, OnFindNewApplicationsRequest()); connection_handler_->OnFindNewApplicationsRequest(); @@ -406,18 +480,24 @@ TEST_F(ConnectionHandlerTest, OnMalformedMessageCallback) { AddTestSession(); AddTestService(kAudio); AddTestService(kMobileNav); - connection_handler_test::ConnectionHandlerObserverMock mock_connection_handler_observer; - connection_handler_->set_connection_handler_observer(&mock_connection_handler_observer); + connection_handler_test::ConnectionHandlerObserverMock + mock_connection_handler_observer; + connection_handler_->set_connection_handler_observer( + &mock_connection_handler_observer); InSequence seq; EXPECT_CALL(mock_connection_handler_observer, - OnServiceEndedCallback(connection_key_,kMobileNav, kMalformed)).Times(1); + OnServiceEndedCallback(connection_key_, kMobileNav, kMalformed)) + .Times(1); EXPECT_CALL(mock_connection_handler_observer, - OnServiceEndedCallback(connection_key_,kAudio, kMalformed)).Times(1); + OnServiceEndedCallback(connection_key_, kAudio, kMalformed)) + .Times(1); EXPECT_CALL(mock_connection_handler_observer, - OnServiceEndedCallback(connection_key_,kBulk, kMalformed)).Times(1); + OnServiceEndedCallback(connection_key_, kBulk, kMalformed)) + .Times(1); EXPECT_CALL(mock_connection_handler_observer, - OnServiceEndedCallback(connection_key_,kRpc, kMalformed)).Times(1); + OnServiceEndedCallback(connection_key_, kRpc, kMalformed)) + .Times(1); connection_handler_->OnMalformedMessageCallback(uid_); } @@ -426,53 +506,288 @@ TEST_F(ConnectionHandlerTest, OnApplicationFloodCallBack) { AddTestSession(); AddTestService(kAudio); AddTestService(kMobileNav); - connection_handler_test::ConnectionHandlerObserverMock mock_connection_handler_observer; - connection_handler_->set_connection_handler_observer(&mock_connection_handler_observer); + connection_handler_test::ConnectionHandlerObserverMock + mock_connection_handler_observer; + connection_handler_->set_connection_handler_observer( + &mock_connection_handler_observer); - protocol_handler_test::ProtocolHandlerMock mock_protocol_handler; - connection_handler_->set_protocol_handler(&mock_protocol_handler); - - EXPECT_CALL(mock_protocol_handler, SendEndSession(uid_,start_session_id_)); + connection_handler_->set_protocol_handler(&mock_protocol_handler_); + EXPECT_CALL(mock_protocol_handler_, SendEndSession(uid_, start_session_id_)) + .Times(1); InSequence seq; EXPECT_CALL(mock_connection_handler_observer, - OnServiceEndedCallback(connection_key_,kMobileNav, kCommon)).Times(1); + OnServiceEndedCallback(connection_key_, kMobileNav, kCommon)); EXPECT_CALL(mock_connection_handler_observer, - OnServiceEndedCallback(connection_key_,kAudio, kCommon)).Times(1); + OnServiceEndedCallback(connection_key_, kAudio, kCommon)); EXPECT_CALL(mock_connection_handler_observer, - OnServiceEndedCallback(connection_key_,kBulk, kCommon)).Times(1); + OnServiceEndedCallback(connection_key_, kBulk, kCommon)); EXPECT_CALL(mock_connection_handler_observer, - OnServiceEndedCallback(connection_key_,kRpc, kCommon)).Times(1); + OnServiceEndedCallback(connection_key_, kRpc, kCommon)); connection_handler_->OnApplicationFloodCallBack(uid_); } +TEST_F(ConnectionHandlerTest, OnApplicationFloodCallBack_SessionFound) { + // Precondition + AddTestDeviceConnection(); + AddTestSession(); + AddTestService(kAudio); + AddTestService(kMobileNav); + + connection_handler_test::ConnectionHandlerObserverMock + mock_connection_handler_observer; + connection_handler_->set_connection_handler_observer( + &mock_connection_handler_observer); + + connection_handler_->set_protocol_handler(&mock_protocol_handler_); + EXPECT_CALL(mock_protocol_handler_, SendEndSession(uid_, start_session_id_)); + InSequence seq; + EXPECT_CALL(mock_connection_handler_observer, + OnServiceEndedCallback(connection_key_, kMobileNav, kFlood)); + EXPECT_CALL(mock_connection_handler_observer, + OnServiceEndedCallback(connection_key_, kAudio, kFlood)); + EXPECT_CALL(mock_connection_handler_observer, + OnServiceEndedCallback(connection_key_, kBulk, kFlood)); + EXPECT_CALL(mock_connection_handler_observer, + OnServiceEndedCallback(connection_key_, kRpc, kFlood)); + + connection_handler_->OnApplicationFloodCallBack(connection_key_); +} + TEST_F(ConnectionHandlerTest, StartDevicesDiscovery) { AddTestDeviceConnection(); AddTestSession(); - transport_manager_test::TransportManagerMock mock_transport_manager; - connection_handler_->set_transport_manager(&mock_transport_manager); - connection_handler_test::ConnectionHandlerObserverMock mock_connection_handler_observer; - connection_handler_->set_connection_handler_observer(&mock_connection_handler_observer); + + connection_handler_test::ConnectionHandlerObserverMock + mock_connection_handler_observer; + connection_handler_->set_connection_handler_observer( + &mock_connection_handler_observer); EXPECT_CALL(mock_transport_manager, SearchDevices()); EXPECT_CALL(mock_connection_handler_observer, OnDeviceListUpdated(_)); connection_handler_->StartDevicesDiscovery(); } +MATCHER_P(CheckDevList, check_device_map, "") { + DeviceMap device_list = arg; + if (device_list.size() != check_device_map.size()) { + return false; + } + DeviceMap::const_iterator it = device_list.begin(); + DeviceMap::const_iterator end = device_list.end(); + + DeviceMap::const_iterator check_it = check_device_map.begin(); + for (; it != end; ++it, ++check_it) { + if (it->first != check_it->first) { + return false; + } + if ((*it).second.device_handle() != (*check_it).second.device_handle()) { + return false; + } + if ((*it).second.mac_address() != (*check_it).second.mac_address()) { + return false; + } + if ((*it).second.connection_type() != + (*check_it).second.connection_type()) { + return false; + } + } + return true; +} + +TEST_F(ConnectionHandlerTest, UpdateDeviceList) { + // Precondition + AddTestDeviceConnection(); + AddTestSession(); + connection_handler_test::ConnectionHandlerObserverMock + mock_connection_handler_observer; + connection_handler_->set_connection_handler_observer( + &mock_connection_handler_observer); + + connection_type_ = "BTMAC"; + device_name_ = "test_name"; + mac_address_ = "test_address"; + const transport_manager::DeviceInfo added_info( + 0, "test_address", "test_name", "BTMAC"); + connection_handler_->OnDeviceAdded(added_info); + + // Prepare map with DeviceInfo that sets in OnDeviceListUpdated + const transport_manager::DeviceInfo unused_parameter( + 0, "mac_address_", "device_name_", "connection_type_"); + std::vector<transport_manager::DeviceInfo> unused_info; + unused_info.push_back(unused_parameter); + DeviceMap map_with_unused_var; + map_with_unused_var.insert( + DeviceMap::value_type(unused_parameter.device_handle(), + Device(unused_parameter.device_handle(), + unused_parameter.name(), + unused_parameter.mac_address(), + unused_parameter.connection_type()))); + + // Only previously added devices is updated + EXPECT_CALL( + mock_connection_handler_observer, + OnDeviceListUpdated(CheckDevList(connection_handler_->getDeviceList()))); + + // New value that sets in OnDeviceListUpdated does not add + EXPECT_CALL(mock_connection_handler_observer, + OnDeviceListUpdated(CheckDevList(map_with_unused_var))).Times(0); + + connection_handler_->OnDeviceListUpdated(unused_info); +} + +TEST_F(ConnectionHandlerTest, GetConnectedDevicesMAC) { + // Precondition + const std::string mac_address1 = "test_address1"; + const std::string mac_address2 = "test_address2"; + + const transport_manager::DeviceInfo device1( + 0, mac_address1, device_name_, connection_type_); + const transport_manager::DeviceInfo device2( + 1, mac_address2, device_name_, connection_type_); + connection_handler_->OnDeviceAdded(device1); + connection_handler_->OnDeviceAdded(device2); + + // Expect mac adress was hashed and saved + const std::string check_mac1 = encryption::MakeHash(mac_address1); + const std::string check_mac2 = encryption::MakeHash(mac_address2); + std::vector<std::string> device_macs; + connection_handler_->GetConnectedDevicesMAC(device_macs); + ASSERT_EQ(2u, device_macs.size()); + EXPECT_EQ(check_mac1, device_macs.at(0)); + EXPECT_EQ(check_mac2, device_macs.at(1)); +} + TEST_F(ConnectionHandlerTest, StartTransportManager) { AddTestDeviceConnection(); AddTestSession(); - transport_manager_test::TransportManagerMock mock_transport_manager; - connection_handler_->set_transport_manager(&mock_transport_manager); + EXPECT_CALL(mock_transport_manager, Visibility(true)); connection_handler_->StartTransportManager(); } +TEST_F(ConnectionHandlerTest, OnDeviceRemoved_ServiceNotStarted) { + // Precondition + const uint32_t dev_handle1 = 1; + const uint32_t dev_handle2 = 2; + + const transport_manager::DeviceInfo device1( + dev_handle1, mac_address_, device_name_, connection_type_); + const transport_manager::DeviceInfo device2( + dev_handle2, mac_address_, device_name_, connection_type_); + connection_handler_->OnDeviceAdded(device1); + connection_handler_->OnDeviceAdded(device2); + + connection_handler_test::ConnectionHandlerObserverMock + mock_connection_handler_observer; + connection_handler_->set_connection_handler_observer( + &mock_connection_handler_observer); + + EXPECT_CALL(mock_connection_handler_observer, RemoveDevice(dev_handle1)); + EXPECT_CALL(mock_connection_handler_observer, OnServiceEndedCallback(_, _, _)) + .Times(0); + connection_handler_->OnDeviceRemoved(device1); +} + +TEST_F(ConnectionHandlerTest, OnDeviceRemoved_ServiceStarted) { + // Precondition + AddTestDeviceConnection(); + AddTestSession(); + + const transport_manager::DeviceInfo device1( + device_handle_, mac_address_, device_name_, connection_type_); + + connection_handler_test::ConnectionHandlerObserverMock + mock_connection_handler_observer; + connection_handler_->set_connection_handler_observer( + &mock_connection_handler_observer); + + EXPECT_CALL(mock_connection_handler_observer, RemoveDevice(device_handle_)); + + EXPECT_CALL(mock_connection_handler_observer, + OnServiceEndedCallback(connection_key_, kBulk, kCommon)); + EXPECT_CALL(mock_connection_handler_observer, + OnServiceEndedCallback(connection_key_, kRpc, kCommon)); + connection_handler_->OnDeviceRemoved(device1); +} + +TEST_F(ConnectionHandlerTest, OnConnectionClosed) { + AddTestDeviceConnection(); + AddTestSession(); + + connection_handler_test::ConnectionHandlerObserverMock + mock_connection_handler_observer; + connection_handler_->set_connection_handler_observer( + &mock_connection_handler_observer); + + EXPECT_CALL(mock_connection_handler_observer, + OnServiceEndedCallback(connection_key_, kBulk, kCommon)); + EXPECT_CALL(mock_connection_handler_observer, + OnServiceEndedCallback(connection_key_, kRpc, kCommon)); + + connection_handler_->OnConnectionClosed(uid_); +} + +TEST_F(ConnectionHandlerTest, OnUnexpectedDisconnect) { + AddTestDeviceConnection(); + AddTestSession(); + + connection_handler_test::ConnectionHandlerObserverMock + mock_connection_handler_observer; + connection_handler_->set_connection_handler_observer( + &mock_connection_handler_observer); + transport_manager::CommunicationError err; + EXPECT_CALL(mock_connection_handler_observer, + OnServiceEndedCallback( + connection_key_, kBulk, CloseSessionReason::kCommon)); + EXPECT_CALL(mock_connection_handler_observer, + OnServiceEndedCallback( + connection_key_, kRpc, CloseSessionReason::kCommon)); + + connection_handler_->OnUnexpectedDisconnect(uid_, err); +} + +TEST_F(ConnectionHandlerTest, ConnectToDevice) { + // Precondition + const uint32_t dev_handle1 = 1; + const uint32_t dev_handle2 = 2; + + const transport_manager::DeviceInfo device1( + dev_handle1, mac_address_, device_name_, connection_type_); + const transport_manager::DeviceInfo device2( + dev_handle2, mac_address_, device_name_, connection_type_); + connection_handler_->OnDeviceAdded(device1); + connection_handler_->OnDeviceAdded(device2); + + EXPECT_CALL(mock_transport_manager, ConnectDevice(dev_handle1)) + .WillOnce(Return(transport_manager::E_SUCCESS)); + EXPECT_CALL(mock_transport_manager, ConnectDevice(dev_handle2)).Times(0); + connection_handler_->ConnectToDevice(dev_handle1); +} + +TEST_F(ConnectionHandlerTest, ConnectToAllDevices) { + // Precondition + const uint32_t dev_handle1 = 1; + const uint32_t dev_handle2 = 2; + + const transport_manager::DeviceInfo device1( + dev_handle1, mac_address_, device_name_, connection_type_); + const transport_manager::DeviceInfo device2( + dev_handle2, mac_address_, device_name_, connection_type_); + connection_handler_->OnDeviceAdded(device1); + connection_handler_->OnDeviceAdded(device2); + + EXPECT_CALL(mock_transport_manager, ConnectDevice(dev_handle1)) + .WillOnce(Return(transport_manager::E_SUCCESS)); + EXPECT_CALL(mock_transport_manager, ConnectDevice(dev_handle2)) + .WillOnce(Return(transport_manager::E_SUCCESS)); + connection_handler_->ConnectToAllDevices(); +} + TEST_F(ConnectionHandlerTest, CloseConnection) { AddTestDeviceConnection(); AddTestSession(); - transport_manager_test::TransportManagerMock mock_transport_manager; - connection_handler_->set_transport_manager(&mock_transport_manager); + EXPECT_CALL(mock_transport_manager, DisconnectForce(uid_)); connection_handler_->CloseConnection(uid_); } @@ -480,8 +795,7 @@ TEST_F(ConnectionHandlerTest, CloseConnection) { TEST_F(ConnectionHandlerTest, CloseRevokedConnection) { AddTestDeviceConnection(); AddTestSession(); - transport_manager_test::TransportManagerMock mock_transport_manager; - connection_handler_->set_transport_manager(&mock_transport_manager); + EXPECT_CALL(mock_transport_manager, DisconnectForce(uid_)); connection_handler_->CloseRevokedConnection(connection_key_); } @@ -491,24 +805,27 @@ TEST_F(ConnectionHandlerTest, CloseSessionWithCommonReason) { AddTestSession(); AddTestService(kAudio); AddTestService(kMobileNav); - connection_handler_test::ConnectionHandlerObserverMock mock_connection_handler_observer; - connection_handler_->set_connection_handler_observer(&mock_connection_handler_observer); - - protocol_handler_test::ProtocolHandlerMock mock_protocol_handler; - connection_handler_->set_protocol_handler(&mock_protocol_handler); - - EXPECT_CALL(mock_protocol_handler, SendEndSession(uid_,start_session_id_)); - + connection_handler_test::ConnectionHandlerObserverMock + mock_connection_handler_observer; + connection_handler_->set_connection_handler_observer( + &mock_connection_handler_observer); + + connection_handler_->set_protocol_handler(&mock_protocol_handler_); + EXPECT_CALL(mock_protocol_handler_, SendEndSession(uid_, start_session_id_)) + .Times(1); InSequence seq; EXPECT_CALL(mock_connection_handler_observer, - OnServiceEndedCallback(connection_key_,kMobileNav, kCommon)).Times(1); + OnServiceEndedCallback(connection_key_, kMobileNav, kCommon)) + .Times(1); EXPECT_CALL(mock_connection_handler_observer, - OnServiceEndedCallback(connection_key_,kAudio, kCommon)).Times(1); + OnServiceEndedCallback(connection_key_, kAudio, kCommon)) + .Times(1); EXPECT_CALL(mock_connection_handler_observer, - OnServiceEndedCallback(connection_key_,kBulk, kCommon)).Times(1); + OnServiceEndedCallback(connection_key_, kBulk, kCommon)).Times(1); EXPECT_CALL(mock_connection_handler_observer, - OnServiceEndedCallback(connection_key_,kRpc, kCommon)).Times(1); + OnServiceEndedCallback(connection_key_, kRpc, kCommon)).Times(1); connection_handler_->CloseSession(connection_key_, kCommon); + Mock::AsyncVerifyAndClearExpectations(10000); } TEST_F(ConnectionHandlerTest, CloseSessionWithFloodReason) { @@ -516,24 +833,27 @@ TEST_F(ConnectionHandlerTest, CloseSessionWithFloodReason) { AddTestSession(); AddTestService(kAudio); AddTestService(kMobileNav); - connection_handler_test::ConnectionHandlerObserverMock mock_connection_handler_observer; - connection_handler_->set_connection_handler_observer(&mock_connection_handler_observer); + connection_handler_test::ConnectionHandlerObserverMock + mock_connection_handler_observer; + connection_handler_->set_connection_handler_observer( + &mock_connection_handler_observer); - protocol_handler_test::ProtocolHandlerMock mock_protocol_handler; - connection_handler_->set_protocol_handler(&mock_protocol_handler); - - EXPECT_CALL(mock_protocol_handler, SendEndSession(uid_,start_session_id_)); + connection_handler_->set_protocol_handler(&mock_protocol_handler_); + EXPECT_CALL(mock_protocol_handler_, SendEndSession(uid_, start_session_id_)) + .Times(1); InSequence seq; EXPECT_CALL(mock_connection_handler_observer, - OnServiceEndedCallback(connection_key_,kMobileNav, kFlood)).Times(1); + OnServiceEndedCallback(connection_key_, kMobileNav, kFlood)) + .Times(1); EXPECT_CALL(mock_connection_handler_observer, - OnServiceEndedCallback(connection_key_,kAudio, kFlood)).Times(1); + OnServiceEndedCallback(connection_key_, kAudio, kFlood)).Times(1); EXPECT_CALL(mock_connection_handler_observer, - OnServiceEndedCallback(connection_key_,kBulk, kFlood)).Times(1); + OnServiceEndedCallback(connection_key_, kBulk, kFlood)).Times(1); EXPECT_CALL(mock_connection_handler_observer, - OnServiceEndedCallback(connection_key_,kRpc, kFlood)).Times(1); + OnServiceEndedCallback(connection_key_, kRpc, kFlood)).Times(1); connection_handler_->CloseSession(connection_key_, kFlood); + Mock::AsyncVerifyAndClearExpectations(10000); } TEST_F(ConnectionHandlerTest, CloseSessionWithMalformedMessage) { @@ -541,24 +861,30 @@ TEST_F(ConnectionHandlerTest, CloseSessionWithMalformedMessage) { AddTestSession(); AddTestService(kAudio); AddTestService(kMobileNav); - connection_handler_test::ConnectionHandlerObserverMock mock_connection_handler_observer; - connection_handler_->set_connection_handler_observer(&mock_connection_handler_observer); - - protocol_handler_test::ProtocolHandlerMock mock_protocol_handler; - connection_handler_->set_protocol_handler(&mock_protocol_handler); + connection_handler_test::ConnectionHandlerObserverMock + mock_connection_handler_observer; + connection_handler_->set_connection_handler_observer( + &mock_connection_handler_observer); - EXPECT_CALL(mock_protocol_handler, SendEndSession(uid_,start_session_id_)).Times(0); + connection_handler_->set_protocol_handler(&mock_protocol_handler_); + EXPECT_CALL(mock_protocol_handler_, SendEndSession(uid_, start_session_id_)) + .Times(0); InSequence seq; EXPECT_CALL(mock_connection_handler_observer, - OnServiceEndedCallback(connection_key_,kMobileNav, kMalformed)).Times(1); + OnServiceEndedCallback(connection_key_, kMobileNav, kMalformed)) + .Times(1); EXPECT_CALL(mock_connection_handler_observer, - OnServiceEndedCallback(connection_key_,kAudio, kMalformed)).Times(1); + OnServiceEndedCallback(connection_key_, kAudio, kMalformed)) + .Times(1); EXPECT_CALL(mock_connection_handler_observer, - OnServiceEndedCallback(connection_key_,kBulk, kMalformed)).Times(1); + OnServiceEndedCallback(connection_key_, kBulk, kMalformed)) + .Times(1); EXPECT_CALL(mock_connection_handler_observer, - OnServiceEndedCallback(connection_key_,kRpc, kMalformed)).Times(1); + OnServiceEndedCallback(connection_key_, kRpc, kMalformed)) + .Times(1); connection_handler_->CloseSession(connection_key_, kMalformed); + Mock::AsyncVerifyAndClearExpectations(10000); } TEST_F(ConnectionHandlerTest, CloseConnectionSessionsWithMalformedMessage) { @@ -566,24 +892,30 @@ TEST_F(ConnectionHandlerTest, CloseConnectionSessionsWithMalformedMessage) { AddTestSession(); AddTestService(kAudio); AddTestService(kMobileNav); - connection_handler_test::ConnectionHandlerObserverMock mock_connection_handler_observer; - connection_handler_->set_connection_handler_observer(&mock_connection_handler_observer); + connection_handler_test::ConnectionHandlerObserverMock + mock_connection_handler_observer; + connection_handler_->set_connection_handler_observer( + &mock_connection_handler_observer); - protocol_handler_test::ProtocolHandlerMock mock_protocol_handler; - connection_handler_->set_protocol_handler(&mock_protocol_handler); - - EXPECT_CALL(mock_protocol_handler, SendEndSession(uid_,start_session_id_)).Times(0); + connection_handler_->set_protocol_handler(&mock_protocol_handler_); + EXPECT_CALL(mock_protocol_handler_, SendEndSession(uid_, start_session_id_)) + .Times(0); InSequence seq; EXPECT_CALL(mock_connection_handler_observer, - OnServiceEndedCallback(connection_key_,kMobileNav, kMalformed)).Times(1); + OnServiceEndedCallback(connection_key_, kMobileNav, kMalformed)) + .Times(1); EXPECT_CALL(mock_connection_handler_observer, - OnServiceEndedCallback(connection_key_,kAudio, kMalformed)).Times(1); + OnServiceEndedCallback(connection_key_, kAudio, kMalformed)) + .Times(1); EXPECT_CALL(mock_connection_handler_observer, - OnServiceEndedCallback(connection_key_,kBulk, kMalformed)).Times(1); + OnServiceEndedCallback(connection_key_, kBulk, kMalformed)) + .Times(1); EXPECT_CALL(mock_connection_handler_observer, - OnServiceEndedCallback(connection_key_,kRpc, kMalformed)).Times(1); + OnServiceEndedCallback(connection_key_, kRpc, kMalformed)) + .Times(1); connection_handler_->CloseConnectionSessions(uid_, kMalformed); + Mock::AsyncVerifyAndClearExpectations(10000); } TEST_F(ConnectionHandlerTest, CloseConnectionSessionsWithCommonReason) { @@ -591,24 +923,28 @@ TEST_F(ConnectionHandlerTest, CloseConnectionSessionsWithCommonReason) { AddTestSession(); AddTestService(kAudio); AddTestService(kMobileNav); - connection_handler_test::ConnectionHandlerObserverMock mock_connection_handler_observer; - connection_handler_->set_connection_handler_observer(&mock_connection_handler_observer); - - protocol_handler_test::ProtocolHandlerMock mock_protocol_handler; - connection_handler_->set_protocol_handler(&mock_protocol_handler); + connection_handler_test::ConnectionHandlerObserverMock + mock_connection_handler_observer; + connection_handler_->set_connection_handler_observer( + &mock_connection_handler_observer); - EXPECT_CALL(mock_protocol_handler, SendEndSession(uid_,start_session_id_)); + connection_handler_->set_protocol_handler(&mock_protocol_handler_); + EXPECT_CALL(mock_protocol_handler_, SendEndSession(uid_, start_session_id_)) + .Times(1); InSequence seq; EXPECT_CALL(mock_connection_handler_observer, - OnServiceEndedCallback(connection_key_,kMobileNav, kCommon)).Times(1); + OnServiceEndedCallback(connection_key_, kMobileNav, kCommon)) + .Times(1); EXPECT_CALL(mock_connection_handler_observer, - OnServiceEndedCallback(connection_key_,kAudio, kCommon)).Times(1); + OnServiceEndedCallback(connection_key_, kAudio, kCommon)) + .Times(1); EXPECT_CALL(mock_connection_handler_observer, - OnServiceEndedCallback(connection_key_,kBulk, kCommon)).Times(1); + OnServiceEndedCallback(connection_key_, kBulk, kCommon)).Times(1); EXPECT_CALL(mock_connection_handler_observer, - OnServiceEndedCallback(connection_key_,kRpc, kCommon)).Times(1); + OnServiceEndedCallback(connection_key_, kRpc, kCommon)).Times(1); connection_handler_->CloseConnectionSessions(uid_, kCommon); + Mock::AsyncVerifyAndClearExpectations(10000); } TEST_F(ConnectionHandlerTest, StartService_withServices) { @@ -618,7 +954,7 @@ TEST_F(ConnectionHandlerTest, StartService_withServices) { // Start Audio service const uint32_t start_audio = connection_handler_->OnSessionStartedCallback( - uid_, start_session_id_, kAudio, PROTECTION_OFF, &out_hash_id_); + uid_, start_session_id_, kAudio, PROTECTION_OFF, &out_hash_id_); EXPECT_EQ(start_session_id_, start_audio); CheckServiceExists(uid_, start_session_id_, kAudio, true); EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, out_hash_id_); @@ -634,8 +970,8 @@ TEST_F(ConnectionHandlerTest, StartService_withServices) { TEST_F(ConnectionHandlerTest, ServiceStop_UnExistSession) { AddTestDeviceConnection(); - const uint32_t end_session_result = connection_handler_->OnSessionEndedCallback( - uid_, 0u, 0u, kAudio); + const uint32_t end_session_result = + connection_handler_->OnSessionEndedCallback(uid_, 0u, 0u, kAudio); EXPECT_EQ(0u, end_session_result); CheckSessionExists(uid_, 0); } @@ -643,8 +979,9 @@ TEST_F(ConnectionHandlerTest, ServiceStop_UnExistSession) { TEST_F(ConnectionHandlerTest, ServiceStop_UnExistService) { AddTestDeviceConnection(); AddTestSession(); - const uint32_t end_session_result = connection_handler_->OnSessionEndedCallback( - uid_, start_session_id_, 0u, kAudio); + const uint32_t end_session_result = + connection_handler_->OnSessionEndedCallback( + uid_, start_session_id_, 0u, kAudio); EXPECT_EQ(0u, end_session_result); CheckServiceExists(uid_, start_session_id_, kAudio, false); } @@ -656,12 +993,13 @@ TEST_F(ConnectionHandlerTest, ServiceStop) { for (uint32_t some_hash_id = 0; some_hash_id < 0xFF; ++some_hash_id) { // Start audio service const uint32_t start_audio = connection_handler_->OnSessionStartedCallback( - uid_, start_session_id_, kAudio, PROTECTION_OFF, &out_hash_id_); + uid_, start_session_id_, kAudio, PROTECTION_OFF, &out_hash_id_); EXPECT_EQ(start_session_id_, start_audio); EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, out_hash_id_); - const uint32_t end_session_result = connection_handler_->OnSessionEndedCallback( - uid_, start_session_id_, some_hash_id, kAudio); + const uint32_t end_session_result = + connection_handler_->OnSessionEndedCallback( + uid_, start_session_id_, some_hash_id, kAudio); EXPECT_EQ(connection_key_, end_session_result); CheckServiceExists(uid_, start_session_id_, kAudio, false); } @@ -675,13 +1013,14 @@ TEST_F(ConnectionHandlerTest, SessionStop_CheckHash) { const uint32_t hash = connection_key_; const uint32_t wrong_hash = hash + 1; - const uint32_t end_audio_wrong_hash = connection_handler_->OnSessionEndedCallback( - uid_, start_session_id_, wrong_hash, kRpc); + const uint32_t end_audio_wrong_hash = + connection_handler_->OnSessionEndedCallback( + uid_, start_session_id_, wrong_hash, kRpc); EXPECT_EQ(0u, end_audio_wrong_hash); CheckSessionExists(uid_, start_session_id_); const uint32_t end_audio = connection_handler_->OnSessionEndedCallback( - uid_, start_session_id_, hash, kRpc); + uid_, start_session_id_, hash, kRpc); EXPECT_EQ(connection_key_, end_audio); CheckSessionExists(uid_, 0); } @@ -695,26 +1034,53 @@ TEST_F(ConnectionHandlerTest, SessionStop_CheckSpecificHash) { const uint32_t wrong_hash = protocol_handler::HASH_ID_WRONG; const uint32_t hash = protocol_handler::HASH_ID_NOT_SUPPORTED; - const uint32_t end_audio_wrong_hash = connection_handler_->OnSessionEndedCallback( - uid_, start_session_id_, wrong_hash, kRpc); + const uint32_t end_audio_wrong_hash = + connection_handler_->OnSessionEndedCallback( + uid_, start_session_id_, wrong_hash, kRpc); EXPECT_EQ(0u, end_audio_wrong_hash); CheckSessionExists(uid_, start_session_id_); const uint32_t end_audio = connection_handler_->OnSessionEndedCallback( - uid_, start_session_id_, hash, kRpc); + uid_, start_session_id_, hash, kRpc); EXPECT_EQ(connection_key_, end_audio); CheckSessionExists(uid_, 0); } } -TEST_F(ConnectionHandlerTest, SessionStarted_StartSession_SecureSpecific_Unprotect) { +TEST_F(ConnectionHandlerTest, SessionStarted_WithRpc) { + // Add virtual device and connection + AddTestDeviceConnection(); + // Expect that rpc service has started + connection_handler_test::ConnectionHandlerObserverMock + mock_connection_handler_observer; + connection_handler_->set_connection_handler_observer( + &mock_connection_handler_observer); + uint32_t session_key = + connection_handler_->KeyFromPair(uid_, start_session_id_); + EXPECT_CALL(mock_connection_handler_observer, + OnServiceStartedCallback(device_handle_, session_key, kRpc)) + .WillOnce(Return(true)); + + // Start new session with RPC service + uint32_t new_session_id = connection_handler_->OnSessionStartedCallback( + uid_, 0, kRpc, PROTECTION_OFF, &out_hash_id_); + + EXPECT_NE(0u, new_session_id); +} + +TEST_F(ConnectionHandlerTest, + SessionStarted_StartSession_SecureSpecific_Unprotect) { + EXPECT_CALL(mock_connection_handler_settings, heart_beat_timeout()) + .WillOnce(Return(heartbeat_timeout)); // Add virtual device and connection AddTestDeviceConnection(); // Forbid start kRPC without encryption - SetSpecificServices("0x07", ""); + protected_services_.push_back(kRpc); + SetSpecificServices(); // Start new session with RPC service - const uint32_t session_id_fail = connection_handler_->OnSessionStartedCallback( - uid_, 0, kRpc, PROTECTION_OFF, &out_hash_id_); + const uint32_t session_id_fail = + connection_handler_->OnSessionStartedCallback( + uid_, 0, kRpc, PROTECTION_OFF, &out_hash_id_); #ifdef ENABLE_SECURITY EXPECT_EQ(0u, session_id_fail); EXPECT_EQ(protocol_handler::HASH_ID_WRONG, out_hash_id_); @@ -724,23 +1090,31 @@ TEST_F(ConnectionHandlerTest, SessionStarted_StartSession_SecureSpecific_Unprote #endif // ENABLE_SECURITY // Allow start kRPC without encryption - SetSpecificServices("0x00, Non", ""); + protected_services_.clear(); + protected_services_.push_back(kControl); + SetSpecificServices(); // Start new session with RPC service const uint32_t session_id = connection_handler_->OnSessionStartedCallback( - uid_, 0, kRpc, PROTECTION_OFF, &out_hash_id_); + uid_, 0, kRpc, PROTECTION_OFF, &out_hash_id_); EXPECT_NE(0u, session_id); CheckService(uid_, session_id, kRpc, NULL, PROTECTION_OFF); EXPECT_EQ(SessionHash(uid_, session_id), out_hash_id_); } -TEST_F(ConnectionHandlerTest, SessionStarted_StartSession_SecureSpecific_Protect) { +TEST_F(ConnectionHandlerTest, + SessionStarted_StartSession_SecureSpecific_Protect) { // Add virtual device and connection AddTestDeviceConnection(); // Forbid start kRPC with encryption - SetSpecificServices("", "0x06, 0x07, 0x08, Non"); + unprotected_services_.push_back(UnnamedService::kServedService1); + unprotected_services_.push_back(kRpc); + unprotected_services_.push_back(UnnamedService::kServedService2); + unprotected_services_.push_back(kControl); + SetSpecificServices(); // Start new session with RPC service - const uint32_t session_id_fail = connection_handler_->OnSessionStartedCallback( - uid_, 0, kRpc, PROTECTION_ON, NULL); + const uint32_t session_id_fail = + connection_handler_->OnSessionStartedCallback( + uid_, 0, kRpc, PROTECTION_ON, NULL); #ifdef ENABLE_SECURITY EXPECT_EQ(0u, session_id_fail); #else @@ -748,10 +1122,12 @@ TEST_F(ConnectionHandlerTest, SessionStarted_StartSession_SecureSpecific_Protect #endif // ENABLE_SECURITY // Allow start kRPC with encryption - SetSpecificServices("", "0x00, 0x05, Non"); + unprotected_services_.clear(); + unprotected_services_.push_back(kControl); + SetSpecificServices(); // Start new session with RPC service const uint32_t session_id = connection_handler_->OnSessionStartedCallback( - uid_, 0, kRpc, PROTECTION_ON, &out_hash_id_); + uid_, 0, kRpc, PROTECTION_ON, &out_hash_id_); EXPECT_NE(0u, session_id); EXPECT_EQ(SessionHash(uid_, session_id), out_hash_id_); @@ -759,67 +1135,75 @@ TEST_F(ConnectionHandlerTest, SessionStarted_StartSession_SecureSpecific_Protect CheckService(uid_, session_id, kRpc, NULL, PROTECTION_OFF); } -TEST_F(ConnectionHandlerTest, SessionStarted_StartService_SecureSpecific_Unprotect) { +TEST_F(ConnectionHandlerTest, + SessionStarted_StartService_SecureSpecific_Unprotect) { AddTestDeviceConnection(); AddTestSession(); - // Audio is 0x0A - ASSERT_EQ(0x0A, kAudio); - // Forbid start kAudio without encryption - SetSpecificServices("0x06, 0x0A, 0x08, Non", ""); + protected_services_.push_back(UnnamedService::kServedService1); + protected_services_.push_back(kAudio); + protected_services_.push_back(UnnamedService::kServedService2); + protected_services_.push_back(kControl); + SetSpecificServices(); // Start new session with Audio service const uint32_t session_id2 = connection_handler_->OnSessionStartedCallback( - uid_, start_session_id_, kAudio, PROTECTION_OFF, NULL); + uid_, start_session_id_, kAudio, PROTECTION_OFF, NULL); #ifdef ENABLE_SECURITY EXPECT_EQ(0u, session_id2); #else EXPECT_EQ(1u, session_id2); #endif // ENABLE_SECURITY // Allow start kAudio without encryption - SetSpecificServices("0x06, 0x0B, 0x08, Non", ""); + protected_services_.clear(); + protected_services_.push_back(UnnamedService::kServedService1); + protected_services_.push_back(kMobileNav); + protected_services_.push_back(UnnamedService::kServedService2); + protected_services_.push_back(kControl); + SetSpecificServices(); const uint32_t session_id3 = connection_handler_->OnSessionStartedCallback( - uid_, start_session_id_, kAudio, PROTECTION_OFF, &out_hash_id_); - // Returned original session id + uid_, start_session_id_, kAudio, PROTECTION_OFF, &out_hash_id_); +// Returned original session id #ifdef ENABLE_SECURITY EXPECT_EQ(start_session_id_, session_id3); EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, out_hash_id_); - CheckService(uid_, session_id3, kRpc, - NULL, - PROTECTION_OFF); + CheckService(uid_, session_id3, kRpc, NULL, PROTECTION_OFF); #else EXPECT_EQ(0u, session_id3); EXPECT_EQ(protocol_handler::HASH_ID_WRONG, out_hash_id_); #endif // ENABLE_SECURITY } -TEST_F(ConnectionHandlerTest, SessionStarted_StartService_SecureSpecific_Protect) { +TEST_F(ConnectionHandlerTest, + SessionStarted_StartService_SecureSpecific_Protect) { AddTestDeviceConnection(); AddTestSession(); - // Audio is 0x0A - ASSERT_EQ(0x0A, kAudio); // Forbid start kAudio with encryption - SetSpecificServices("", "0x06, 0x0A, 0x08, Non"); + unprotected_services_.push_back(UnnamedService::kServedService1); + unprotected_services_.push_back(kAudio); + unprotected_services_.push_back(UnnamedService::kServedService2); + unprotected_services_.push_back(kControl); + SetSpecificServices(); // Start new session with Audio service - const uint32_t session_id_reject = connection_handler_->OnSessionStartedCallback( - uid_, start_session_id_, kAudio, PROTECTION_ON, NULL); + const uint32_t session_id_reject = + connection_handler_->OnSessionStartedCallback( + uid_, start_session_id_, kAudio, PROTECTION_ON, NULL); #ifdef ENABLE_SECURITY EXPECT_EQ(0u, session_id_reject); #else EXPECT_EQ(1u, session_id_reject); #endif // ENABLE_SECURITY // Allow start kAudio with encryption - SetSpecificServices("", "Non"); + unprotected_services_.clear(); + SetSpecificServices(); const uint32_t session_id3 = connection_handler_->OnSessionStartedCallback( - uid_, start_session_id_, kAudio, PROTECTION_ON, &out_hash_id_); - // Returned original session id + uid_, start_session_id_, kAudio, PROTECTION_ON, &out_hash_id_); +// Returned original session id #ifdef ENABLE_SECURITY EXPECT_EQ(start_session_id_, session_id3); EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, out_hash_id_); - CheckService(uid_, session_id3, kAudio, - NULL, - PROTECTION_ON); + CheckService(uid_, session_id3, kAudio, NULL, PROTECTION_ON); #else EXPECT_EQ(0u, session_id3); EXPECT_EQ(protocol_handler::HASH_ID_WRONG, out_hash_id_); @@ -833,14 +1217,12 @@ TEST_F(ConnectionHandlerTest, SessionStarted_DealyProtect) { // Start RPC protection const uint32_t session_id_new = connection_handler_->OnSessionStartedCallback( - uid_, start_session_id_, kRpc, PROTECTION_ON, &out_hash_id_); + uid_, start_session_id_, kRpc, PROTECTION_ON, &out_hash_id_); #ifdef ENABLE_SECURITY EXPECT_EQ(start_session_id_, session_id_new); // Post protection nedd no hash EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, out_hash_id_); - CheckService(uid_, start_session_id_, kRpc, - NULL, - PROTECTION_ON); + CheckService(uid_, start_session_id_, kRpc, NULL, PROTECTION_ON); #else EXPECT_EQ(0u, session_id_new); // Post protection nedd no hash @@ -850,20 +1232,18 @@ TEST_F(ConnectionHandlerTest, SessionStarted_DealyProtect) { // Start Audio session without protection const uint32_t session_id2 = connection_handler_->OnSessionStartedCallback( - uid_, start_session_id_, kAudio, PROTECTION_OFF, &out_hash_id_); + uid_, start_session_id_, kAudio, PROTECTION_OFF, &out_hash_id_); EXPECT_EQ(start_session_id_, session_id2); EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, out_hash_id_); CheckService(uid_, start_session_id_, kAudio, NULL, PROTECTION_OFF); // Start Audio protection const uint32_t session_id3 = connection_handler_->OnSessionStartedCallback( - uid_, start_session_id_, kAudio, PROTECTION_ON, &out_hash_id_); + uid_, start_session_id_, kAudio, PROTECTION_ON, &out_hash_id_); #ifdef ENABLE_SECURITY EXPECT_EQ(start_session_id_, session_id3); EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, out_hash_id_); - CheckService(uid_, start_session_id_, kAudio, - NULL, - PROTECTION_ON); + CheckService(uid_, start_session_id_, kAudio, NULL, PROTECTION_ON); #else EXPECT_EQ(0u, session_id3); EXPECT_EQ(protocol_handler::HASH_ID_WRONG, out_hash_id_); @@ -876,12 +1256,10 @@ TEST_F(ConnectionHandlerTest, SessionStarted_DealyProtectBulk) { AddTestSession(); const uint32_t session_id_new = connection_handler_->OnSessionStartedCallback( - uid_, start_session_id_, kBulk, PROTECTION_ON, NULL); + uid_, start_session_id_, kBulk, PROTECTION_ON, NULL); #ifdef ENABLE_SECURITY EXPECT_EQ(start_session_id_, session_id_new); - CheckService(uid_, start_session_id_, kRpc, - NULL, - PROTECTION_ON); + CheckService(uid_, start_session_id_, kRpc, NULL, PROTECTION_ON); #else EXPECT_EQ(0u, session_id_new); CheckService(uid_, start_session_id_, kRpc, NULL, PROTECTION_OFF); @@ -892,40 +1270,41 @@ TEST_F(ConnectionHandlerTest, SessionStarted_DealyProtectBulk) { TEST_F(ConnectionHandlerTest, SetSSLContext_Null) { // No SSLContext on start up EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kControl), - reinterpret_cast<security_manager::SSLContext *>(NULL)); + reinterpret_cast<security_manager::SSLContext*>(NULL)); EXPECT_EQ(::security_manager::SecurityManager::ERROR_INTERNAL, - connection_handler_->SetSSLContext(connection_key_, NULL)); + connection_handler_->SetSSLContext(connection_key_, NULL)); // No SSLContext after error EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kControl), - reinterpret_cast<security_manager::SSLContext *>(NULL)); + reinterpret_cast<security_manager::SSLContext*>(NULL)); AddTestDeviceConnection(); EXPECT_EQ(::security_manager::SecurityManager::ERROR_INTERNAL, - connection_handler_->SetSSLContext(connection_key_, NULL)); + connection_handler_->SetSSLContext(connection_key_, NULL)); // No SSLContext after error EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kControl), - reinterpret_cast<security_manager::SSLContext *>(NULL)); + reinterpret_cast<security_manager::SSLContext*>(NULL)); AddTestSession(); EXPECT_EQ(::security_manager::SecurityManager::ERROR_SUCCESS, - connection_handler_->SetSSLContext(connection_key_, NULL)); + connection_handler_->SetSSLContext(connection_key_, NULL)); // NULL SSLContext after success EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kControl), - reinterpret_cast<security_manager::SSLContext *>(NULL)); + reinterpret_cast<security_manager::SSLContext*>(NULL)); } + TEST_F(ConnectionHandlerTest, SetSSLContext) { // No SSLContext on start up EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kControl), - reinterpret_cast<security_manager::SSLContext *>(NULL)); + reinterpret_cast<security_manager::SSLContext*>(NULL)); - testing::StrictMock<security_manager_test::SSLContextMock> mock_ssl_context; + testing::StrictMock<security_manager_test::MockSSLContext> mock_ssl_context; // Error on no connection EXPECT_EQ( connection_handler_->SetSSLContext(connection_key_, &mock_ssl_context), ::security_manager::SecurityManager::ERROR_INTERNAL); // No SSLContext after error EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kControl), - reinterpret_cast<security_manager::SSLContext *>(NULL)); + reinterpret_cast<security_manager::SSLContext*>(NULL)); AddTestDeviceConnection(); // Error on no session @@ -934,7 +1313,7 @@ TEST_F(ConnectionHandlerTest, SetSSLContext) { ::security_manager::SecurityManager::ERROR_INTERNAL); // No SSLContext after error EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kControl), - reinterpret_cast<security_manager::SSLContext *>(NULL)); + reinterpret_cast<security_manager::SSLContext*>(NULL)); AddTestSession(); // Success EXPECT_EQ( @@ -942,24 +1321,24 @@ TEST_F(ConnectionHandlerTest, SetSSLContext) { ::security_manager::SecurityManager::ERROR_SUCCESS); // SSLContext set on Success EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kControl), - &mock_ssl_context); + &mock_ssl_context); // Null SSLContext for unprotected services EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kRpc), - reinterpret_cast<security_manager::SSLContext *>(NULL)); + reinterpret_cast<security_manager::SSLContext*>(NULL)); EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kBulk), - reinterpret_cast<security_manager::SSLContext *>(NULL)); + reinterpret_cast<security_manager::SSLContext*>(NULL)); EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kAudio), - reinterpret_cast<security_manager::SSLContext *>(NULL)); + reinterpret_cast<security_manager::SSLContext*>(NULL)); EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kMobileNav), - reinterpret_cast<security_manager::SSLContext *>(NULL)); + reinterpret_cast<security_manager::SSLContext*>(NULL)); } TEST_F(ConnectionHandlerTest, GetSSLContext_ByProtectedService) { // No SSLContext on start up EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kControl), - reinterpret_cast<security_manager::SSLContext *>(NULL)); + reinterpret_cast<security_manager::SSLContext*>(NULL)); - testing::StrictMock<security_manager_test::SSLContextMock> mock_ssl_context; + testing::StrictMock<security_manager_test::MockSSLContext> mock_ssl_context; AddTestDeviceConnection(); AddTestSession(); EXPECT_EQ( @@ -967,11 +1346,11 @@ TEST_F(ConnectionHandlerTest, GetSSLContext_ByProtectedService) { ::security_manager::SecurityManager::ERROR_SUCCESS); // kControl service mean - return for all connection EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kControl), - &mock_ssl_context); + &mock_ssl_context); // kAudio is not exists yet EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kAudio), - reinterpret_cast<security_manager::SSLContext *>(NULL)); + reinterpret_cast<security_manager::SSLContext*>(NULL)); // Open kAudio service const uint32_t session_id = connection_handler_->OnSessionStartedCallback( uid_, start_session_id_, kAudio, PROTECTION_ON, NULL); @@ -980,21 +1359,22 @@ TEST_F(ConnectionHandlerTest, GetSSLContext_ByProtectedService) { // kAudio is not exists yet EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kAudio), - &mock_ssl_context); + &mock_ssl_context); } + TEST_F(ConnectionHandlerTest, GetSSLContext_ByDealyProtectedRPC) { - testing::StrictMock<security_manager_test::SSLContextMock> mock_ssl_context; + testing::StrictMock<security_manager_test::MockSSLContext> mock_ssl_context; AddTestDeviceConnection(); AddTestSession(); EXPECT_EQ( connection_handler_->SetSSLContext(connection_key_, &mock_ssl_context), ::security_manager::SecurityManager::ERROR_SUCCESS); EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kControl), - &mock_ssl_context); + &mock_ssl_context); // kRpc is not protected EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kRpc), - reinterpret_cast<security_manager::SSLContext *>(NULL)); + reinterpret_cast<security_manager::SSLContext*>(NULL)); // Protect kRpc (Bulk will be protect also) const uint32_t session_id = connection_handler_->OnSessionStartedCallback( @@ -1004,24 +1384,25 @@ TEST_F(ConnectionHandlerTest, GetSSLContext_ByDealyProtectedRPC) { // kRpc is protected EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kRpc), - &mock_ssl_context); + &mock_ssl_context); // kBulk is protected EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kBulk), - &mock_ssl_context); + &mock_ssl_context); } + TEST_F(ConnectionHandlerTest, GetSSLContext_ByDealyProtectedBulk) { - testing::StrictMock<security_manager_test::SSLContextMock> mock_ssl_context; + testing::StrictMock<security_manager_test::MockSSLContext> mock_ssl_context; AddTestDeviceConnection(); AddTestSession(); EXPECT_EQ( connection_handler_->SetSSLContext(connection_key_, &mock_ssl_context), ::security_manager::SecurityManager::ERROR_SUCCESS); EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kControl), - &mock_ssl_context); + &mock_ssl_context); // kRpc is not protected EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kRpc), - reinterpret_cast<security_manager::SSLContext *>(NULL)); + reinterpret_cast<security_manager::SSLContext*>(NULL)); // Protect Bulk (kRpc will be protected also) const uint32_t session_id = connection_handler_->OnSessionStartedCallback( @@ -1031,13 +1412,22 @@ TEST_F(ConnectionHandlerTest, GetSSLContext_ByDealyProtectedBulk) { // kRpc is protected EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kRpc), - &mock_ssl_context); + &mock_ssl_context); // kBulk is protected EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kBulk), - &mock_ssl_context); + &mock_ssl_context); } #endif // ENABLE_SECURITY -} // namespace connection_handle_test +TEST_F(ConnectionHandlerTest, SendHeartBeat) { + // Add virtual device and connection + AddTestDeviceConnection(); + AddTestSession(); + connection_handler_->set_protocol_handler(&mock_protocol_handler_); + EXPECT_CALL(mock_protocol_handler_, SendHeartBeat(uid_, start_session_id_)); + connection_handler_->SendHeartBeat(uid_, start_session_id_); +} + +} // namespace connection_handler_test } // namespace components } // namespace test diff --git a/src/components/connection_handler/test/connection_test.cc b/src/components/connection_handler/test/connection_test.cc index a1e9307ce3..e36e9aa65c 100644 --- a/src/components/connection_handler/test/connection_test.cc +++ b/src/components/connection_handler/test/connection_test.cc @@ -30,14 +30,18 @@ * POSSIBILITY OF SUCH DAMAGE. */ -#include <gtest/gtest.h> #include <algorithm> + +#include "gtest/gtest.h" + #include "protocol/common.h" #include "connection_handler/connection.h" #include "connection_handler/connection_handler_impl.h" #include "protocol/service_type.h" -#include "utils/shared_ptr.h" -#include "security_manager_mock.h" +#include "connection_handler/mock_connection_handler_settings.h" +#include "transport_manager/mock_transport_manager.h" +#include "security_manager/mock_security_manager.h" +#include "security_manager/mock_ssl_context.h" #define EXPECT_RETURN_TRUE true #define EXPECT_RETURN_FALSE false @@ -46,24 +50,25 @@ namespace test { namespace components { -namespace connection_handle { +namespace connection_handler_test { using namespace ::connection_handler; using namespace ::protocol_handler; class ConnectionTest : public ::testing::Test { protected: void SetUp() OVERRIDE { - connection_handler_ = ConnectionHandlerImpl::instance(); + connection_handler_ = new ConnectionHandlerImpl( + mock_connection_handler_settings, transport_manager_mock); const ConnectionHandle connectionHandle = 0; - const DeviceHandle device_handle = 0; - connection_.reset( - new Connection(connectionHandle, device_handle, connection_handler_, - 10000)); + const DeviceHandle device_handle = 0u; + const uint32_t heart_beat = 10000u; + connection_ = new Connection( + connectionHandle, device_handle, connection_handler_, heart_beat); } void TearDown() OVERRIDE { - connection_.reset(); - ConnectionHandlerImpl::destroy(); + delete connection_; + delete connection_handler_; } void StartSession() { session_id = connection_->AddNewSession(); @@ -72,17 +77,17 @@ class ConnectionTest : public ::testing::Test { EXPECT_FALSE(sessionMap.empty()); const ServiceList serviceList = sessionMap.begin()->second.service_list; EXPECT_FALSE(serviceList.empty()); - const ServiceList::const_iterator it = std::find(serviceList.begin(), - serviceList.end(), - protocol_handler::kRpc); - EXPECT_NE(it, serviceList.end()); + const ServiceList::const_iterator it = + std::find(serviceList.begin(), serviceList.end(), kRpc); + const bool found_result = (it != serviceList.end()); + EXPECT_TRUE(found_result); } - void AddNewService(const protocol_handler::ServiceType service_type, + void AddNewService(const ServiceType service_type, const bool protection, const bool expect_add_new_service_call_result, const bool expect_exist_service) { - const bool result = connection_->AddNewService(session_id, service_type, - protection); + const bool result = + connection_->AddNewService(session_id, service_type, protection); EXPECT_EQ(result, expect_add_new_service_call_result); #ifdef ENABLE_SECURITY @@ -94,9 +99,8 @@ class ConnectionTest : public ::testing::Test { EXPECT_FALSE(session_map.empty()); const ServiceList newServiceList = session_map.begin()->second.service_list; EXPECT_FALSE(newServiceList.empty()); - const ServiceList::const_iterator it = std::find(newServiceList.begin(), - newServiceList.end(), - service_type); + const ServiceList::const_iterator it = + std::find(newServiceList.begin(), newServiceList.end(), service_type); const bool found_result = it != newServiceList.end(); EXPECT_EQ(expect_exist_service, found_result); #ifdef ENABLE_SECURITY @@ -107,7 +111,7 @@ class ConnectionTest : public ::testing::Test { #endif // ENABLE_SECURITY } - void RemoveService(const protocol_handler::ServiceType service_type, + void RemoveService(const ServiceType service_type, const bool expect_remove_service_result, const bool expect_exist_service) { const bool result = connection_->RemoveService(session_id, service_type); @@ -115,22 +119,23 @@ class ConnectionTest : public ::testing::Test { const SessionMap newSessionMap = connection_->session_map(); EXPECT_FALSE(newSessionMap.empty()); - const ServiceList newServiceList = newSessionMap.begin()->second - .service_list; + const ServiceList newServiceList = + newSessionMap.begin()->second.service_list; EXPECT_FALSE(newServiceList.empty()); - const ServiceList::const_iterator it = std::find(newServiceList.begin(), - newServiceList.end(), - service_type); - const bool found_result = it != newServiceList.end(); + const ServiceList::const_iterator it = + std::find(newServiceList.begin(), newServiceList.end(), service_type); + const bool found_result = (it != newServiceList.end()); EXPECT_EQ(expect_exist_service, found_result); } - ::utils::SharedPtr<Connection> connection_; + Connection* connection_; + MockConnectionHandlerSettings mock_connection_handler_settings; + testing::StrictMock<transport_manager_test::MockTransportManager> + transport_manager_mock; ConnectionHandlerImpl* connection_handler_; uint32_t session_id; }; - TEST_F(ConnectionTest, Session_TryGetProtocolVersionWithoutSession) { uint8_t protocol_version; EXPECT_FALSE(connection_->ProtocolVersion(session_id, protocol_version)); @@ -140,14 +145,14 @@ TEST_F(ConnectionTest, Session_GetDefaultProtocolVersion) { StartSession(); uint8_t protocol_version; EXPECT_TRUE(connection_->ProtocolVersion(session_id, protocol_version)); - EXPECT_EQ(protocol_version, ::protocol_handler::PROTOCOL_VERSION_2); + EXPECT_EQ(static_cast<uint8_t>(PROTOCOL_VERSION_2), protocol_version); } TEST_F(ConnectionTest, Session_UpdateProtocolVersion) { StartSession(); - uint8_t protocol_version = ::protocol_handler::PROTOCOL_VERSION_3; + uint8_t protocol_version = static_cast<uint8_t>(PROTOCOL_VERSION_3); connection_->UpdateProtocolVersionSession(session_id, protocol_version); EXPECT_TRUE(connection_->ProtocolVersion(session_id, protocol_version)); - EXPECT_EQ(protocol_version, ::protocol_handler::PROTOCOL_VERSION_3); + EXPECT_EQ(static_cast<uint8_t>(PROTOCOL_VERSION_3), protocol_version); } TEST_F(ConnectionTest, HeartBeat_NotSupported) { @@ -155,44 +160,64 @@ TEST_F(ConnectionTest, HeartBeat_NotSupported) { StartSession(); uint8_t protocol_version; EXPECT_TRUE(connection_->ProtocolVersion(session_id, protocol_version)); - EXPECT_EQ(protocol_version, ::protocol_handler::PROTOCOL_VERSION_2); + EXPECT_EQ(static_cast<uint8_t>(PROTOCOL_VERSION_2), protocol_version); // Assert EXPECT_FALSE(connection_->SupportHeartBeat(session_id)); } -TEST_F(ConnectionTest, DISABLED_HeartBeat_Supported) { +TEST_F(ConnectionTest, HeartBeat_Protocol3_Supported) { // Arrange StartSession(); - - // Check if protocol version is 3 - uint8_t protocol_version = ::protocol_handler::PROTOCOL_VERSION_3; + // Check execution if protocol version is 3 + const uint8_t protocol_version = static_cast<uint8_t>(PROTOCOL_VERSION_3); connection_->UpdateProtocolVersionSession(session_id, protocol_version); - EXPECT_EQ(protocol_version, ::protocol_handler::PROTOCOL_VERSION_3); + EXPECT_TRUE(connection_->SupportHeartBeat(session_id)); +} - // Assert +TEST_F(ConnectionTest, HeartBeat_Protocol4_PositiveHeartBeat_Supported) { + // Arrange + StartSession(); + // Check execution if protocol version is 4 + const uint8_t protocol_version = static_cast<uint8_t>(PROTOCOL_VERSION_4); + connection_->UpdateProtocolVersionSession(session_id, protocol_version); EXPECT_TRUE(connection_->SupportHeartBeat(session_id)); } +TEST_F(ConnectionTest, HeartBeat_Protocol4_ZeroHeartBeat_NotSupported) { + // Correctc of connection (need connection with heartbeat=0) + delete connection_; + connection_ = 0; + + const ConnectionHandle connectionHandle = 0; + const DeviceHandle device_handle = 0u; + const uint32_t heart_beat = 0u; + connection_ = new Connection( + connectionHandle, device_handle, connection_handler_, heart_beat); + StartSession(); + // Check execution if protocol version is 4 + const uint8_t protocol_version = static_cast<uint8_t>(PROTOCOL_VERSION_4); + connection_->UpdateProtocolVersionSession(session_id, protocol_version); + EXPECT_FALSE(connection_->SupportHeartBeat(session_id)); +} + // Try to add service without session TEST_F(ConnectionTest, Session_AddNewServiceWithoutSession) { - EXPECT_EQ( - connection_->AddNewService(session_id, protocol_handler::kAudio, true), - EXPECT_RETURN_FALSE); - EXPECT_EQ( - connection_->AddNewService(session_id, protocol_handler::kAudio, false), - EXPECT_RETURN_FALSE); - EXPECT_EQ( - connection_->AddNewService(session_id, protocol_handler::kMobileNav, true), - EXPECT_RETURN_FALSE); - EXPECT_EQ( - connection_->AddNewService(session_id, protocol_handler::kMobileNav, false), - EXPECT_RETURN_FALSE); + EXPECT_EQ(connection_->AddNewService(session_id, kAudio, true), + EXPECT_RETURN_FALSE); + EXPECT_EQ(connection_->AddNewService(session_id, kAudio, false), + EXPECT_RETURN_FALSE); + EXPECT_EQ(connection_->AddNewService(session_id, kMobileNav, true), + EXPECT_RETURN_FALSE); + EXPECT_EQ(connection_->AddNewService(session_id, kMobileNav, false), + EXPECT_RETURN_FALSE); } // Try to remove service without session TEST_F(ConnectionTest, Session_RemoveServiceWithoutSession) { - EXPECT_EQ(connection_->RemoveService(session_id, protocol_handler::kAudio), + EXPECT_EQ(connection_->RemoveService(session_id, kAudio), + EXPECT_RETURN_FALSE); + EXPECT_EQ(connection_->RemoveService(session_id, kMobileNav), EXPECT_RETURN_FALSE); EXPECT_EQ( connection_->RemoveService(session_id, protocol_handler::kMobileNav), @@ -201,70 +226,67 @@ TEST_F(ConnectionTest, Session_RemoveServiceWithoutSession) { // Try to remove RPC TEST_F(ConnectionTest, Session_RemoveRPCBulk) { StartSession(); - EXPECT_EQ(connection_->RemoveService(session_id, protocol_handler::kRpc), - EXPECT_RETURN_FALSE); - EXPECT_EQ(connection_->RemoveService(session_id, protocol_handler::kBulk), - EXPECT_RETURN_FALSE); + EXPECT_EQ(connection_->RemoveService(session_id, kRpc), EXPECT_RETURN_FALSE); + EXPECT_EQ(connection_->RemoveService(session_id, kBulk), EXPECT_RETURN_FALSE); } // Control Service could not be started anyway TEST_F(ConnectionTest, Session_AddControlService) { StartSession(); - - AddNewService(protocol_handler::kControl, PROTECTION_OFF, EXPECT_RETURN_FALSE, - EXPECT_SERVICE_NOT_EXISTS); - AddNewService(protocol_handler::kControl, PROTECTION_ON, EXPECT_RETURN_FALSE, - EXPECT_SERVICE_NOT_EXISTS); + AddNewService( + kControl, PROTECTION_OFF, EXPECT_RETURN_FALSE, EXPECT_SERVICE_NOT_EXISTS); + AddNewService( + kControl, PROTECTION_ON, EXPECT_RETURN_FALSE, EXPECT_SERVICE_NOT_EXISTS); } // Invalid Services couldnot be started anyway TEST_F(ConnectionTest, Session_AddInvalidService) { StartSession(); - AddNewService(protocol_handler::kInvalidServiceType, PROTECTION_OFF, - EXPECT_RETURN_FALSE, EXPECT_SERVICE_NOT_EXISTS); - AddNewService(protocol_handler::kInvalidServiceType, PROTECTION_ON, - EXPECT_RETURN_FALSE, EXPECT_SERVICE_NOT_EXISTS); + AddNewService(kInvalidServiceType, + PROTECTION_OFF, + EXPECT_RETURN_FALSE, + EXPECT_SERVICE_NOT_EXISTS); + AddNewService(kInvalidServiceType, + PROTECTION_ON, + EXPECT_RETURN_FALSE, + EXPECT_SERVICE_NOT_EXISTS); } // RPC and Bulk Services could be only delay protected TEST_F(ConnectionTest, Session_AddRPCBulkServices) { StartSession(); - AddNewService(protocol_handler::kRpc, PROTECTION_OFF, - EXPECT_RETURN_FALSE, EXPECT_SERVICE_EXISTS); + AddNewService( + kRpc, PROTECTION_OFF, EXPECT_RETURN_FALSE, EXPECT_SERVICE_EXISTS); // Bulk shall not be added and shall be PROTECTION_OFF - AddNewService(protocol_handler::kBulk, PROTECTION_OFF, - EXPECT_RETURN_FALSE, EXPECT_SERVICE_EXISTS); + AddNewService( + kBulk, PROTECTION_OFF, EXPECT_RETURN_FALSE, EXPECT_SERVICE_EXISTS); #ifdef ENABLE_SECURITY - AddNewService(protocol_handler::kRpc, PROTECTION_ON, - EXPECT_RETURN_TRUE, - EXPECT_SERVICE_EXISTS); + AddNewService(kRpc, PROTECTION_ON, EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS); #else - AddNewService(protocol_handler::kRpc, PROTECTION_ON, - EXPECT_RETURN_FALSE, EXPECT_SERVICE_EXISTS); + AddNewService( + kRpc, PROTECTION_ON, EXPECT_RETURN_FALSE, EXPECT_SERVICE_EXISTS); #endif // ENABLE_SECURITY // Bulk shall not be added and shall be PROTECTION_ON - AddNewService(protocol_handler::kBulk, PROTECTION_ON, - EXPECT_RETURN_FALSE, EXPECT_SERVICE_EXISTS); + AddNewService( + kBulk, PROTECTION_ON, EXPECT_RETURN_FALSE, EXPECT_SERVICE_EXISTS); } TEST_F(ConnectionTest, Session_AddAllOtherService_Unprotected) { StartSession(); - - AddNewService(protocol_handler::kAudio, PROTECTION_OFF, - EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS); - AddNewService(protocol_handler::kMobileNav, PROTECTION_OFF, - EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS); + AddNewService( + kAudio, PROTECTION_OFF, EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS); + AddNewService( + kMobileNav, PROTECTION_OFF, EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS); } TEST_F(ConnectionTest, Session_AddAllOtherService_Protected) { StartSession(); - - AddNewService(protocol_handler::kAudio, PROTECTION_ON, - EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS); - AddNewService(protocol_handler::kMobileNav, PROTECTION_ON, - EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS); + AddNewService( + kAudio, PROTECTION_ON, EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS); + AddNewService( + kMobileNav, PROTECTION_ON, EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS); } TEST_F(ConnectionTest, FindAddedService) { @@ -272,82 +294,79 @@ TEST_F(ConnectionTest, FindAddedService) { // Arrange SessionMap currentSessionMap = connection_->session_map(); - Service * sessionWithService = currentSessionMap.find(session_id)->second - .FindService(protocol_handler::kAudio); + Service* sessionWithService = + currentSessionMap.find(session_id)->second.FindService(kAudio); EXPECT_EQ(NULL, sessionWithService); // Act - AddNewService(protocol_handler::kAudio, PROTECTION_OFF, - EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS); + AddNewService( + kAudio, PROTECTION_OFF, EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS); currentSessionMap = connection_->session_map(); // Expect that service is existing - sessionWithService = currentSessionMap.find(session_id)->second.FindService( - protocol_handler::kAudio); + sessionWithService = + currentSessionMap.find(session_id)->second.FindService(kAudio); EXPECT_TRUE(sessionWithService != NULL); } TEST_F(ConnectionTest, Session_RemoveAddedService) { StartSession(); - AddNewService(protocol_handler::kAudio, PROTECTION_OFF, - EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS); + AddNewService( + kAudio, PROTECTION_OFF, EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS); - EXPECT_EQ(connection_->RemoveService(session_id, protocol_handler::kAudio), - EXPECT_RETURN_TRUE); + EXPECT_EQ(connection_->RemoveService(session_id, kAudio), EXPECT_RETURN_TRUE); // Try delete nonexisting service - EXPECT_EQ(connection_->RemoveService(session_id, protocol_handler::kAudio), + EXPECT_EQ(connection_->RemoveService(session_id, kAudio), EXPECT_RETURN_FALSE); } TEST_F(ConnectionTest, Session_AddAllOtherService_DelayProtected1) { StartSession(); - AddNewService(protocol_handler::kAudio, PROTECTION_OFF, - EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS); + AddNewService( + kAudio, PROTECTION_OFF, EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS); - AddNewService(protocol_handler::kMobileNav, PROTECTION_OFF, - EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS); + AddNewService( + kMobileNav, PROTECTION_OFF, EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS); #ifdef ENABLE_SECURITY - AddNewService(protocol_handler::kAudio, PROTECTION_ON, - EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS); + AddNewService( + kAudio, PROTECTION_ON, EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS); - AddNewService(protocol_handler::kMobileNav, PROTECTION_ON, - EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS); + AddNewService( + kMobileNav, PROTECTION_ON, EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS); #else - AddNewService(protocol_handler::kAudio, PROTECTION_ON, - EXPECT_RETURN_FALSE, EXPECT_SERVICE_EXISTS); + AddNewService( + kAudio, PROTECTION_ON, EXPECT_RETURN_FALSE, EXPECT_SERVICE_EXISTS); - AddNewService(protocol_handler::kMobileNav, PROTECTION_ON, - EXPECT_RETURN_FALSE, EXPECT_SERVICE_EXISTS); + AddNewService( + kMobileNav, PROTECTION_ON, EXPECT_RETURN_FALSE, EXPECT_SERVICE_EXISTS); #endif // ENABLE_SECURITY } // Use other order TEST_F(ConnectionTest, Session_AddAllOtherService_DelayProtected2) { StartSession(); - - AddNewService(protocol_handler::kAudio, PROTECTION_OFF, - EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS); + AddNewService( + kAudio, PROTECTION_OFF, EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS); #ifdef ENABLE_SECURITY - AddNewService(protocol_handler::kAudio, PROTECTION_ON, - EXPECT_RETURN_TRUE, - EXPECT_SERVICE_EXISTS); + AddNewService( + kAudio, PROTECTION_ON, EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS); #else - AddNewService(protocol_handler::kAudio, PROTECTION_ON, - EXPECT_RETURN_FALSE, EXPECT_SERVICE_EXISTS); + AddNewService( + kAudio, PROTECTION_ON, EXPECT_RETURN_FALSE, EXPECT_SERVICE_EXISTS); #endif // ENABLE_SECURITY - AddNewService(protocol_handler::kMobileNav, PROTECTION_OFF, - EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS); + AddNewService( + kMobileNav, PROTECTION_OFF, EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS); #ifdef ENABLE_SECURITY - AddNewService(protocol_handler::kMobileNav, PROTECTION_ON, - EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS); + AddNewService( + kMobileNav, PROTECTION_ON, EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS); #else - AddNewService(protocol_handler::kMobileNav, PROTECTION_ON, - EXPECT_RETURN_FALSE, EXPECT_SERVICE_EXISTS); + AddNewService( + kMobileNav, PROTECTION_ON, EXPECT_RETURN_FALSE, EXPECT_SERVICE_EXISTS); #endif // ENABLE_SECURITY } @@ -360,86 +379,84 @@ TEST_F(ConnectionTest, RemoveSession) { #ifdef ENABLE_SECURITY TEST_F(ConnectionTest, SetSSLContextWithoutSession) { - //random value. Session was not started + // random value. Session was not started uint8_t session_id = 10; - security_manager_test::SSLContextMock mock_ssl_context; + security_manager_test::MockSSLContext mock_ssl_context; int setResult = connection_->SetSSLContext(session_id, &mock_ssl_context); - EXPECT_EQ(security_manager::SecurityManager::ERROR_INTERNAL,setResult); + EXPECT_EQ(security_manager::SecurityManager::ERROR_INTERNAL, setResult); } TEST_F(ConnectionTest, GetSSLContextWithoutSession) { - //random value. Session was not started + // random value. Session was not started uint8_t session_id = 10; - EXPECT_EQ(NULL,connection_->GetSSLContext(session_id,protocol_handler::kMobileNav)); + EXPECT_EQ(NULL, connection_->GetSSLContext(session_id, kMobileNav)); } TEST_F(ConnectionTest, SetGetSSLContext) { StartSession(); - EXPECT_EQ(NULL,connection_->GetSSLContext(session_id,protocol_handler::kMobileNav)); - AddNewService(protocol_handler::kMobileNav, PROTECTION_ON, - EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS); + EXPECT_EQ(NULL, connection_->GetSSLContext(session_id, kMobileNav)); + AddNewService( + kMobileNav, PROTECTION_ON, EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS); - EXPECT_EQ(NULL,connection_->GetSSLContext(session_id,protocol_handler::kMobileNav)); + EXPECT_EQ(NULL, connection_->GetSSLContext(session_id, kMobileNav)); - security_manager_test::SSLContextMock mock_ssl_context; - //Set SSLContext + security_manager_test::MockSSLContext mock_ssl_context; + // Set SSLContext int setResult = connection_->SetSSLContext(session_id, &mock_ssl_context); - EXPECT_EQ(security_manager::SecurityManager::ERROR_SUCCESS,setResult); + EXPECT_EQ(security_manager::SecurityManager::ERROR_SUCCESS, setResult); - security_manager::SSLContext *result = connection_->GetSSLContext(session_id,protocol_handler::kMobileNav); - EXPECT_EQ(result,&mock_ssl_context); + security_manager::SSLContext* result = + connection_->GetSSLContext(session_id, kMobileNav); + EXPECT_EQ(result, &mock_ssl_context); } TEST_F(ConnectionTest, SetProtectionFlagForRPC) { StartSession(); // Arrange SessionMap currentSessionMap = connection_->session_map(); - Service * service_rpc = currentSessionMap.find(session_id)->second - .FindService(protocol_handler::kRpc); + Service* service_rpc = + currentSessionMap.find(session_id)->second.FindService(kRpc); EXPECT_FALSE(service_rpc->is_protected_); - Service * service_bulk = currentSessionMap.find(session_id)->second - .FindService(protocol_handler::kBulk); + Service* service_bulk = + currentSessionMap.find(session_id)->second.FindService(kBulk); EXPECT_FALSE(service_bulk->is_protected_); // Expect that service protection is enabled - connection_->SetProtectionFlag(session_id, protocol_handler::kRpc); + connection_->SetProtectionFlag(session_id, kRpc); currentSessionMap = connection_->session_map(); - service_bulk = currentSessionMap.find(session_id)->second - .FindService(protocol_handler::kBulk); + service_bulk = currentSessionMap.find(session_id)->second.FindService(kBulk); EXPECT_TRUE(service_bulk->is_protected_); - service_rpc = currentSessionMap.find(session_id)->second - .FindService(protocol_handler::kRpc); + service_rpc = currentSessionMap.find(session_id)->second.FindService(kRpc); EXPECT_TRUE(service_rpc->is_protected_); } - TEST_F(ConnectionTest, SetProtectionFlagForBulk) { StartSession(); // Arrange SessionMap currentSessionMap = connection_->session_map(); - Service * service_rpc = currentSessionMap.find(session_id)->second - .FindService(protocol_handler::kRpc); + Service* service_rpc = + currentSessionMap.find(session_id)->second.FindService(kRpc); EXPECT_FALSE(service_rpc->is_protected_); - Service * service_bulk = currentSessionMap.find(session_id)->second - .FindService(protocol_handler::kBulk); + Service* service_bulk = + currentSessionMap.find(session_id)->second.FindService(kBulk); EXPECT_FALSE(service_bulk->is_protected_); // Expect that service protection is enabled - connection_->SetProtectionFlag(session_id, protocol_handler::kBulk); + connection_->SetProtectionFlag(session_id, kBulk); currentSessionMap = connection_->session_map(); - service_bulk = currentSessionMap.find(session_id)->second.FindService(protocol_handler::kBulk); + service_bulk = currentSessionMap.find(session_id)->second.FindService(kBulk); EXPECT_TRUE(service_bulk->is_protected_); - service_rpc = currentSessionMap.find(session_id)->second.FindService(protocol_handler::kRpc); + service_rpc = currentSessionMap.find(session_id)->second.FindService(kRpc); EXPECT_TRUE(service_rpc->is_protected_); } @@ -448,4 +465,3 @@ TEST_F(ConnectionTest, SetProtectionFlagForBulk) { } // namespace connection_handle } // namespace components } // namespace test - diff --git a/src/components/connection_handler/test/device_test.cc b/src/components/connection_handler/test/device_test.cc index dc1a51faf1..ea9aa746b5 100644 --- a/src/components/connection_handler/test/device_test.cc +++ b/src/components/connection_handler/test/device_test.cc @@ -55,7 +55,8 @@ TEST(ConnectionDevice, CompareDevicesWithDifferentMacAddresses) { std::string hash_mac_address = test_device.mac_address(); std::string test_next_mac_address = "test_address_"; - Device next_test_device(device_handle, device_name, test_next_mac_address, connection_type); + Device next_test_device( + device_handle, device_name, test_next_mac_address, connection_type); EXPECT_NE(test_next_mac_address, next_test_device.mac_address()); std::string hash_next_mac_address = next_test_device.mac_address(); @@ -77,4 +78,3 @@ TEST(ConnectionDevice, MacAddressHash) { } // namespace connection_handle } // namespace components } // namespace test - diff --git a/src/components/connection_handler/test/heart_beat_monitor_test.cc b/src/components/connection_handler/test/heart_beat_monitor_test.cc index 710977c643..2c928fe458 100644 --- a/src/components/connection_handler/test/heart_beat_monitor_test.cc +++ b/src/components/connection_handler/test/heart_beat_monitor_test.cc @@ -32,12 +32,11 @@ #include <string> #include <iostream> -//#include <stdio.h> -#include "gmock/gmock.h" +#include "gtest/gtest.h" #include "connection_handler/heartbeat_monitor.h" #include "connection_handler/connection.h" #include "connection_handler/connection_handler.h" -#include "config_profile/profile.h" +#include "connection_handler/mock_connection_handler.h" namespace { const int32_t MILLISECONDS_IN_SECOND = 1000; @@ -50,91 +49,42 @@ namespace components { namespace connection_handler_test { using ::testing::_; -class ConnectionHandlerMock : public connection_handler::ConnectionHandler { +class HeartBeatMonitorTest : public testing::Test { public: - MOCK_METHOD1(set_connection_handler_observer, - void(connection_handler::ConnectionHandlerObserver*)); - MOCK_METHOD1(set_transport_manager, - void(transport_manager::TransportManager*)); - MOCK_METHOD0(StartTransportManager, - void()); - MOCK_METHOD1(ConnectToDevice, - void(connection_handler::DeviceHandle device_handle)); - MOCK_METHOD0(ConnectToAllDevices, - void()); - MOCK_METHOD1(CloseRevokedConnection, void(uint32_t connection_key)); - MOCK_METHOD1(CloseConnection, - void(connection_handler::ConnectionHandle connection_handle)); - MOCK_METHOD1(GetConnectionSessionsCount, uint32_t(uint32_t connection_key)); - MOCK_METHOD2(GetDeviceID, - bool(const std::string& mac_address, - connection_handler::DeviceHandle* device_handle)); - MOCK_CONST_METHOD1(GetConnectedDevicesMAC, void(std::vector<std::string> &device_macs)); - MOCK_METHOD2(CloseSession, - void(uint32_t key, - connection_handler::CloseSessionReason close_reason)); - MOCK_METHOD3(CloseSession, - void(connection_handler::ConnectionHandle connection_handle, - uint8_t session_id, - connection_handler::CloseSessionReason close_reason)); - MOCK_METHOD2(SendEndService, - void(uint32_t key, uint8_t service_type)); - - MOCK_METHOD1(StartSessionHeartBeat, - void(uint32_t key)); - MOCK_METHOD2(SendHeartBeat, - void(connection_handler::ConnectionHandle connection_handle, - uint8_t session_id)); - MOCK_METHOD2(SetHeartBeatTimeout, void(uint32_t connection_key, - uint32_t timeout)); - MOCK_METHOD2(BindProtocolVersionWithSession, - void(uint32_t connection_key, - uint8_t protocol_version)); - MOCK_METHOD4(GetDataOnSessionKey, - int32_t(uint32_t key, uint32_t* app_id, - std::list<int32_t>* sessions_list, - uint32_t* device_id)); -}; + HeartBeatMonitorTest() : conn(NULL) { + kTimeout = 5000u; + } -class HeartBeatMonitorTest : public testing::Test { -public: - HeartBeatMonitorTest(): - conn(NULL) { - profile::Profile::instance()->config_file_name("smartDeviceLink.ini"); - kTimeout = profile::Profile::instance()->heart_beat_timeout(); - } - -protected: - testing::NiceMock<ConnectionHandlerMock> connection_handler_mock; + protected: + testing::NiceMock<MockConnectionHandler> connection_handler_mock; connection_handler::Connection* conn; uint32_t kTimeout; - static const connection_handler::ConnectionHandle kConnectionHandle = 0xABCDEF; + static const connection_handler::ConnectionHandle kConnectionHandle = + 0xABCDEF; virtual void SetUp() { - conn = new connection_handler::Connection(kConnectionHandle, 0, - &connection_handler_mock, - kTimeout); + conn = new connection_handler::Connection( + kConnectionHandle, 0, &connection_handler_mock, kTimeout); } - virtual void TearDown() { + void TearDown() OVERRIDE { delete conn; } - }; -ACTION_P2(RemoveSession, conn, session_id){ +ACTION_P2(RemoveSession, conn, session_id) { conn->RemoveSession(session_id); } TEST_F(HeartBeatMonitorTest, TimerNotStarted) { - - // Whithout StartHeartBeat nothing to be call + // Whithout StartHeartBeat nothing to be call EXPECT_CALL(connection_handler_mock, CloseSession(_, _)).Times(0); EXPECT_CALL(connection_handler_mock, CloseConnection(_)).Times(0); EXPECT_CALL(connection_handler_mock, SendHeartBeat(_, _)).Times(0); conn->AddNewSession(); - usleep(kTimeout * MICROSECONDS_IN_MILLISECONDS + MICROSECONDS_IN_SECOND); + testing::Mock::AsyncVerifyAndClearExpectations( + kTimeout * MICROSECONDS_IN_MILLISECONDS + MICROSECONDS_IN_SECOND); } TEST_F(HeartBeatMonitorTest, TimerNotElapsed) { @@ -144,19 +94,21 @@ TEST_F(HeartBeatMonitorTest, TimerNotElapsed) { const uint32_t session = conn->AddNewSession(); conn->StartHeartBeat(session); - usleep(kTimeout * MICROSECONDS_IN_MILLISECONDS - MICROSECONDS_IN_SECOND); + testing::Mock::AsyncVerifyAndClearExpectations( + kTimeout * MICROSECONDS_IN_MILLISECONDS - MICROSECONDS_IN_SECOND); } TEST_F(HeartBeatMonitorTest, TimerElapsed) { const uint32_t session = conn->AddNewSession(); - EXPECT_CALL(connection_handler_mock, CloseSession(_, session,_)) - .WillOnce(RemoveSession(conn, session)); + EXPECT_CALL(connection_handler_mock, CloseSession(_, session, _)) + .WillOnce(RemoveSession(conn, session)); EXPECT_CALL(connection_handler_mock, CloseConnection(_)); EXPECT_CALL(connection_handler_mock, SendHeartBeat(_, session)); conn->StartHeartBeat(session); - usleep(2 * kTimeout * MICROSECONDS_IN_MILLISECONDS + MICROSECONDS_IN_SECOND); + testing::Mock::AsyncVerifyAndClearExpectations( + 2 * kTimeout * MICROSECONDS_IN_MILLISECONDS + MICROSECONDS_IN_SECOND); } TEST_F(HeartBeatMonitorTest, KeptAlive) { @@ -179,8 +131,8 @@ TEST_F(HeartBeatMonitorTest, NotKeptAlive) { const uint32_t session = conn->AddNewSession(); EXPECT_CALL(connection_handler_mock, SendHeartBeat(_, session)); - EXPECT_CALL(connection_handler_mock, CloseSession(_, session,_)) - .WillOnce(RemoveSession(conn, session)); + EXPECT_CALL(connection_handler_mock, CloseSession(_, session, _)) + .WillOnce(RemoveSession(conn, session)); EXPECT_CALL(connection_handler_mock, CloseConnection(_)); conn->StartHeartBeat(session); @@ -197,17 +149,18 @@ TEST_F(HeartBeatMonitorTest, TwoSessionsElapsed) { const uint32_t kSession1 = conn->AddNewSession(); const uint32_t kSession2 = conn->AddNewSession(); - EXPECT_CALL(connection_handler_mock, CloseSession(_, kSession1,_)) - .WillOnce(RemoveSession(conn, kSession1)); - EXPECT_CALL(connection_handler_mock, CloseSession(_, kSession2,_)) - .WillOnce(RemoveSession(conn, kSession2)); + EXPECT_CALL(connection_handler_mock, CloseSession(_, kSession1, _)) + .WillOnce(RemoveSession(conn, kSession1)); + EXPECT_CALL(connection_handler_mock, CloseSession(_, kSession2, _)) + .WillOnce(RemoveSession(conn, kSession2)); EXPECT_CALL(connection_handler_mock, CloseConnection(_)); EXPECT_CALL(connection_handler_mock, SendHeartBeat(_, kSession1)); EXPECT_CALL(connection_handler_mock, SendHeartBeat(_, kSession2)); conn->StartHeartBeat(kSession1); conn->StartHeartBeat(kSession2); - usleep(2 * kTimeout * MICROSECONDS_IN_MILLISECONDS + MICROSECONDS_IN_SECOND); + testing::Mock::AsyncVerifyAndClearExpectations( + 2 * kTimeout * MICROSECONDS_IN_MILLISECONDS + MICROSECONDS_IN_SECOND); } TEST_F(HeartBeatMonitorTest, IncreaseHeartBeatTimeout) { @@ -217,19 +170,19 @@ TEST_F(HeartBeatMonitorTest, IncreaseHeartBeatTimeout) { EXPECT_CALL(connection_handler_mock, CloseConnection(_)).Times(0); EXPECT_CALL(connection_handler_mock, SendHeartBeat(_, _)).Times(0); - const uint32_t kNewTimeout = kTimeout + MICROSECONDS_IN_MILLISECONDS; conn->StartHeartBeat(kSession); conn->SetHeartBeatTimeout(kNewTimeout, kSession); // new timeout greater by old timeout so mock object shouldn't be invoked - usleep(kTimeout * MICROSECONDS_IN_MILLISECONDS); + testing::Mock::AsyncVerifyAndClearExpectations(kTimeout * + MICROSECONDS_IN_MILLISECONDS); } TEST_F(HeartBeatMonitorTest, DecreaseHeartBeatTimeout) { const uint32_t kSession = conn->AddNewSession(); - EXPECT_CALL(connection_handler_mock, CloseSession(_, kSession,_)) - .WillOnce(RemoveSession(conn, kSession)); + EXPECT_CALL(connection_handler_mock, CloseSession(_, kSession, _)) + .WillOnce(RemoveSession(conn, kSession)); EXPECT_CALL(connection_handler_mock, CloseConnection(_)); EXPECT_CALL(connection_handler_mock, SendHeartBeat(_, kSession)); @@ -237,9 +190,10 @@ TEST_F(HeartBeatMonitorTest, DecreaseHeartBeatTimeout) { conn->StartHeartBeat(kSession); conn->SetHeartBeatTimeout(kNewTimeout, kSession); // new timeout less than old timeout so mock object should be invoked - usleep(kTimeout * 2 * MICROSECONDS_IN_MILLISECONDS); + testing::Mock::AsyncVerifyAndClearExpectations(kTimeout * 2 * + MICROSECONDS_IN_MILLISECONDS); } -} // namespace connection_handler_test -} // namespace components -} // namespace test +} // namespace connection_handler_test +} // namespace components +} // namespace test diff --git a/src/components/connection_handler/test/include/connection_handler_observer_mock.h b/src/components/connection_handler/test/include/connection_handler/connection_handler_observer_mock.h index 9a74375262..aa22f1aa1c 100644 --- a/src/components/connection_handler/test/include/connection_handler_observer_mock.h +++ b/src/components/connection_handler/test/include/connection_handler/connection_handler_observer_mock.h @@ -33,7 +33,7 @@ #ifndef SRC_COMPONENTS_CONNECTION_HANDLER_TEST_INCLUDE_CONNECTION_HANDLER_OBSERVER_MOCK_H_ #define SRC_COMPONENTS_CONNECTION_HANDLER_TEST_INCLUDE_CONNECTION_HANDLER_OBSERVER_MOCK_H_ -#include <gmock/gmock.h> +#include "gmock/gmock.h" #include <string> #include "connection_handler/connection_handler_observer.h" @@ -42,29 +42,31 @@ namespace components { namespace connection_handler_test { /* - * MOCK implementation of ::connection_handler::ConnectionHandlerObserver interface + * MOCK implementation of ::connection_handler::ConnectionHandlerObserver + * interface */ -class ConnectionHandlerObserverMock : public ::connection_handler::ConnectionHandlerObserver { +class ConnectionHandlerObserverMock + : public ::connection_handler::ConnectionHandlerObserver { public: MOCK_METHOD1(OnDeviceListUpdated, - void(const connection_handler::DeviceMap &device_list)); - MOCK_METHOD0(OnFindNewApplicationsRequest,void()); + void(const connection_handler::DeviceMap& device_list)); + MOCK_METHOD0(OnFindNewApplicationsRequest, void()); MOCK_METHOD1(RemoveDevice, - void(const connection_handler::DeviceHandle &device_handle)); + void(const connection_handler::DeviceHandle& device_handle)); MOCK_METHOD3(OnServiceStartedCallback, - bool(const connection_handler::DeviceHandle &device_handle, - const int32_t &session_key, - const protocol_handler::ServiceType &type)); - MOCK_METHOD3(OnServiceEndedCallback, - void(const int32_t &session_key, - const protocol_handler::ServiceType &type, + bool(const connection_handler::DeviceHandle& device_handle, + const int32_t& session_key, + const protocol_handler::ServiceType& type)); + MOCK_METHOD3( + OnServiceEndedCallback, + void(const int32_t& session_key, + const protocol_handler::ServiceType& type, const connection_handler::CloseSessionReason& close_reason)); - MOCK_CONST_METHOD1(GetHandshakeContext, - security_manager::SSLContext::HandshakeContext( - uint32_t key)); - + MOCK_CONST_METHOD1( + GetHandshakeContext, + security_manager::SSLContext::HandshakeContext(uint32_t key)); }; -} // namespace connection_handler_test -} // namespace components -} // namespace test -#endif //SRC_COMPONENTS_CONNECTION_HANDLER_TEST_INCLUDE_CONNECTION_HANDLER_OBSERVER_MOCK_H_ +} // namespace connection_handler_test +} // namespace components +} // namespace test +#endif // SRC_COMPONENTS_CONNECTION_HANDLER_TEST_INCLUDE_CONNECTION_HANDLER_OBSERVER_MOCK_H_ |