From 47629eedfa6bbb6c75acb8baec6f1fd932f0a76d Mon Sep 17 00:00:00 2001 From: sniukalov Date: Thu, 30 May 2019 09:32:08 +0300 Subject: [PATCH 01/19] Added OnServiceUpdate notification --- .../application_manager/message_helper.h | 31 ++++++- .../application_manager/smart_object_keys.h | 3 + .../on_service_status_update_notification.h | 85 +++++++++++++++++++ .../on_service_status_update_notification.cc | 63 ++++++++++++++ .../sdl_rpc_plugin/src/hmi_command_factory.cc | 5 ++ .../src/hmi_interfaces_impl.cc | 2 + .../src/message_helper/message_helper.cc | 41 +++++++++ .../src/smart_object_keys.cc | 3 + .../application_manager/mock_message_helper.h | 12 +++ .../test/mock_message_helper.cc | 20 +++++ src/components/interfaces/HMI_API.xml | 58 ++++++++++++- 11 files changed, 321 insertions(+), 2 deletions(-) create mode 100644 src/components/application_manager/rpc_plugins/sdl_rpc_plugin/include/sdl_rpc_plugin/commands/hmi/on_service_status_update_notification.h create mode 100644 src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/hmi/on_service_status_update_notification.cc diff --git a/src/components/application_manager/include/application_manager/message_helper.h b/src/components/application_manager/include/application_manager/message_helper.h index 8f05b523b3b..7dac442ef08 100644 --- a/src/components/application_manager/include/application_manager/message_helper.h +++ b/src/components/application_manager/include/application_manager/message_helper.h @@ -89,10 +89,39 @@ class MessageHelper { static smart_objects::SmartObjectSPtr CreateHMINotification( hmi_apis::FunctionID::eType function_id); + /** + * @brief CreateOnServiceStatusUpdateNotification creates on status update hmi + * notification smart object + * @param app_id - application id + * @param service_type - enum value representing service_type + * @param service_event - enum value representing service update event + * @return smart object containing on status update notification + */ + static smart_objects::SmartObjectSPtr CreateOnServiceStatusUpdateNotification( + const uint32_t app_id, + const hmi_apis::Common_ServiceType::eType service_type, + const hmi_apis::Common_ServiceEvent::eType service_event); + + /** + * @brief CreateOnServiceStatusUpdateNotification creates on status update hmi + * notification smart object + * @param app_id - application id + * @param service_type - enum value representing service_type + * @param service_event - enum value representing service update event + * @param service_event_reason - enum value representing service update reason + * @return smart object containing on status update notification + */ + static smart_objects::SmartObjectSPtr CreateOnServiceStatusUpdateNotification( + const uint32_t app_id, + const hmi_apis::Common_ServiceType::eType service_type, + const hmi_apis::Common_ServiceEvent::eType service_event, + const hmi_apis::Common_ServiceUpdateReason::eType service_update_reason); + /** * @brief Creates request for different interfaces(JSON) * @param correlation_id unique ID - * @param params Vector of arguments that we need in GetVehicleData request + * @param params Vector of arguments that we need in GetVehicleData + * request * (e.g. gps, odometer, fuel_level) */ static void CreateGetVehicleDataRequest( diff --git a/src/components/application_manager/include/application_manager/smart_object_keys.h b/src/components/application_manager/include/application_manager/smart_object_keys.h index 1d13417fa19..b3ca00013a2 100644 --- a/src/components/application_manager/include/application_manager/smart_object_keys.h +++ b/src/components/application_manager/include/application_manager/smart_object_keys.h @@ -616,6 +616,9 @@ extern const char* policyfile; extern const char* is_active; extern const char* is_deactivated; extern const char* event_name; +extern const char* service_type; +extern const char* service_event; +extern const char* reason; } // namespace hmi_notification diff --git a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/include/sdl_rpc_plugin/commands/hmi/on_service_status_update_notification.h b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/include/sdl_rpc_plugin/commands/hmi/on_service_status_update_notification.h new file mode 100644 index 00000000000..93f7da8b5ff --- /dev/null +++ b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/include/sdl_rpc_plugin/commands/hmi/on_service_status_update_notification.h @@ -0,0 +1,85 @@ +/* + * Copyright (c) 2019, Ford Motor Company + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following + * disclaimer in the documentation and/or other materials provided with the + * distribution. + * + * Neither the name of the Ford Motor Company nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_SDL_RPC_PLUGIN_INCLUDE_SDL_RPC_PLUGIN_COMMANDS_HMI_ON_SERVICE_STATUS_UPDATE_NOTIFICATION_H_ +#define SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_SDL_RPC_PLUGIN_INCLUDE_SDL_RPC_PLUGIN_COMMANDS_HMI_ON_SERVICE_STATUS_UPDATE_NOTIFICATION_H_ + +#include "application_manager/commands/notification_to_hmi.h" + +namespace sdl_rpc_plugin { +namespace app_mngr = application_manager; + +namespace commands { + +namespace hmi { + +/** + * @brief OnServiceStatusUpdateNotification command class + **/ +class OnServiceStatusUpdateNotification + : public app_mngr::commands::NotificationToHMI { + public: + /** + * @brief OnServiceStatusUpdateNotification class constructor + * @param application_manager ref to application manager + * @param rpc_service ref to rpc service + * @param hmi_capabilities ref to HMI capabilities + * @param policy_handle ref to policy handler + **/ + OnServiceStatusUpdateNotification( + const app_mngr::commands::MessageSharedPtr& message, + app_mngr::ApplicationManager& application_manager, + app_mngr::rpc_service::RPCService& rpc_service, + app_mngr::HMICapabilities& hmi_capabilities, + policy::PolicyHandlerInterface& policy_handle); + + /** + * @brief OnServiceStatusUpdateNotification class destructor + **/ + virtual ~OnServiceStatusUpdateNotification() OVERRIDE; + + /** + * @brief Execute command + **/ + void Run() OVERRIDE; + + private: + DISALLOW_COPY_AND_ASSIGN(OnServiceStatusUpdateNotification); +}; + +} // namespace hmi + +} // namespace commands + +} // namespace sdl_rpc_plugin + +#endif // SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_SDL_RPC_PLUGIN_INCLUDE_SDL_RPC_PLUGIN_COMMANDS_HMI_ON_SERVICE_STATUS_UPDATE_NOTIFICATION_H_ diff --git a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/hmi/on_service_status_update_notification.cc b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/hmi/on_service_status_update_notification.cc new file mode 100644 index 00000000000..8224325f8e1 --- /dev/null +++ b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/hmi/on_service_status_update_notification.cc @@ -0,0 +1,63 @@ +/* + * Copyright (c) 2019, Ford Motor Company + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following + * disclaimer in the documentation and/or other materials provided with the + * distribution. + * + * Neither the name of the Ford Motor Company nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#include "sdl_rpc_plugin/commands/hmi/on_service_status_update_notification.h" + +namespace sdl_rpc_plugin { +using namespace application_manager; + +namespace commands { + +namespace hmi { + +OnServiceStatusUpdateNotification::OnServiceStatusUpdateNotification( + const application_manager::commands::MessageSharedPtr& message, + ApplicationManager& application_manager, + rpc_service::RPCService& rpc_service, + HMICapabilities& hmi_capabilities, + policy::PolicyHandlerInterface& policy_handle) + : NotificationToHMI(message, + application_manager, + rpc_service, + hmi_capabilities, + policy_handle) {} + +OnServiceStatusUpdateNotification::~OnServiceStatusUpdateNotification() {} + +void OnServiceStatusUpdateNotification::Run() { + LOG4CXX_AUTO_TRACE(logger_); + + SendNotification(); +} +} // namespace hmi +} // namespace commands +} // namespace sdl_rpc_plugin diff --git a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/hmi_command_factory.cc b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/hmi_command_factory.cc index 27768e8a318..6ac398c0938 100644 --- a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/hmi_command_factory.cc +++ b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/hmi_command_factory.cc @@ -247,6 +247,7 @@ #include "sdl_rpc_plugin/commands/hmi/bc_get_file_path_request.h" #include "sdl_rpc_plugin/commands/hmi/bc_get_file_path_response.h" +#include "sdl_rpc_plugin/commands/hmi/on_service_status_update_notification.h" #include "sdl_rpc_plugin/commands/hmi/rc_get_capabilities_request.h" #include "sdl_rpc_plugin/commands/hmi/rc_get_capabilities_response.h" #include "sdl_rpc_plugin/commands/hmi/rc_is_ready_request.h" @@ -866,6 +867,10 @@ CommandCreator& HMICommandFactory::get_creator_factory( ? factory.GetCreator() : factory.GetCreator(); } + case hmi_apis::FunctionID::BasicCommunication_OnServiceUpdate: { + return factory + .GetCreator(); + } case hmi_apis::FunctionID::Navigation_OnWayPointChange: { return factory.GetCreator(); } diff --git a/src/components/application_manager/src/hmi_interfaces_impl.cc b/src/components/application_manager/src/hmi_interfaces_impl.cc index f1f8660217f..64ec2374a9d 100644 --- a/src/components/application_manager/src/hmi_interfaces_impl.cc +++ b/src/components/application_manager/src/hmi_interfaces_impl.cc @@ -103,6 +103,8 @@ generate_function_to_interface_convert_map() { HmiInterfaces::HMI_INTERFACE_BasicCommunication; convert_map[BasicCommunication_OnEventChanged] = HmiInterfaces::HMI_INTERFACE_BasicCommunication; + convert_map[BasicCommunication_OnServiceUpdate] = + HmiInterfaces::HMI_INTERFACE_BasicCommunication; convert_map[BasicCommunication_GetFilePath] = HmiInterfaces::HMI_INTERFACE_BasicCommunication; convert_map[BasicCommunication_CloseApplication] = diff --git a/src/components/application_manager/src/message_helper/message_helper.cc b/src/components/application_manager/src/message_helper/message_helper.cc index e2ed3fa8201..d99ca90916d 100644 --- a/src/components/application_manager/src/message_helper/message_helper.cc +++ b/src/components/application_manager/src/message_helper/message_helper.cc @@ -2234,6 +2234,47 @@ smart_objects::SmartObjectSPtr MessageHelper::CreateNegativeResponse( return std::make_shared(response_data); } +smart_objects::SmartObjectSPtr +MessageHelper::CreateOnServiceStatusUpdateNotification( + const uint32_t app_id, + const hmi_apis::Common_ServiceType::eType service_type, + const hmi_apis::Common_ServiceEvent::eType service_event) { + auto on_status_update_notification = CreateHMINotification( + hmi_apis::FunctionID::BasicCommunication_OnServiceUpdate); + + if (0 < app_id) { + (*on_status_update_notification)[strings::msg_params][strings::app_id] = + app_id; + } + + (*on_status_update_notification)[strings::msg_params] + [hmi_notification::service_type] = + service_type; + (*on_status_update_notification)[strings::msg_params] + [hmi_notification::service_event] = + service_event; + + return on_status_update_notification; +} + +smart_objects::SmartObjectSPtr +MessageHelper::CreateOnServiceStatusUpdateNotification( + const uint32_t app_id, + const hmi_apis::Common_ServiceType::eType service_type, + const hmi_apis::Common_ServiceEvent::eType service_event, + const hmi_apis::Common_ServiceUpdateReason::eType service_update_reason) { + auto notification = CreateOnServiceStatusUpdateNotification( + app_id, service_type, service_event); + + if (hmi_apis::Common_ServiceUpdateReason::eType::INVALID_ENUM != + service_update_reason) { + (*notification)[strings::msg_params][hmi_notification::reason] = + service_update_reason; + } + + return notification; +} + void MessageHelper::SendNaviSetVideoConfig( int32_t app_id, ApplicationManager& app_mngr, diff --git a/src/components/application_manager/src/smart_object_keys.cc b/src/components/application_manager/src/smart_object_keys.cc index 2efc04a7679..e67c87a234f 100644 --- a/src/components/application_manager/src/smart_object_keys.cc +++ b/src/components/application_manager/src/smart_object_keys.cc @@ -573,6 +573,9 @@ const char* policyfile = "policyfile"; const char* is_active = "isActive"; const char* is_deactivated = "isDeactivated"; const char* event_name = "eventName"; +const char* service_type = "serviceType"; +const char* service_event = "serviceEvent"; +const char* reason = "reason"; } // namespace hmi_notification } // namespace application_manager diff --git a/src/components/application_manager/test/include/application_manager/mock_message_helper.h b/src/components/application_manager/test/include/application_manager/mock_message_helper.h index 79718983ee3..f8a4253cb42 100644 --- a/src/components/application_manager/test/include/application_manager/mock_message_helper.h +++ b/src/components/application_manager/test/include/application_manager/mock_message_helper.h @@ -341,6 +341,18 @@ class MockMessageHelper { CreateDisplayCapabilityUpdateToMobile, smart_objects::SmartObjectSPtr(const smart_objects::SmartObject&, application_manager::Application&)); + MOCK_METHOD3(CreateOnServiceStatusUpdateNotification, + smart_objects::SmartObject( + const uint32_t app_id, + const hmi_apis::Common_ServiceType::eType service_type, + const hmi_apis::Common_ServiceEvent::eType service_event)); + MOCK_METHOD4(CreateOnServiceStatusUpdateNotification, + smart_objects::SmartObject( + const uint32_t app_id, + const hmi_apis::Common_ServiceType::eType service_type, + const hmi_apis::Common_ServiceEvent::eType service_event, + const hmi_apis::Common_ServiceUpdateReason::eType + service_update_reason)); static MockMessageHelper* message_helper_mock(); }; diff --git a/src/components/application_manager/test/mock_message_helper.cc b/src/components/application_manager/test/mock_message_helper.cc index 7002bb01577..4269e172dfc 100644 --- a/src/components/application_manager/test/mock_message_helper.cc +++ b/src/components/application_manager/test/mock_message_helper.cc @@ -601,6 +601,26 @@ void MessageHelper::SendUnsubscribeButtonNotification( ->SendUnsubscribeButtonNotification(button, application, app_mngr); } +smart_objects::SmartObject +MessageHelper::CreateOnServiceStatusUpdateNotification( + const uint32_t app_id, + const hmi_apis::Common_ServiceType::eType service_type, + const hmi_apis::Common_ServiceEvent::eType service_event) { + return MockMessageHelper::message_helper_mock() + ->CreateOnStatusUpdateNotification(app_id, service_type, service_event); +} + +smart_objects::SmartObject +MessageHelper::CreateOnServiceStatusUpdateNotification( + const uint32_t app_id, + const hmi_apis::Common_ServiceType::eType service_type, + const hmi_apis::Common_ServiceEvent::eType service_event, + const hmi_apis::Common_ServiceUpdateReason service_update_reason) { + return MockMessageHelper::message_helper_mock() + ->CreateOnStatusUpdateNotification( + app_id, service_type, service_event, service_update_reason); +} + smart_objects::SmartObject MessageHelper::CreateAppServiceCapabilities( std::vector& all_services) { return MockMessageHelper::message_helper_mock()->CreateAppServiceCapabilities( diff --git a/src/components/interfaces/HMI_API.xml b/src/components/interfaces/HMI_API.xml index df7fbbfbade..54cf2c14355 100644 --- a/src/components/interfaces/HMI_API.xml +++ b/src/components/interfaces/HMI_API.xml @@ -3538,7 +3538,7 @@ - + Specifies the version number of the SmartDeviceLink protocol that is supported by the mobile application or app service @@ -3552,6 +3552,42 @@ + + + Refers to the Video service. + + + Refers to the Audio service. + + + Refers to the RPC service. + + + + + + When a request for a Service is received. + + + When a request for a Service is Accepted. + + + When a request for a Service is Rejected. + + + + + + When a Service is rejected because the system was unable to get a required Policy Table Update. + + + When a Service is rejected because the security certificate is invalid/expired. + + + When a Service is rejected because the system was unable to get a valid SystemTime from HMI, which is required for certificate authentication. + + + @@ -4086,6 +4122,26 @@ + + + Must be sent by SDL to HMI when there is an update on status of certain services. + Services supported with current version: Video + + + Specifies the service which has been updated. + + + Specifies service update event. + + + + The reason for a service event. Certain events may not have a reason, such as when a service is ACCEPTED (which is the normal expected behavior). + + + + ID of the application which triggered the update. + + Request from SDL to HMI to obtain current UTC time. From 19e83e31fe80ab32c27eca8e269b915adb032c64 Mon Sep 17 00:00:00 2001 From: sniukalov Date: Thu, 30 May 2019 09:40:59 +0300 Subject: [PATCH 02/19] Added handling of service status update - introduced ServiceStatusUpdateHandler and ServiceStatusUpdateHandlerListener interfaces - added lacking interface functions to corresponding entities - added notification of listeners - introduced ServiceStatusUpdateNotificationBuilder - replaced shared_ptr with unique_ptr - moved SERVICE_RECEIVED --- src/appMain/life_cycle_impl.cc | 7 ++ .../application_manager_impl.h | 53 ++++++++++- .../application_manager/message_helper.h | 81 +++++++++++----- .../policies/policy_handler.h | 7 +- .../regular/policy_handler_observer.h | 2 + .../system_time/system_time_handler_impl.h | 6 ++ .../on_service_status_update_notification.h | 3 - ...c_communication_get_system_time_request.cc | 2 +- .../on_service_status_update_notification.cc | 2 +- ...munication_get_system_time_request_test.cc | 2 +- .../src/application_manager_impl.cc | 62 +++++++++++- .../src/message_helper/message_helper.cc | 64 ++++++------- .../src/policies/policy_handler.cc | 22 +++++ .../system_time/system_time_handler_impl.cc | 15 +++ .../application_manager/mock_message_helper.h | 20 ++++ .../message_helper/message_helper_test.cc | 8 ++ .../test/mock_message_helper.cc | 46 +++++---- .../policies/policy_handler_observer.h | 12 +++ .../policy_regular/policy/policy_listener.h | 5 + .../protocol_handler/protocol_handler.h | 12 ++- .../security_manager/security_manager.h | 18 +++- .../security_manager_listener.h | 17 +++- .../policy/mock_policy_listener.h | 1 + .../policy/mock_policy_listener.h | 1 + .../protocol_handler/mock_protocol_handler.h | 5 +- .../security_manager/mock_security_manager.h | 7 +- .../mock_security_manager_listener.h | 6 +- .../test/utils/mock_system_time_handler.h | 1 + .../include/policy/policy_manager_impl.h | 2 +- .../policy_regular/src/policy_manager_impl.cc | 17 +++- .../protocol_handler/CMakeLists.txt | 1 + .../protocol_handler/handshake_handler.h | 36 ++++++- .../protocol_handler/protocol_handler_impl.h | 25 +++-- .../service_status_update_handler.h | 86 +++++++++++++++++ .../service_status_update_handler_listener.h | 77 +++++++++++++++ .../protocol_handler/src/handshake_handler.cc | 95 ++++++++++++++----- .../src/protocol_handler_impl.cc | 53 +++++++++-- .../src/service_status_update_handler.cc | 82 ++++++++++++++++ .../security_manager/security_manager_impl.h | 23 ++++- .../src/security_manager_impl.cc | 67 ++++++++++++- .../utils/include/utils/system_time_handler.h | 11 +++ 41 files changed, 920 insertions(+), 142 deletions(-) mode change 100644 => 100755 src/components/application_manager/test/mock_message_helper.cc create mode 100644 src/components/protocol_handler/include/protocol_handler/service_status_update_handler.h create mode 100644 src/components/protocol_handler/include/protocol_handler/service_status_update_handler_listener.h create mode 100644 src/components/protocol_handler/src/service_status_update_handler.cc diff --git a/src/appMain/life_cycle_impl.cc b/src/appMain/life_cycle_impl.cc index 10f0fc0d525..c903fb1a8ad 100644 --- a/src/appMain/life_cycle_impl.cc +++ b/src/appMain/life_cycle_impl.cc @@ -103,6 +103,13 @@ bool LifeCycleImpl::StartComponents() { app_manager_ = new application_manager::ApplicationManagerImpl(profile_, profile_); + auto service_status_update_handler = + std::unique_ptr( + new protocol_handler::ServiceStatusUpdateHandler(app_manager_)); + + protocol_handler_->set_service_status_update_handler( + std::move(service_status_update_handler)); + DCHECK(!hmi_handler_); hmi_handler_ = new hmi_message_handler::HMIMessageHandlerImpl(profile_); diff --git a/src/components/application_manager/include/application_manager/application_manager_impl.h b/src/components/application_manager/include/application_manager/application_manager_impl.h index a224d51a331..7071610acba 100644 --- a/src/components/application_manager/include/application_manager/application_manager_impl.h +++ b/src/components/application_manager/include/application_manager/application_manager_impl.h @@ -58,6 +58,8 @@ #include "application_manager/rpc_service.h" #include "application_manager/state_controller_impl.h" +#include "application_manager/rpc_handler.h" + #include "application_manager/policies/policy_handler_interface.h" #include "application_manager/policies/policy_handler_observer.h" #include "connection_handler/connection_handler.h" @@ -69,6 +71,7 @@ #include "policies/policy_handler.h" #include "protocol_handler/protocol_handler.h" #include "protocol_handler/protocol_observer.h" +#include "protocol_handler/service_status_update_handler_listener.h" #include "interfaces/HMI_API.h" #include "interfaces/HMI_API_schema.h" @@ -132,7 +135,8 @@ typedef std::shared_ptr TimerSPtr; class ApplicationManagerImpl : public ApplicationManager, public connection_handler::ConnectionHandlerObserver, - public policy::PolicyHandlerObserver + public policy::PolicyHandlerObserver, + public protocol_handler::ServiceStatusUpdateHandlerListener #ifdef ENABLE_SECURITY , public security_manager::SecurityManagerListener @@ -538,6 +542,51 @@ class ApplicationManagerImpl */ void OnPTUFinished(const bool ptu_result) FINAL; +#if defined(EXTERNAL_PROPRIETARY_MODE) && defined(ENABLE_SECURITY) + /** + * @brief OnCertDecryptFailed is called when certificate decryption fails in + * external flow + * @return since this callback is a part of SecurityManagerListener, bool + * return value is used to indicate whether listener instance can be deleted + * by calling entity. if true - listener can be deleted and removed from + * listeners by SecurityManager, false - listener retains its place within + * SecurityManager. + */ + bool OnCertDecryptFailed() FINAL; + + /** + * @brief OnCertDecryptFinished is called when certificate decryption is + * finished in the external flow + * @param decrypt_result bool value indicating whether decryption was + * successful + */ + void OnCertDecryptFinished(const bool decrypt_result) FINAL; +#endif + + /** + * @brief OnPTUTimeoutExceeded is called on policy table update timed out + */ + void OnPTUTimeoutExceeded() FINAL; + + /** + *@brief ProcessServiceStatusUpdate callback that is invoked in case of + *service status update + *@param connection_key - connection key + *@param service_type enum value containing type of service. + *@param service_event enum value containing event that occured during service + *start. + *@param service_update_reason enum value containing reason why service_event + *occured. + **/ + void ProcessServiceStatusUpdate( + const uint32_t connection_key, + hmi_apis::Common_ServiceType::eType service_type, + hmi_apis::Common_ServiceEvent::eType service_event, + utils::Optional + service_update_reason) FINAL; + + void OnPTUFailed() FINAL {} + /* * @brief Starts audio pass thru thread * @@ -657,7 +706,7 @@ class ApplicationManagerImpl * @brief Notification about handshake failure * @return true on success notification handling or false otherwise */ - bool OnHandshakeFailed() OVERRIDE; + bool OnGetSystemTimeFailed() OVERRIDE; /** * @brief Notification that certificate update is required. diff --git a/src/components/application_manager/include/application_manager/message_helper.h b/src/components/application_manager/include/application_manager/message_helper.h index 7dac442ef08..7b390d7adfc 100644 --- a/src/components/application_manager/include/application_manager/message_helper.h +++ b/src/components/application_manager/include/application_manager/message_helper.h @@ -90,32 +90,61 @@ class MessageHelper { hmi_apis::FunctionID::eType function_id); /** - * @brief CreateOnServiceStatusUpdateNotification creates on status update hmi - * notification smart object - * @param app_id - application id - * @param service_type - enum value representing service_type - * @param service_event - enum value representing service update event - * @return smart object containing on status update notification - */ - static smart_objects::SmartObjectSPtr CreateOnServiceStatusUpdateNotification( - const uint32_t app_id, - const hmi_apis::Common_ServiceType::eType service_type, - const hmi_apis::Common_ServiceEvent::eType service_event); - - /** - * @brief CreateOnServiceStatusUpdateNotification creates on status update hmi - * notification smart object - * @param app_id - application id - * @param service_type - enum value representing service_type - * @param service_event - enum value representing service update event - * @param service_event_reason - enum value representing service update reason - * @return smart object containing on status update notification - */ - static smart_objects::SmartObjectSPtr CreateOnServiceStatusUpdateNotification( - const uint32_t app_id, - const hmi_apis::Common_ServiceType::eType service_type, - const hmi_apis::Common_ServiceEvent::eType service_event, - const hmi_apis::Common_ServiceUpdateReason::eType service_update_reason); + * @brief ServiceStatusUpdateNotificationBuilder small utility class used for + * more flexible construction of OnServiceUpdateNotification + */ + class ServiceStatusUpdateNotificationBuilder { + public: + typedef hmi_apis::Common_ServiceType::eType ServiceType; + typedef hmi_apis::Common_ServiceEvent::eType ServiceEvent; + typedef hmi_apis::Common_ServiceUpdateReason::eType ServiceUpdateReason; + + /** + * @brief CreateBuilder creates builder instance + * @param service_type - enum value containing service type + * @param service_event - enum value containing service event + * @returns builder instance + */ + static ServiceStatusUpdateNotificationBuilder CreateBuilder( + const ServiceType service_type, const ServiceEvent service_event); + + /** + * @brief AddAppID adds app id to notification + * @param app_id application id to add + * @returns ref to builder instance + */ + ServiceStatusUpdateNotificationBuilder& AddAppID(const uint32_t app_id); + + /** + * @brief AddServiceUpdateReason adds service update reason to notification + * @param service_update_reason enum value containing update reason + * @returns ref to builder instance + */ + ServiceStatusUpdateNotificationBuilder& AddServiceUpdateReason( + const ServiceUpdateReason service_update_reason); + + /** + * @brief notification gets notification SO + * @returns shared ptr to notification SO + */ + smart_objects::SmartObjectSPtr notification() const; + + protected: + smart_objects::SmartObjectSPtr notification_; + + /** + * @brief class constructor + * @param service_type - enum value containing service type + * @param service_event - enum value containing service event + */ + ServiceStatusUpdateNotificationBuilder(const ServiceType service_type, + const ServiceEvent service_event); + + /** + * @brief class constructor + */ + ServiceStatusUpdateNotificationBuilder(){}; + }; /** * @brief Creates request for different interfaces(JSON) diff --git a/src/components/application_manager/include/application_manager/policies/policy_handler.h b/src/components/application_manager/include/application_manager/policies/policy_handler.h index dddd1b333db..39026b34208 100644 --- a/src/components/application_manager/include/application_manager/policies/policy_handler.h +++ b/src/components/application_manager/include/application_manager/policies/policy_handler.h @@ -176,6 +176,9 @@ class PolicyHandler : public PolicyHandlerInterface, const std::string& policy_app_id, const std::string& hmi_level) OVERRIDE; +#ifndef EXTERNAL_PROPRIETARY_MODE + void OnPTUTimeOut() OVERRIDE; +#endif /** * Gets all allowed module types * @param app_id unique identifier of application @@ -502,11 +505,11 @@ class PolicyHandler : public PolicyHandlerInterface, virtual void OnCertificateUpdated( const std::string& certificate_data) OVERRIDE; + #ifdef EXTERNAL_PROPRIETARY_MODE void OnCertificateDecrypted(bool is_succeeded) OVERRIDE; + void ProcessCertDecryptFailed(); #endif // EXTERNAL_PROPRIETARY_MODE - void OnAuthTokenUpdated(const std::string& policy_app_id, - const std::string& auth_token); virtual bool CanUpdate() OVERRIDE; diff --git a/src/components/application_manager/include/application_manager/policies/regular/policy_handler_observer.h b/src/components/application_manager/include/application_manager/policies/regular/policy_handler_observer.h index 3c4dce2fbc2..fdfed698c4d 100644 --- a/src/components/application_manager/include/application_manager/policies/regular/policy_handler_observer.h +++ b/src/components/application_manager/include/application_manager/policies/regular/policy_handler_observer.h @@ -53,6 +53,8 @@ class PolicyHandlerObserver { virtual void OnPTUFinished(const bool ptu_result) {} + virtual void OnPTUTimeoutExceeded() {} + virtual ~PolicyHandlerObserver() {} }; } // namespace policy diff --git a/src/components/application_manager/include/application_manager/system_time/system_time_handler_impl.h b/src/components/application_manager/include/application_manager/system_time/system_time_handler_impl.h index 46aa98e6c12..a8ba796a1bc 100644 --- a/src/components/application_manager/include/application_manager/system_time/system_time_handler_impl.h +++ b/src/components/application_manager/include/application_manager/system_time/system_time_handler_impl.h @@ -129,6 +129,12 @@ class SystemTimeHandlerImpl : public utils::SystemTimeHandler, */ void ProcessSystemTimeReadyNotification(); + /** + * @brief ResetPendingSystemTimeRequests resets waiting for system time + * requests flag + */ + void ResetPendingSystemTimeRequests() OVERRIDE; + /** * @brief Checks if UTC time is ready to provided by HMI * and can be requested by GetSystemTime request diff --git a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/include/sdl_rpc_plugin/commands/hmi/on_service_status_update_notification.h b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/include/sdl_rpc_plugin/commands/hmi/on_service_status_update_notification.h index 93f7da8b5ff..f51b0c2907a 100644 --- a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/include/sdl_rpc_plugin/commands/hmi/on_service_status_update_notification.h +++ b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/include/sdl_rpc_plugin/commands/hmi/on_service_status_update_notification.h @@ -39,7 +39,6 @@ namespace sdl_rpc_plugin { namespace app_mngr = application_manager; namespace commands { - namespace hmi { /** @@ -77,9 +76,7 @@ class OnServiceStatusUpdateNotification }; } // namespace hmi - } // namespace commands - } // namespace sdl_rpc_plugin #endif // SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_SDL_RPC_PLUGIN_INCLUDE_SDL_RPC_PLUGIN_COMMANDS_HMI_ON_SERVICE_STATUS_UPDATE_NOTIFICATION_H_ diff --git a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/hmi/basic_communication_get_system_time_request.cc b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/hmi/basic_communication_get_system_time_request.cc index fb87612e198..19c9fa91d82 100644 --- a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/hmi/basic_communication_get_system_time_request.cc +++ b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/hmi/basic_communication_get_system_time_request.cc @@ -51,7 +51,7 @@ BasicCommunicationGetSystemTimeRequest::BasicCommunicationGetSystemTimeRequest( void BasicCommunicationGetSystemTimeRequest::onTimeOut() { LOG4CXX_AUTO_TRACE(logger_); - application_manager_.protocol_handler().NotifyOnFailedHandshake(); + application_manager_.protocol_handler().NotifyOnGetSystemTimeFailed(); } } // namespace commands diff --git a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/hmi/on_service_status_update_notification.cc b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/hmi/on_service_status_update_notification.cc index 8224325f8e1..6dc5f9a7fc2 100644 --- a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/hmi/on_service_status_update_notification.cc +++ b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/hmi/on_service_status_update_notification.cc @@ -55,9 +55,9 @@ OnServiceStatusUpdateNotification::~OnServiceStatusUpdateNotification() {} void OnServiceStatusUpdateNotification::Run() { LOG4CXX_AUTO_TRACE(logger_); - SendNotification(); } + } // namespace hmi } // namespace commands } // namespace sdl_rpc_plugin diff --git a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/test/commands/hmi/basic_communication_get_system_time_request_test.cc b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/test/commands/hmi/basic_communication_get_system_time_request_test.cc index 0251c4873d3..9cd87b053d8 100644 --- a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/test/commands/hmi/basic_communication_get_system_time_request_test.cc +++ b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/test/commands/hmi/basic_communication_get_system_time_request_test.cc @@ -60,7 +60,7 @@ TEST_F(BasicCommunicationGetSystemTimeRequestTest, OnTimeout) { ON_CALL(app_mngr_, protocol_handler()) .WillByDefault(ReturnRef(mock_protocol_handler)); - EXPECT_CALL(mock_protocol_handler, NotifyOnFailedHandshake()); + EXPECT_CALL(mock_protocol_handler, NotifyOnGetSystemTimeFailed()); command->onTimeOut(); } diff --git a/src/components/application_manager/src/application_manager_impl.cc b/src/components/application_manager/src/application_manager_impl.cc index 3829005047f..6f5c5a82e34 100644 --- a/src/components/application_manager/src/application_manager_impl.cc +++ b/src/components/application_manager/src/application_manager_impl.cc @@ -1917,7 +1917,7 @@ void ApplicationManagerImpl::OnServiceStartedCallback( "ServiceType = " << type << ". Session = " << std::hex << session_key); std::vector empty; - if (type == kRpc) { + if (kRpc == type) { LOG4CXX_DEBUG(logger_, "RPC service is about to be started."); connection_handler().NotifyServiceStartedResult(session_key, true, empty); return; @@ -1944,6 +1944,7 @@ void ApplicationManagerImpl::OnServiceStartedCallback( } else { LOG4CXX_WARN(logger_, "Refuse unknown service"); } + connection_handler().NotifyServiceStartedResult(session_key, false, empty); } @@ -2026,6 +2027,36 @@ void ApplicationManagerImpl::OnServiceEndedCallback( } } +void ApplicationManagerImpl::ProcessServiceStatusUpdate( + const uint32_t connection_key, + hmi_apis::Common_ServiceType::eType service_type, + hmi_apis::Common_ServiceEvent::eType service_event, + utils::Optional + service_update_reason) { + LOG4CXX_AUTO_TRACE(logger_); + + LOG4CXX_DEBUG(logger_, + "Processing status update with connection key: " + << connection_key << " service type: " << service_type + << " service_event " << service_event + << " service_update_reason " << service_update_reason); + + const auto app = application(connection_key); + auto notification_builder = + MessageHelper::ServiceStatusUpdateNotificationBuilder::CreateBuilder( + service_type, service_event); + + if (app) { + notification_builder.AddAppID(app->app_id()); + } + + if (service_update_reason) { + notification_builder.AddServiceUpdateReason(*service_update_reason); + } + + rpc_service_->ManageHMICommand(notification_builder.notification()); +} + void ApplicationManagerImpl::OnSecondaryTransportStartedCallback( const connection_handler::DeviceHandle device_handle, const int32_t session_key) { @@ -2118,7 +2149,12 @@ bool ApplicationManagerImpl::OnHandshakeDone( using namespace helpers; ApplicationSharedPtr app = application(connection_key); - DCHECK_OR_RETURN(app, false); + if (!app) { + LOG4CXX_WARN(logger_, + "Application for connection key: " << connection_key + << " was not found"); + return false; + } if (Compare( result, SSLContext::Handshake_Result_CertExpired, @@ -2131,7 +2167,7 @@ bool ApplicationManagerImpl::OnHandshakeDone( return false; } -bool ApplicationManagerImpl::OnHandshakeFailed() { +bool ApplicationManagerImpl::OnGetSystemTimeFailed() { LOG4CXX_AUTO_TRACE(logger_); return false; } @@ -3889,6 +3925,7 @@ void ApplicationManagerImpl::ProcessReconnection( void ApplicationManagerImpl::OnPTUFinished(const bool ptu_result) { LOG4CXX_AUTO_TRACE(logger_); if (!ptu_result) { + protocol_handler_->ProcessFailedPTU(); return; } @@ -3907,6 +3944,25 @@ void ApplicationManagerImpl::OnPTUFinished(const bool ptu_result) { plugin_manager_->ForEachPlugin(on_app_policy_updated); } +#if defined(EXTERNAL_PROPRIETARY_MODE) && defined(ENABLE_SECURITY) +void ApplicationManagerImpl::OnCertDecryptFinished(const bool decrypt_result) { + LOG4CXX_AUTO_TRACE(logger_); + if (!decrypt_result) { + protocol_handler_->ProcessFailedCertDecrypt(); + } +} + +bool ApplicationManagerImpl::OnCertDecryptFailed() { + LOG4CXX_AUTO_TRACE(logger_); + return false; +} +#endif + +void ApplicationManagerImpl::OnPTUTimeoutExceeded() { + LOG4CXX_AUTO_TRACE(logger_); + protocol_handler_->ProcessFailedPTU(); +} + void ApplicationManagerImpl::SendDriverDistractionState( ApplicationSharedPtr application) { LOG4CXX_AUTO_TRACE(logger_); diff --git a/src/components/application_manager/src/message_helper/message_helper.cc b/src/components/application_manager/src/message_helper/message_helper.cc index d99ca90916d..c90711b675b 100644 --- a/src/components/application_manager/src/message_helper/message_helper.cc +++ b/src/components/application_manager/src/message_helper/message_helper.cc @@ -2234,45 +2234,45 @@ smart_objects::SmartObjectSPtr MessageHelper::CreateNegativeResponse( return std::make_shared(response_data); } -smart_objects::SmartObjectSPtr -MessageHelper::CreateOnServiceStatusUpdateNotification( - const uint32_t app_id, - const hmi_apis::Common_ServiceType::eType service_type, - const hmi_apis::Common_ServiceEvent::eType service_event) { - auto on_status_update_notification = CreateHMINotification( +MessageHelper::ServiceStatusUpdateNotificationBuilder:: + ServiceStatusUpdateNotificationBuilder(const ServiceType service_type, + const ServiceEvent service_event) { + notification_ = MessageHelper::CreateHMINotification( hmi_apis::FunctionID::BasicCommunication_OnServiceUpdate); - if (0 < app_id) { - (*on_status_update_notification)[strings::msg_params][strings::app_id] = - app_id; - } - - (*on_status_update_notification)[strings::msg_params] - [hmi_notification::service_type] = - service_type; - (*on_status_update_notification)[strings::msg_params] - [hmi_notification::service_event] = - service_event; + (*notification_)[strings::msg_params][hmi_notification::service_type] = + service_type; + (*notification_)[strings::msg_params][hmi_notification::service_event] = + service_event; +} - return on_status_update_notification; +MessageHelper::ServiceStatusUpdateNotificationBuilder +MessageHelper::ServiceStatusUpdateNotificationBuilder::CreateBuilder( + const ServiceType service_type, const ServiceEvent service_event) { + MessageHelper::ServiceStatusUpdateNotificationBuilder builder{service_type, + service_event}; + return builder; } -smart_objects::SmartObjectSPtr -MessageHelper::CreateOnServiceStatusUpdateNotification( - const uint32_t app_id, - const hmi_apis::Common_ServiceType::eType service_type, - const hmi_apis::Common_ServiceEvent::eType service_event, - const hmi_apis::Common_ServiceUpdateReason::eType service_update_reason) { - auto notification = CreateOnServiceStatusUpdateNotification( - app_id, service_type, service_event); +MessageHelper::ServiceStatusUpdateNotificationBuilder& +MessageHelper::ServiceStatusUpdateNotificationBuilder::AddAppID( + const uint32_t app_id) { + (*notification_)[strings::msg_params][strings::app_id] = app_id; - if (hmi_apis::Common_ServiceUpdateReason::eType::INVALID_ENUM != - service_update_reason) { - (*notification)[strings::msg_params][hmi_notification::reason] = - service_update_reason; - } + return *this; +} - return notification; +MessageHelper::ServiceStatusUpdateNotificationBuilder& +MessageHelper::ServiceStatusUpdateNotificationBuilder::AddServiceUpdateReason( + const ServiceUpdateReason service_update_reason) { + (*notification_)[strings::msg_params][hmi_notification::reason] = + service_update_reason; + + return *this; +} +smart_objects::SmartObjectSPtr +MessageHelper::ServiceStatusUpdateNotificationBuilder::notification() const { + return notification_; } void MessageHelper::SendNaviSetVideoConfig( diff --git a/src/components/application_manager/src/policies/policy_handler.cc b/src/components/application_manager/src/policies/policy_handler.cc index 1bad50b34f6..7085d7a86c9 100644 --- a/src/components/application_manager/src/policies/policy_handler.cc +++ b/src/components/application_manager/src/policies/policy_handler.cc @@ -1461,6 +1461,11 @@ void PolicyHandler::OnPermissionsUpdated(const std::string& device_id, << policy_app_id << " and connection_key " << app->app_id()); } +#ifndef EXTERNAL_PROPRIETARY_MODE +void PolicyHandler::OnPTUTimeOut() { + application_manager_.protocol_handler().ProcessFailedPTU(); +} +#endif bool PolicyHandler::SaveSnapshot(const BinaryMessage& pt_string, std::string& snap_path) { @@ -1630,6 +1635,11 @@ uint32_t PolicyHandler::TimeoutExchangeMSec() const { void PolicyHandler::OnExceededTimeout() { POLICY_LIB_CHECK_VOID(); + + std::for_each(listeners_.begin(), + listeners_.end(), + std::mem_fn(&PolicyHandlerObserver::OnPTUTimeoutExceeded)); + policy_manager_->OnExceededTimeout(); } @@ -1787,6 +1797,7 @@ void PolicyHandler::OnCertificateDecrypted(bool is_succeeded) { if (!is_succeeded) { LOG4CXX_ERROR(logger_, "Couldn't delete file " << file_name); + ProcessCertDecryptFailed(); return; } @@ -1809,6 +1820,17 @@ void PolicyHandler::OnCertificateDecrypted(bool is_succeeded) { std::bind2nd(std::mem_fun(&PolicyHandlerObserver::OnCertificateUpdated), certificate_data)); } + +void PolicyHandler::ProcessCertDecryptFailed() { + LOG4CXX_AUTO_TRACE(logger_); + sync_primitives::AutoLock lock(listeners_lock_); + + std::for_each( + listeners_.begin(), + listeners_.end(), + std::bind2nd(std::mem_fn(&PolicyHandlerObserver::OnCertDecryptFinished), + false)); +} #else // EXTERNAL_PROPRIETARY_MODE void PolicyHandler::OnCertificateUpdated(const std::string& certificate_data) { LOG4CXX_AUTO_TRACE(logger_); diff --git a/src/components/application_manager/src/system_time/system_time_handler_impl.cc b/src/components/application_manager/src/system_time/system_time_handler_impl.cc index f5d08a8ebfd..deb92d5d812 100644 --- a/src/components/application_manager/src/system_time/system_time_handler_impl.cc +++ b/src/components/application_manager/src/system_time/system_time_handler_impl.cc @@ -82,6 +82,13 @@ void SystemTimeHandlerImpl::DoSubscribe(utils::SystemTimeListener* listener) { system_time_listener_ = listener; } +void SystemTimeHandlerImpl::ResetPendingSystemTimeRequests() { + LOG4CXX_AUTO_TRACE(logger_); + unsubscribe_from_event( + hmi_apis::FunctionID::BasicCommunication_GetSystemTime); + awaiting_get_system_time_ = false; +} + void SystemTimeHandlerImpl::DoUnsubscribe(utils::SystemTimeListener* listener) { LOG4CXX_AUTO_TRACE(logger_); sync_primitives::AutoLock lock(system_time_listener_lock_); @@ -145,6 +152,14 @@ void SystemTimeHandlerImpl::ProcessSystemTimeResponse( const application_manager::event_engine::Event& event) { LOG4CXX_AUTO_TRACE(logger_); const smart_objects::SmartObject& message = event.smart_object(); + + const auto result = static_cast( + message[strings::params][hmi_response::code].asInt()); + + if (hmi_apis::Common_Result::SUCCESS != result) { + system_time_listener_->OnSystemTimeFailed(); + } + const smart_objects::SmartObject& system_time_so = message[strings::msg_params][hmi_response::system_time]; diff --git a/src/components/application_manager/test/include/application_manager/mock_message_helper.h b/src/components/application_manager/test/include/application_manager/mock_message_helper.h index f8a4253cb42..eec8d464a56 100644 --- a/src/components/application_manager/test/include/application_manager/mock_message_helper.h +++ b/src/components/application_manager/test/include/application_manager/mock_message_helper.h @@ -354,7 +354,27 @@ class MockMessageHelper { const hmi_apis::Common_ServiceUpdateReason::eType service_update_reason)); + class MockServiceStatusUpdateNotificationBuilder { + public: + MOCK_METHOD2(CreateBuilder, + MessageHelper::ServiceStatusUpdateNotificationBuilder( + hmi_apis::Common_ServiceType::eType, + hmi_apis::Common_ServiceEvent::eType)); + + MOCK_METHOD1(AddAppID, + MessageHelper::ServiceStatusUpdateNotificationBuilder&( + const uint32_t app_id)); + + MOCK_METHOD1(AddServiceUpdateReason, + MessageHelper::ServiceStatusUpdateNotificationBuilder&( + const hmi_apis::Common_ServiceUpdateReason::eType)); + + MOCK_CONST_METHOD0(notification, smart_objects::SmartObjectSPtr()); + }; + static MockMessageHelper* message_helper_mock(); + static MockServiceStatusUpdateNotificationBuilder* + on_service_update_builder_mock(); }; } // namespace application_manager diff --git a/src/components/application_manager/test/message_helper/message_helper_test.cc b/src/components/application_manager/test/message_helper/message_helper_test.cc index a174d74d5db..249d7231d7d 100644 --- a/src/components/application_manager/test/message_helper/message_helper_test.cc +++ b/src/components/application_manager/test/message_helper/message_helper_test.cc @@ -69,6 +69,14 @@ using namespace application_manager; typedef std::shared_ptr MockApplicationSharedPtr; typedef std::vector StringArray; typedef std::shared_ptr ApplicationSharedPtr; +typedef MessageHelper::ServiceStatusUpdateNotificationBuilder::ServiceType + ServiceType; +typedef MessageHelper::ServiceStatusUpdateNotificationBuilder::ServiceEvent + ServiceEvent; +typedef MessageHelper::ServiceStatusUpdateNotificationBuilder:: + ServiceUpdateReason UpdateReason; +typedef MessageHelper::ServiceStatusUpdateNotificationBuilder + ServiceStatusUpdateBuilder; using testing::_; using testing::AtLeast; diff --git a/src/components/application_manager/test/mock_message_helper.cc b/src/components/application_manager/test/mock_message_helper.cc old mode 100644 new mode 100755 index 4269e172dfc..d33e98cb6f5 --- a/src/components/application_manager/test/mock_message_helper.cc +++ b/src/components/application_manager/test/mock_message_helper.cc @@ -601,24 +601,38 @@ void MessageHelper::SendUnsubscribeButtonNotification( ->SendUnsubscribeButtonNotification(button, application, app_mngr); } -smart_objects::SmartObject -MessageHelper::CreateOnServiceStatusUpdateNotification( - const uint32_t app_id, - const hmi_apis::Common_ServiceType::eType service_type, - const hmi_apis::Common_ServiceEvent::eType service_event) { - return MockMessageHelper::message_helper_mock() - ->CreateOnStatusUpdateNotification(app_id, service_type, service_event); +MockMessageHelper::MockServiceStatusUpdateNotificationBuilder* +MockMessageHelper::on_service_update_builder_mock() { + static ::testing::NiceMock< + MockMessageHelper::MockServiceStatusUpdateNotificationBuilder> + on_service_update_builder_mock; + return &on_service_update_builder_mock; } -smart_objects::SmartObject -MessageHelper::CreateOnServiceStatusUpdateNotification( - const uint32_t app_id, - const hmi_apis::Common_ServiceType::eType service_type, - const hmi_apis::Common_ServiceEvent::eType service_event, - const hmi_apis::Common_ServiceUpdateReason service_update_reason) { - return MockMessageHelper::message_helper_mock() - ->CreateOnStatusUpdateNotification( - app_id, service_type, service_event, service_update_reason); +MessageHelper::ServiceStatusUpdateNotificationBuilder +MessageHelper::ServiceStatusUpdateNotificationBuilder::CreateBuilder( + hmi_apis::Common_ServiceType::eType service_type, + hmi_apis::Common_ServiceEvent::eType service_event) { + return MockMessageHelper::on_service_update_builder_mock()->CreateBuilder( + service_type, service_event); +} + +MessageHelper::ServiceStatusUpdateNotificationBuilder& +MessageHelper::ServiceStatusUpdateNotificationBuilder::AddAppID( + const uint32_t app_id) { + return MockMessageHelper::on_service_update_builder_mock()->AddAppID(app_id); +} + +MessageHelper::ServiceStatusUpdateNotificationBuilder& +MessageHelper::ServiceStatusUpdateNotificationBuilder::AddServiceUpdateReason( + const hmi_apis::Common_ServiceUpdateReason::eType service_update_reason) { + return MockMessageHelper::on_service_update_builder_mock() + ->AddServiceUpdateReason(service_update_reason); +} + +smart_objects::SmartObjectSPtr +MessageHelper::ServiceStatusUpdateNotificationBuilder::notification() const { + return MockMessageHelper::on_service_update_builder_mock()->notification(); } smart_objects::SmartObject MessageHelper::CreateAppServiceCapabilities( diff --git a/src/components/include/application_manager/policies/policy_handler_observer.h b/src/components/include/application_manager/policies/policy_handler_observer.h index 42348e77050..fc22d196df5 100644 --- a/src/components/include/application_manager/policies/policy_handler_observer.h +++ b/src/components/include/application_manager/policies/policy_handler_observer.h @@ -55,6 +55,18 @@ class PolicyHandlerObserver { virtual void OnPTInited() {} + virtual void OnPTUTimeoutExceeded() {} + +#ifdef EXTERNAL_PROPRIETARY_MODE + /** + * @brief OnCertDecryptFinished is called when certificate decryption is + * finished in the external flow + * @param decrypt_result bool value indicating whether decryption was + * successful + */ + virtual void OnCertDecryptFinished(const bool decrypt_result) {} +#endif + virtual ~PolicyHandlerObserver() {} }; } // namespace policy diff --git a/src/components/include/policy/policy_regular/policy/policy_listener.h b/src/components/include/policy/policy_regular/policy/policy_listener.h index d717822cac5..3e23df9710e 100644 --- a/src/components/include/policy/policy_regular/policy/policy_listener.h +++ b/src/components/include/policy/policy_regular/policy/policy_listener.h @@ -118,6 +118,11 @@ class PolicyListener { */ virtual void OnCertificateUpdated(const std::string& certificate_data) = 0; + /** + * @brief OnPTUTimeOut the callback which signals if PTU timeout occured + */ + virtual void OnPTUTimeOut() = 0; + /** * @brief OnAuthTokenUpdated the callback which signals if an app's auth token * field has been updated during a PTU diff --git a/src/components/include/protocol_handler/protocol_handler.h b/src/components/include/protocol_handler/protocol_handler.h index 619c47ac343..aacb31c2608 100644 --- a/src/components/include/protocol_handler/protocol_handler.h +++ b/src/components/include/protocol_handler/protocol_handler.h @@ -118,7 +118,7 @@ class ProtocolHandler { /** * \brief Called to notify all handsheke handlers about handshake failure. */ - virtual void NotifyOnFailedHandshake() = 0; + virtual void NotifyOnGetSystemTimeFailed() = 0; /** * \brief Protocol handler settings getter @@ -141,6 +141,16 @@ class ProtocolHandler { virtual bool IsRPCServiceSecure(const uint32_t connection_key) const = 0; + virtual void ProcessFailedPTU() = 0; + +#ifdef EXTERNAL_PROPRIETARY_MODE + /** + * @brief ProcessFailedCertDecrypt is called to notify security manager that + * certificate decryption failed in the external flow + */ + virtual void ProcessFailedCertDecrypt() = 0; +#endif + protected: /** * \brief Destructor diff --git a/src/components/include/security_manager/security_manager.h b/src/components/include/security_manager/security_manager.h index e02a3a1cbec..358c4e52684 100644 --- a/src/components/include/security_manager/security_manager.h +++ b/src/components/include/security_manager/security_manager.h @@ -166,7 +166,17 @@ class SecurityManager : public protocol_handler::ProtocolObserver, /** * @brief Notify all listeners that handshake was failed */ - virtual void NotifyListenersOnHandshakeFailed() = 0; + virtual void NotifyListenersOnGetSystemTimeFailed() = 0; + + virtual void ProcessFailedPTU() = 0; + +#ifdef EXTERNAL_PROPRIETARY_MODE + /** + * @brief ProcessFailedCertDecrypt is called to notify listeners that + * certificate decryption failed in the external flow + */ + virtual void ProcessFailedCertDecrypt() = 0; +#endif /** * @brief Check if policy certificate data is empty @@ -174,6 +184,12 @@ class SecurityManager : public protocol_handler::ProtocolObserver, */ virtual bool IsPolicyCertificateDataEmpty() = 0; + /** + * @brief ResetPendingSystemTimeRequests resets waiting for system time + * requests flag + */ + virtual void ResetPendingSystemTimeRequests() = 0; + /** * \brief Add/Remove for SecurityManagerListener */ diff --git a/src/components/include/security_manager/security_manager_listener.h b/src/components/include/security_manager/security_manager_listener.h index 00a4c681349..f7148d31654 100644 --- a/src/components/include/security_manager/security_manager_listener.h +++ b/src/components/include/security_manager/security_manager_listener.h @@ -52,13 +52,28 @@ class SecurityManagerListener { * @brief Notification about handshake failure * @return true on success notification handling or false otherwise */ - virtual bool OnHandshakeFailed() = 0; + virtual bool OnGetSystemTimeFailed() = 0; /** * @brief Notify listeners that certificate update is required. */ virtual void OnCertificateUpdateRequired() = 0; + virtual void OnPTUFailed() = 0; + +#ifdef EXTERNAL_PROPRIETARY_MODE + /** + * @brief OnCertDecryptFailed is called when certificate decryption fails in + * external flow + * @return since this callback is a part of SecurityManagerListener, bool + * return value is used to indicate whether listener instance can be deleted + * by calling entity. if true - listener can be deleted and removed from + * listeners by SecurityManager, false - listener retains its place within + * SecurityManager. + */ + virtual bool OnCertDecryptFailed() = 0; +#endif + /** * @brief Get certificate data from policy * @param reference to string where to save certificate data diff --git a/src/components/include/test/policy/policy_external/policy/mock_policy_listener.h b/src/components/include/test/policy/policy_external/policy/mock_policy_listener.h index 16341ed4f4f..f65138e4898 100644 --- a/src/components/include/test/policy/policy_external/policy/mock_policy_listener.h +++ b/src/components/include/test/policy/policy_external/policy/mock_policy_listener.h @@ -112,6 +112,7 @@ class MockPolicyListener : public ::policy::PolicyListener { const std::string& policy_app_id, const std::string& hmi_level)); MOCK_METHOD0(OnLockScreenDismissalStateChanged, void()); + MOCK_METHOD1(OnCertDecryptFinished, void(bool)); }; } // namespace policy_test diff --git a/src/components/include/test/policy/policy_regular/policy/mock_policy_listener.h b/src/components/include/test/policy/policy_regular/policy/mock_policy_listener.h index d0d85409a27..cb5feb31268 100644 --- a/src/components/include/test/policy/policy_regular/policy/mock_policy_listener.h +++ b/src/components/include/test/policy/policy_regular/policy/mock_policy_listener.h @@ -105,6 +105,7 @@ class MockPolicyListener : public ::policy::PolicyListener { const std::string& policy_app_id, const std::string& hmi_level)); MOCK_METHOD0(OnLockScreenDismissalStateChanged, void()); + MOCK_METHOD0(OnPTUTimeOut, void()); }; } // namespace policy_test diff --git a/src/components/include/test/protocol_handler/mock_protocol_handler.h b/src/components/include/test/protocol_handler/mock_protocol_handler.h index 772b63b5829..df75c71c490 100644 --- a/src/components/include/test/protocol_handler/mock_protocol_handler.h +++ b/src/components/include/test/protocol_handler/mock_protocol_handler.h @@ -67,8 +67,11 @@ class MockProtocolHandler : public ::protocol_handler::ProtocolHandler { MOCK_METHOD2(NotifySessionStarted, void(const ::protocol_handler::SessionContext& context, std::vector& rejected_params)); - MOCK_METHOD0(NotifyOnFailedHandshake, void()); + MOCK_METHOD0(NotifyOnGetSystemTimeFailed, void()); MOCK_CONST_METHOD1(IsRPCServiceSecure, bool(const uint32_t connection_key)); +#ifdef EXTERNAL_PROPRIETARY_MODE + MOCK_METHOD0(ProcessFailedCertDecrypt, void()); +#endif }; } // namespace protocol_handler_test } // namespace components diff --git a/src/components/include/test/security_manager/mock_security_manager.h b/src/components/include/test/security_manager/mock_security_manager.h index 2b5d99c156c..e44d6207c1a 100644 --- a/src/components/include/test/security_manager/mock_security_manager.h +++ b/src/components/include/test/security_manager/mock_security_manager.h @@ -68,11 +68,16 @@ class MockSecurityManager : public ::security_manager::SecurityManager { void(const ::protocol_handler::RawMessagePtr)); MOCK_METHOD1(IsCertificateUpdateRequired, bool(const uint32_t)); MOCK_METHOD0(NotifyOnCertificateUpdateRequired, void()); - MOCK_METHOD0(NotifyListenersOnHandshakeFailed, void()); + MOCK_METHOD0(NotifyListenersOnGetSystemTimeFailed, void()); MOCK_METHOD0(IsPolicyCertificateDataEmpty, bool()); + MOCK_METHOD0(ProcessFailedPTU, void()); MOCK_METHOD1(OnCertificateUpdated, bool(const std::string&)); MOCK_METHOD1(PostponeHandshake, void(const uint32_t)); MOCK_CONST_METHOD0(IsSystemTimeProviderReady, bool()); + MOCK_METHOD0(ResetPendingSystemTimeRequests, void()); +#ifdef EXTERNAL_PROPRIETARY_MODE + MOCK_METHOD0(ProcessFailedCertDecrypt, void()); +#endif }; /* diff --git a/src/components/include/test/security_manager/mock_security_manager_listener.h b/src/components/include/test/security_manager/mock_security_manager_listener.h index 7a7714d299b..1673a270876 100644 --- a/src/components/include/test/security_manager/mock_security_manager_listener.h +++ b/src/components/include/test/security_manager/mock_security_manager_listener.h @@ -49,7 +49,11 @@ class MockSecurityManagerListener ::security_manager::SSLContext::HandshakeResult result)); MOCK_METHOD0(OnCertificateUpdateRequired, void()); MOCK_CONST_METHOD1(GetPolicyCertificateData, bool(std::string& data)); - MOCK_METHOD0(OnHandshakeFailed, bool()); + MOCK_METHOD0(OnGetSystemTimeFailed, bool()); + MOCK_METHOD0(OnPTUFailed, void()); +#ifdef EXTERNAL_PROPRIETARY_MODE + MOCK_METHOD0(OnCertDecryptFailed, bool()); +#endif }; } // namespace security_manager_test } // namespace components diff --git a/src/components/include/test/utils/mock_system_time_handler.h b/src/components/include/test/utils/mock_system_time_handler.h index 7bb2a7f0a50..5d82c0a8c74 100644 --- a/src/components/include/test/utils/mock_system_time_handler.h +++ b/src/components/include/test/utils/mock_system_time_handler.h @@ -50,6 +50,7 @@ class MockSystemTimeHandler : public ::utils::SystemTimeHandler { void(utils::SystemTimeListener* listener)); MOCK_METHOD0(GetUTCTime, time_t()); MOCK_CONST_METHOD0(system_time_can_be_received, bool()); + MOCK_METHOD0(ResetPendingSystemTimeRequests, void()); ~MockSystemTimeHandler() {} private: diff --git a/src/components/policy/policy_regular/include/policy/policy_manager_impl.h b/src/components/policy/policy_regular/include/policy/policy_manager_impl.h index d8ab079cf02..c14fb0e1422 100644 --- a/src/components/policy/policy_regular/include/policy/policy_manager_impl.h +++ b/src/components/policy/policy_regular/include/policy/policy_manager_impl.h @@ -1019,7 +1019,7 @@ class PolicyManagerImpl : public PolicyManager { /** * @brief Starts new retry sequence */ - void RetrySequence(); + void StartRetrySequence(); private: /** diff --git a/src/components/policy/policy_regular/src/policy_manager_impl.cc b/src/components/policy/policy_regular/src/policy_manager_impl.cc index e3d2c1780c2..6871a5c4164 100644 --- a/src/components/policy/policy_regular/src/policy_manager_impl.cc +++ b/src/components/policy/policy_regular/src/policy_manager_impl.cc @@ -81,7 +81,7 @@ PolicyManagerImpl::PolicyManagerImpl() , retry_sequence_index_(0) , timer_retry_sequence_("Retry sequence timer", new timer::TimerTaskImpl( - this, &PolicyManagerImpl::RetrySequence)) + this, &PolicyManagerImpl::StartRetrySequence)) , ignition_check(true) , retry_sequence_url_(0, 0, "") , wrong_ptu_update_received_(false) @@ -1217,6 +1217,7 @@ uint32_t PolicyManagerImpl::NextRetryTimeout() { } void PolicyManagerImpl::RefreshRetrySequence() { + LOG4CXX_AUTO_TRACE(logger_); sync_primitives::AutoLock auto_lock(retry_sequence_lock_); retry_sequence_timeout_ = cache_->TimeoutResponse(); retry_sequence_seconds_.clear(); @@ -1438,6 +1439,7 @@ bool PolicyManagerImpl::IsNewApplication( } bool PolicyManagerImpl::ResetPT(const std::string& file_name) { + LOG4CXX_AUTO_TRACE(logger_); cache_->ResetCalculatedPermissions(); const bool result = cache_->ResetPT(file_name); if (result) { @@ -1502,8 +1504,17 @@ void PolicyManagerImpl::set_cache_manager( cache_ = std::shared_ptr(cache_manager); } -void PolicyManagerImpl::RetrySequence() { - LOG4CXX_INFO(logger_, "Start new retry sequence"); +void PolicyManagerImpl::StartRetrySequence() { + LOG4CXX_DEBUG(logger_, "Start new retry sequence"); + + const bool is_exceeded_retries_count = + (retry_sequence_seconds_.size() < retry_sequence_index_); + + if (is_exceeded_retries_count) { + LOG4CXX_WARN(logger_, "Exceeded allowed PTU retry count"); + listener_->OnPTUTimeOut(); + } + update_status_manager_.OnUpdateTimeoutOccurs(); const uint32_t timeout_msec = NextRetryTimeout(); diff --git a/src/components/protocol_handler/CMakeLists.txt b/src/components/protocol_handler/CMakeLists.txt index d18c13337c1..b4123aaf06b 100644 --- a/src/components/protocol_handler/CMakeLists.txt +++ b/src/components/protocol_handler/CMakeLists.txt @@ -35,6 +35,7 @@ include_directories( ${COMPONENTS_DIR}/protocol_handler/include/ ${COMPONENTS_DIR}/connection_handler/include/ ${COMPONENTS_DIR}/application_manager/include + ${CMAKE_BINARY_DIR}/src/components/ ${LOG4CXX_INCLUDE_DIRECTORY} ${BSON_INCLUDE_DIRECTORY} ) diff --git a/src/components/protocol_handler/include/protocol_handler/handshake_handler.h b/src/components/protocol_handler/include/protocol_handler/handshake_handler.h index cb52c9d3752..2c7f7de67ec 100644 --- a/src/components/protocol_handler/include/protocol_handler/handshake_handler.h +++ b/src/components/protocol_handler/include/protocol_handler/handshake_handler.h @@ -57,7 +57,8 @@ class HandshakeHandler : public security_manager::SecurityManagerListener { utils::SemanticVersion& full_version, const SessionContext& context, const uint8_t protocol_version, - std::shared_ptr payload); + std::shared_ptr payload, + ServiceStatusUpdateHandler& service_status_update_handler); ~HandshakeHandler(); @@ -82,13 +83,28 @@ class HandshakeHandler : public security_manager::SecurityManagerListener { * @brief Notification about handshake failure * @return true on success notification handling or false otherwise */ - bool OnHandshakeFailed() OVERRIDE; + bool OnGetSystemTimeFailed() OVERRIDE; /** * @brief Notification that certificate update is required. */ void OnCertificateUpdateRequired() OVERRIDE; + void OnPTUFailed() OVERRIDE; + +#ifdef EXTERNAL_PROPRIETARY_MODE + /** + * @brief OnCertDecryptFailed is called when certificate decryption fails in + * external flow + * @return since this callback is a part of SecurityManagerListener, bool + * return value is used to indicate whether listener instance can be deleted + * by calling entity. if true - listener can be deleted and removed from + * listeners by SecurityManager, false - listener retains its place within + * SecurityManager. + */ + bool OnCertDecryptFailed() OVERRIDE; +#endif + /** * @brief Get connection key of this handler * @return connection key @@ -107,8 +123,21 @@ class HandshakeHandler : public security_manager::SecurityManagerListener { /** * @brief Performs related actions if handshake was failed * @param params set of params used in bson part of message + * @param service_status - service status to be sent to HMI + */ + void ProcessFailedHandshake(BsonObject& params, ServiceStatus service_status); + + /** + * @brief Determines whether service can be protected + * @return true is service can be protected, otherwise - false + */ + bool CanBeProtected() const; + + /** + * @brief Determines whether service is already protected + * @return true is service is already protected, otherwise - false */ - void ProcessFailedHandshake(BsonObject& params); + bool IsAlreadyProtected() const; ProtocolHandlerImpl& protocol_handler_; SessionObserver& session_observer_; @@ -116,6 +145,7 @@ class HandshakeHandler : public security_manager::SecurityManagerListener { utils::SemanticVersion full_version_; const uint8_t protocol_version_; std::shared_ptr payload_; + ServiceStatusUpdateHandler& service_status_update_handler_; }; } // namespace protocol_handler diff --git a/src/components/protocol_handler/include/protocol_handler/protocol_handler_impl.h b/src/components/protocol_handler/include/protocol_handler/protocol_handler_impl.h index 9d6243e274b..336ed1f3381 100644 --- a/src/components/protocol_handler/include/protocol_handler/protocol_handler_impl.h +++ b/src/components/protocol_handler/include/protocol_handler/protocol_handler_impl.h @@ -55,6 +55,7 @@ #include "protocol_handler/protocol_handler_settings.h" #include "protocol_handler/protocol_observer.h" #include "protocol_handler/protocol_packet.h" +#include "protocol_handler/service_status_update_handler.h" #include "protocol_handler/session_observer.h" #include "transport_manager/common.h" #include "transport_manager/transport_adapter/transport_adapter.h" @@ -210,6 +211,16 @@ class ProtocolHandlerImpl void RemoveProtocolObserver(ProtocolObserver* observer) OVERRIDE; + void ProcessFailedPTU() OVERRIDE; + +#ifdef EXTERNAL_PROPRIETARY_MODE + /** + * @brief ProcessFailedCertDecrypt is called to notify security manager that + * certificate decryption failed in the external flow + */ + void ProcessFailedCertDecrypt() OVERRIDE; +#endif + #ifdef ENABLE_SECURITY /** * \brief Sets pointer for SecurityManager layer for managing protection @@ -220,6 +231,9 @@ class ProtocolHandlerImpl security_manager::SecurityManager* security_manager); #endif // ENABLE_SECURITY + void set_service_status_update_handler( + std::unique_ptr handler); + /** * \brief Stop all handling activity */ @@ -278,7 +292,7 @@ class ProtocolHandlerImpl uint8_t session_id, uint8_t service_type); - void NotifyOnFailedHandshake() OVERRIDE; + void NotifyOnGetSystemTimeFailed() OVERRIDE; // TODO(Ezamakhov): move Ack/Nack as interface for StartSessionHandler /** @@ -436,9 +450,6 @@ class ProtocolHandlerImpl void NotifySessionStarted(const SessionContext& context, std::vector& rejected_params) OVERRIDE; - void OnAuthTokenUpdated(const std::string& policy_app_id, - const std::string& auth_token) OVERRIDE; - #ifdef BUILD_TESTS const impl::FromMobileQueue& get_from_mobile_queue() const { return raw_ford_messages_from_mobile_; @@ -523,10 +534,6 @@ class ProtocolHandlerImpl void OnTMMessageSendFailed(const transport_manager::DataSendError& error, const RawMessagePtr message) OVERRIDE; - void OnConnectionPending( - const transport_manager::DeviceInfo& device_info, - const transport_manager::ConnectionUID connection_id) OVERRIDE; - void OnConnectionEstablished( const transport_manager::DeviceInfo& device_info, const transport_manager::ConnectionUID connection_id) OVERRIDE; @@ -790,6 +797,8 @@ class ProtocolHandlerImpl sync_primitives::Lock start_session_frame_map_lock_; StartSessionFrameMap start_session_frame_map_; + std::unique_ptr service_status_update_handler_; + // Map policy app id -> auth token sync_primitives::Lock auth_token_map_lock_; std::map auth_token_map_; diff --git a/src/components/protocol_handler/include/protocol_handler/service_status_update_handler.h b/src/components/protocol_handler/include/protocol_handler/service_status_update_handler.h new file mode 100644 index 00000000000..125f3b2909b --- /dev/null +++ b/src/components/protocol_handler/include/protocol_handler/service_status_update_handler.h @@ -0,0 +1,86 @@ +/* + Copyright (c) 2019, Ford Motor Company + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following + disclaimer in the documentation and/or other materials provided with the + distribution. + + Neither the name of the Ford Motor Company nor the names of its contributors + may be used to endorse or promote products derived from this software + without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef SRC_COMPONENTS_PROTOCOL_HANDLER_INCLUDE_PROTOCOL_HANDLER_SERVICE_STATUS_UPDATE_HANDLER_H_ +#define SRC_COMPONENTS_PROTOCOL_HANDLER_INCLUDE_PROTOCOL_HANDLER_SERVICE_STATUS_UPDATE_HANDLER_H_ + +#include "protocol_handler/service_status_update_handler_listener.h" + +namespace protocol_handler { + +/** + * @brief ServiceUpdateFailureReason helper enum containing reasons for + * service + * status to be updated + */ +enum class ServiceStatus { + INVALID_ENUM = -1, + SERVICE_RECEIVED, + SERVICE_ACCEPTED, + SERVICE_START_FAILED, + PTU_FAILED, + CERT_INVALID, + INVALID_TIME +}; + +/** + * @brief ServiceStatusUpdateHandler class is used to notify listeners about + * occured events during service start + */ +class ServiceStatusUpdateHandler { + public: + /** + * @brief ServiceStatusUpdateHandler class constructor + * @param listener pointer to ServiceStatusUpdateHandlerListener instance + */ + ServiceStatusUpdateHandler(ServiceStatusUpdateHandlerListener* listener) + : listener_(listener) {} + + /** + * @brief OnServiceUpdate callback that is invoked in case of + * service status update needed + * @param connection_key - connection key + * @param service_type enum value containing type of service. + * @param service_status enum value containing status of service. + * received + */ + void OnServiceUpdate(const uint32_t connection_key, + const protocol_handler::ServiceType service_type, + const ServiceStatus service_status); + + private: + ServiceStatusUpdateHandlerListener* listener_; +}; + +} // namespace protocol_handler + +#endif // SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_SERVICE_STATUS_UPDATE_HANDLER_H_ diff --git a/src/components/protocol_handler/include/protocol_handler/service_status_update_handler_listener.h b/src/components/protocol_handler/include/protocol_handler/service_status_update_handler_listener.h new file mode 100644 index 00000000000..6e1e4ee6c22 --- /dev/null +++ b/src/components/protocol_handler/include/protocol_handler/service_status_update_handler_listener.h @@ -0,0 +1,77 @@ +/* + * Copyright (c) 2019, Ford Motor Company + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following + * disclaimer in the documentation and/or other materials provided with the + * distribution. + * + * Neither the name of the Ford Motor Company nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef SRC_COMPONENTS_PROTOCOL_HANDLER_INCLUDE_PROTOCOL_HANDLER_SERVICE_STATUS_UPDATE_HANDLER_LISTENER_H_ +#define SRC_COMPONENTS_PROTOCOL_HANDLER_INCLUDE_PROTOCOL_HANDLER_SERVICE_STATUS_UPDATE_HANDLER_LISTENER_H_ + +#include "interfaces/HMI_API.h" +#include "protocol_handler/protocol_handler.h" +#include "transport_manager/transport_manager.h" +#include "utils/optional.h" + +namespace protocol_handler { +/** + * @brief Converts service type enum value from protocol_handler to hmi_apis. + * @param service_type protocol_handler enum value. + **/ +hmi_apis::Common_ServiceType::eType GetHMIServiceType( + protocol_handler::ServiceType service_type); + +/** + * @brief ServiceStatusUpdateHandlerListener provides callbacks interface with + * a purpose to notify HMI on successful or failed state updates of different + * services + **/ +class ServiceStatusUpdateHandlerListener { + public: + /** + * @brief ProcessServiceStatusUpdate callback that is invoked in case of + * service + * status update + * @param connection_key - connection key + * @param service_type enum value containing type of service. + * @param service_event enum value containing event that occured during + * service start. + * @param service_update_reason enum value containing reason why service_event + * occured. + **/ + virtual void ProcessServiceStatusUpdate( + const uint32_t connection_key, + hmi_apis::Common_ServiceType::eType service_type, + hmi_apis::Common_ServiceEvent::eType service_event, + utils::Optional + service_update_reason) = 0; +}; + +} // namespace protocol_handler + +#endif diff --git a/src/components/protocol_handler/src/handshake_handler.cc b/src/components/protocol_handler/src/handshake_handler.cc index fa0b3750184..2109e637a45 100644 --- a/src/components/protocol_handler/src/handshake_handler.cc +++ b/src/components/protocol_handler/src/handshake_handler.cc @@ -38,23 +38,27 @@ #include "protocol_handler/protocol_packet.h" #include "protocol_handler/session_observer.h" #include "security_manager/security_manager.h" +#include "utils/helpers.h" namespace protocol_handler { CREATE_LOGGERPTR_GLOBAL(logger_, "ProtocolHandler") -HandshakeHandler::HandshakeHandler(ProtocolHandlerImpl& protocol_handler, - SessionObserver& session_observer, - utils::SemanticVersion& full_version, - const SessionContext& context, - const uint8_t protocol_version, - std::shared_ptr payload) +HandshakeHandler::HandshakeHandler( + ProtocolHandlerImpl& protocol_handler, + SessionObserver& session_observer, + utils::SemanticVersion& full_version, + const SessionContext& context, + const uint8_t protocol_version, + std::shared_ptr payload, + ServiceStatusUpdateHandler& service_status_update_handler) : protocol_handler_(protocol_handler) , session_observer_(session_observer) , context_(context) , full_version_(full_version) , protocol_version_(protocol_version) - , payload_(payload) {} + , payload_(payload) + , service_status_update_handler_(service_status_update_handler) {} HandshakeHandler::~HandshakeHandler() { LOG4CXX_DEBUG(logger_, "Destroying of HandshakeHandler: " << this); @@ -69,26 +73,51 @@ bool HandshakeHandler::GetPolicyCertificateData(std::string& data) const { return false; } -void HandshakeHandler::OnCertificateUpdateRequired() {} +void HandshakeHandler::OnCertificateUpdateRequired() { + LOG4CXX_AUTO_TRACE(logger_); +} -bool HandshakeHandler::OnHandshakeFailed() { +#if defined(EXTERNAL_PROPRIETARY_MODE) && defined(ENABLE_SECURITY) +bool HandshakeHandler::OnCertDecryptFailed() { + LOG4CXX_AUTO_TRACE(logger_); if (payload_) { - ProcessFailedHandshake(*payload_); + ProcessFailedHandshake(*payload_, ServiceStatus::CERT_INVALID); + } + + return true; +} +#endif + +bool HandshakeHandler::OnGetSystemTimeFailed() { + LOG4CXX_AUTO_TRACE(logger_); + + if (payload_) { + ProcessFailedHandshake(*payload_, ServiceStatus::INVALID_TIME); } else { BsonObject params; bson_object_initialize_default(¶ms); - ProcessFailedHandshake(params); + ProcessFailedHandshake(params, ServiceStatus::INVALID_TIME); bson_object_deinitialize(¶ms); } return true; } +void HandshakeHandler::OnPTUFailed() { + LOG4CXX_AUTO_TRACE(logger_); + if (payload_) { + ProcessFailedHandshake(*payload_, ServiceStatus::PTU_FAILED); + } +} + bool HandshakeHandler::OnHandshakeDone( uint32_t connection_key, security_manager::SSLContext::HandshakeResult result) { LOG4CXX_AUTO_TRACE(logger_); + LOG4CXX_DEBUG(logger_, + "OnHandshakeDone for service : " << context_.service_type_); + if (connection_key != this->connection_key()) { LOG4CXX_DEBUG(logger_, "Listener " << this @@ -106,7 +135,7 @@ bool HandshakeHandler::OnHandshakeDone( if (success) { ProcessSuccessfulHandshake(connection_key, *payload_); } else { - ProcessFailedHandshake(*payload_); + ProcessFailedHandshake(*payload_, ServiceStatus::CERT_INVALID); } } else { BsonObject params; @@ -114,7 +143,7 @@ bool HandshakeHandler::OnHandshakeDone( if (success) { ProcessSuccessfulHandshake(connection_key, params); } else { - ProcessFailedHandshake(params); + ProcessFailedHandshake(params, ServiceStatus::CERT_INVALID); } bson_object_deinitialize(¶ms); } @@ -122,20 +151,25 @@ bool HandshakeHandler::OnHandshakeDone( return true; } +bool HandshakeHandler::CanBeProtected() const { + const auto& force_unprotected = + protocol_handler_.get_settings().force_unprotected_service(); + + return !(helpers::in_range(force_unprotected, context_.service_type_)); +} + +bool HandshakeHandler::IsAlreadyProtected() const { + return (session_observer_.GetSSLContext(this->connection_key(), + context_.service_type_) != NULL); +} + void HandshakeHandler::ProcessSuccessfulHandshake(const uint32_t connection_key, BsonObject& params) { LOG4CXX_AUTO_TRACE(logger_); - const std::vector& force_unprotected = - protocol_handler_.get_settings().force_unprotected_service(); - const bool can_be_protected = - std::find(force_unprotected.begin(), - force_unprotected.end(), - context_.service_type_) == force_unprotected.end(); + const bool is_service_already_protected = IsAlreadyProtected(); - const bool is_service_already_protected = - session_observer_.GetSSLContext(connection_key, context_.service_type_) != - NULL; + const bool can_be_protected = CanBeProtected(); LOG4CXX_DEBUG(logger_, "Service can be protected: " << can_be_protected @@ -144,6 +178,10 @@ void HandshakeHandler::ProcessSuccessfulHandshake(const uint32_t connection_key, if (can_be_protected && !is_service_already_protected) { session_observer_.SetProtectionFlag(connection_key, context_.service_type_); + service_status_update_handler_.OnServiceUpdate( + this->connection_key(), + context_.service_type_, + ServiceStatus::SERVICE_ACCEPTED); protocol_handler_.SendStartSessionAck(context_.connection_id_, context_.new_session_id_, protocol_version_, @@ -153,6 +191,10 @@ void HandshakeHandler::ProcessSuccessfulHandshake(const uint32_t connection_key, full_version_, params); } else { + service_status_update_handler_.OnServiceUpdate( + this->connection_key(), + context_.service_type_, + ServiceStatus::SERVICE_START_FAILED); protocol_handler_.SendStartSessionNAck(context_.connection_id_, context_.new_session_id_, protocol_version_, @@ -160,7 +202,8 @@ void HandshakeHandler::ProcessSuccessfulHandshake(const uint32_t connection_key, } } -void HandshakeHandler::ProcessFailedHandshake(BsonObject& params) { +void HandshakeHandler::ProcessFailedHandshake(BsonObject& params, + ServiceStatus service_status) { LOG4CXX_AUTO_TRACE(logger_); LOG4CXX_DEBUG(logger_, "Handshake failed"); const std::vector& force_protected = @@ -177,6 +220,10 @@ void HandshakeHandler::ProcessFailedHandshake(BsonObject& params) { << context_.is_new_service_); if (can_be_unprotected && context_.is_new_service_) { + service_status_update_handler_.OnServiceUpdate( + this->connection_key(), + context_.service_type_, + ServiceStatus::SERVICE_ACCEPTED); protocol_handler_.SendStartSessionAck(context_.connection_id_, context_.new_session_id_, protocol_version_, @@ -186,6 +233,8 @@ void HandshakeHandler::ProcessFailedHandshake(BsonObject& params) { full_version_, params); } else { + service_status_update_handler_.OnServiceUpdate( + this->connection_key(), context_.service_type_, service_status); protocol_handler_.SendStartSessionNAck(context_.connection_id_, context_.new_session_id_, protocol_version_, diff --git a/src/components/protocol_handler/src/protocol_handler_impl.cc b/src/components/protocol_handler/src/protocol_handler_impl.cc index d95c57f0cc4..70148a1d735 100644 --- a/src/components/protocol_handler/src/protocol_handler_impl.cc +++ b/src/components/protocol_handler/src/protocol_handler_impl.cc @@ -1129,13 +1129,25 @@ void ProtocolHandlerImpl::OnUnexpectedDisconnect( OnConnectionClosed(connection_id); } -void ProtocolHandlerImpl::NotifyOnFailedHandshake() { +void ProtocolHandlerImpl::NotifyOnGetSystemTimeFailed() { LOG4CXX_AUTO_TRACE(logger_); + security_manager_->ResetPendingSystemTimeRequests(); #ifdef ENABLE_SECURITY - security_manager_->NotifyListenersOnHandshakeFailed(); + security_manager_->NotifyListenersOnGetSystemTimeFailed(); #endif // ENABLE_SECURITY } +void ProtocolHandlerImpl::ProcessFailedPTU() { + security_manager_->ProcessFailedPTU(); +} + +#ifdef EXTERNAL_PROPRIETARY_MODE +void ProtocolHandlerImpl::ProcessFailedCertDecrypt() { + LOG4CXX_AUTO_TRACE(logger_); + security_manager_->ProcessFailedCertDecrypt(); +} +#endif + void ProtocolHandlerImpl::OnTransportConfigUpdated( const transport_manager::transport_adapter::TransportConfig& configs) { LOG4CXX_AUTO_TRACE(logger_); @@ -1639,6 +1651,12 @@ RESULT_CODE ProtocolHandlerImpl::HandleControlMessageStartSession( std::find(audio_transports.begin(), audio_transports.end(), transport) != audio_transports.end(); + const uint32_t connection_key = session_observer_.KeyFromPair( + packet->connection_id(), packet->session_id()); + + service_status_update_handler_->OnServiceUpdate( + connection_key, service_type, ServiceStatus::SERVICE_RECEIVED); + if ((ServiceType::kMobileNav == service_type && !is_video_allowed) || (ServiceType::kAudio == service_type && !is_audio_allowed)) { LOG4CXX_DEBUG(logger_, @@ -1836,12 +1854,14 @@ void ProtocolHandlerImpl::NotifySessionStarted( context.connection_id_, context.new_session_id_); std::shared_ptr handler = - std::make_shared(*this, - session_observer_, - *fullVersion, - context, - packet->protocol_version(), - start_session_ack_params); + std::make_shared( + *this, + session_observer_, + *fullVersion, + context, + packet->protocol_version(), + start_session_ack_params, + *(service_status_update_handler_.get())); security_manager::SSLContext* ssl_context = security_manager_->CreateSSLContext( @@ -1872,6 +1892,10 @@ void ProtocolHandlerImpl::NotifySessionStarted( // mark service as protected session_observer_.SetProtectionFlag(connection_key, service_type); // Start service as protected with current SSLContext + service_status_update_handler_->OnServiceUpdate( + connection_key, + context.service_type_, + ServiceStatus::SERVICE_ACCEPTED); SendStartSessionAck(context.connection_id_, context.new_session_id_, packet->protocol_version(), @@ -1908,7 +1932,11 @@ void ProtocolHandlerImpl::NotifySessionStarted( return; } #endif // ENABLE_SECURITY + const uint32_t connection_key = session_observer_.KeyFromPair( + context.connection_id_, context.new_session_id_); if (rejected_params.empty()) { + service_status_update_handler_->OnServiceUpdate( + connection_key, context.service_type_, ServiceStatus::SERVICE_ACCEPTED); SendStartSessionAck(context.connection_id_, context.new_session_id_, packet->protocol_version(), @@ -1918,6 +1946,10 @@ void ProtocolHandlerImpl::NotifySessionStarted( *fullVersion, *start_session_ack_params); } else { + service_status_update_handler_->OnServiceUpdate( + connection_key, + context.service_type_, + ServiceStatus::SERVICE_START_FAILED); SendStartSessionNAck(context.connection_id_, packet->session_id(), protocol_version, @@ -2099,6 +2131,11 @@ void ProtocolHandlerImpl::Stop() { start_session_frame_map_.clear(); } +void ProtocolHandlerImpl::set_service_status_update_handler( + std::unique_ptr handler) { + service_status_update_handler_ = std::move(handler); +} + #ifdef ENABLE_SECURITY void ProtocolHandlerImpl::set_security_manager( security_manager::SecurityManager* security_manager) { diff --git a/src/components/protocol_handler/src/service_status_update_handler.cc b/src/components/protocol_handler/src/service_status_update_handler.cc new file mode 100644 index 00000000000..b0ffaee9b45 --- /dev/null +++ b/src/components/protocol_handler/src/service_status_update_handler.cc @@ -0,0 +1,82 @@ +#include "protocol_handler/service_status_update_handler.h" +#include "interfaces/HMI_API.h" + +namespace protocol_handler { + +hmi_apis::Common_ServiceType::eType GetHMIServiceType( + protocol_handler::ServiceType service_type) { + using namespace hmi_apis; + using namespace protocol_handler; + switch (service_type) { + case SERVICE_TYPE_RPC: { + return Common_ServiceType::RPC; + } + case SERVICE_TYPE_AUDIO: { + return Common_ServiceType::AUDIO; + } + case SERVICE_TYPE_NAVI: { + return Common_ServiceType::VIDEO; + } + default: { return Common_ServiceType::INVALID_ENUM; } + } +} + +void ServiceStatusUpdateHandler::OnServiceUpdate( + const uint32_t connection_key, + const protocol_handler::ServiceType service_type, + ServiceStatus service_status) { + using namespace hmi_apis; + typedef utils::Optional + UpdateReasonOptional; + auto hmi_service_type = GetHMIServiceType(service_type); + + switch (service_status) { + case ServiceStatus::SERVICE_RECEIVED: { + return listener_->ProcessServiceStatusUpdate( + connection_key, + hmi_service_type, + Common_ServiceEvent::REQUEST_RECEIVED, + UpdateReasonOptional(UpdateReasonOptional::EMPTY)); + } + case ServiceStatus::SERVICE_ACCEPTED: { + return listener_->ProcessServiceStatusUpdate( + connection_key, + hmi_service_type, + Common_ServiceEvent::REQUEST_ACCEPTED, + UpdateReasonOptional(UpdateReasonOptional::EMPTY)); + } + case ServiceStatus::SERVICE_START_FAILED: { + return listener_->ProcessServiceStatusUpdate( + connection_key, + hmi_service_type, + Common_ServiceEvent::REQUEST_REJECTED, + UpdateReasonOptional(UpdateReasonOptional::EMPTY)); + } + case ServiceStatus::PTU_FAILED: { + auto update_reason = Common_ServiceUpdateReason::PTU_FAILED; + return listener_->ProcessServiceStatusUpdate( + connection_key, + hmi_service_type, + Common_ServiceEvent::REQUEST_REJECTED, + update_reason); + } + case ServiceStatus::CERT_INVALID: { + auto update_reason = Common_ServiceUpdateReason::INVALID_CERT; + return listener_->ProcessServiceStatusUpdate( + connection_key, + hmi_service_type, + Common_ServiceEvent::REQUEST_REJECTED, + update_reason); + } + case ServiceStatus::INVALID_TIME: { + auto update_reason = Common_ServiceUpdateReason::INVALID_TIME; + return listener_->ProcessServiceStatusUpdate( + connection_key, + hmi_service_type, + Common_ServiceEvent::REQUEST_REJECTED, + update_reason); + } + default: { return; } + } +} +} // namespace protocol_handler diff --git a/src/components/security_manager/include/security_manager/security_manager_impl.h b/src/components/security_manager/include/security_manager/security_manager_impl.h index f2a417a43d7..ee00e0774af 100644 --- a/src/components/security_manager/include/security_manager/security_manager_impl.h +++ b/src/components/security_manager/include/security_manager/security_manager_impl.h @@ -200,7 +200,7 @@ class SecurityManagerImpl : public SecurityManager, /** * @brief Notify all listeners that handshake was failed */ - void NotifyListenersOnHandshakeFailed() OVERRIDE; + void NotifyListenersOnGetSystemTimeFailed() OVERRIDE; /** * @brief Check is policy certificate data is empty @@ -214,6 +214,16 @@ class SecurityManagerImpl : public SecurityManager, */ static const char* ConfigSection(); + void ProcessFailedPTU() OVERRIDE; + +#ifdef EXTERNAL_PROPRIETARY_MODE + /** + * @brief ProcessFailedCertDecrypt is called to notify listeners that + * certificate decryption failed in the external flow + */ + void ProcessFailedCertDecrypt() OVERRIDE; +#endif + private: /** * \brief Sends Handshake binary data to mobile application @@ -280,6 +290,17 @@ class SecurityManagerImpl : public SecurityManager, */ void OnSystemTimeArrived(const time_t utc_time) OVERRIDE; + /** + * @brief OnSystemTimeFailed Notify about system request failure + */ + void OnSystemTimeFailed() OVERRIDE; + + /** + * @brief ResetPendingSystemTimeRequests resets waiting for system time + * requests flag + */ + void ResetPendingSystemTimeRequests(); + // Thread that pumps handshake data SecurityMessageLoop security_messages_; diff --git a/src/components/security_manager/src/security_manager_impl.cc b/src/components/security_manager/src/security_manager_impl.cc index 19c2ee2b11a..488b4745be0 100644 --- a/src/components/security_manager/src/security_manager_impl.cc +++ b/src/components/security_manager/src/security_manager_impl.cc @@ -213,6 +213,13 @@ void SecurityManagerImpl::ResumeHandshake(uint32_t connection_key) { return; } + LOG4CXX_DEBUG(logger_, + "Connection key : " + << connection_key + << " is waiting for certificate: " << std::boolalpha + << waiting_for_certificate_ << " and has certificate: " + << ssl_context->HasCertificate()); + ssl_context->ResetConnection(); if (!waiting_for_certificate_ && !ssl_context->HasCertificate()) { NotifyListenersOnHandshakeDone(connection_key, @@ -228,6 +235,7 @@ void SecurityManagerImpl::StartHandshake(uint32_t connection_key) { LOG4CXX_INFO(logger_, "StartHandshake: connection_key " << connection_key); security_manager::SSLContext* ssl_context = session_observer_->GetSSLContext( connection_key, protocol_handler::kControl); + if (!ssl_context) { const std::string error_text( "StartHandshake failed, " @@ -277,6 +285,7 @@ void SecurityManagerImpl::ProceedHandshake( time_t cert_due_date; if (!ssl_context->GetCertificateDueDate(cert_due_date)) { LOG4CXX_ERROR(logger_, "Failed to get certificate due date!"); + PostponeHandshake(connection_key); return; } @@ -388,6 +397,56 @@ void SecurityManagerImpl::OnSystemTimeArrived(const time_t utc_time) { awaiting_time_connections_.clear(); } +void SecurityManagerImpl::OnSystemTimeFailed() { + LOG4CXX_AUTO_TRACE(logger_); + { + sync_primitives::AutoLock lock(waiters_lock_); + waiting_for_time_ = false; + } + + NotifyListenersOnGetSystemTimeFailed(); + + awaiting_time_connections_.clear(); +} + +void SecurityManagerImpl::ProcessFailedPTU() { + LOG4CXX_AUTO_TRACE(logger_); + if (listeners_.empty()) { + LOG4CXX_DEBUG(logger_, "listeners arrays IS EMPTY!"); + return; + } + std::for_each(listeners_.begin(), + listeners_.end(), + std::mem_fun(&SecurityManagerListener::OnPTUFailed)); +} + +#ifdef EXTERNAL_PROPRIETARY_MODE +void SecurityManagerImpl::ProcessFailedCertDecrypt() { + LOG4CXX_AUTO_TRACE(logger_); + { + sync_primitives::AutoLock lock(waiters_lock_); + waiting_for_certificate_ = false; + } + + std::list listeners_to_remove; + for (auto listener : listeners_) { + if (listener->OnCertDecryptFailed()) { + listeners_to_remove.push_back(listener); + } + } + + for (auto& listener : listeners_to_remove) { + auto it = std::find(listeners_.begin(), listeners_.end(), listener); + DCHECK(it != listeners_.end()); + LOG4CXX_DEBUG(logger_, "Destroying listener: " << *it); + delete (*it); + listeners_.erase(it); + } + + awaiting_certificate_connections_.clear(); +} +#endif + void SecurityManagerImpl::NotifyListenersOnHandshakeDone( const uint32_t& connection_key, SSLContext::HandshakeResult error) { LOG4CXX_AUTO_TRACE(logger_); @@ -412,11 +471,15 @@ void SecurityManagerImpl::NotifyOnCertificateUpdateRequired() { } } -void SecurityManagerImpl::NotifyListenersOnHandshakeFailed() { +void SecurityManagerImpl::ResetPendingSystemTimeRequests() { + system_time_handler_->ResetPendingSystemTimeRequests(); +} + +void SecurityManagerImpl::NotifyListenersOnGetSystemTimeFailed() { LOG4CXX_AUTO_TRACE(logger_); std::list::iterator it = listeners_.begin(); while (it != listeners_.end()) { - if ((*it)->OnHandshakeFailed()) { + if ((*it)->OnGetSystemTimeFailed()) { LOG4CXX_DEBUG(logger_, "Destroying listener: " << *it); delete (*it); it = listeners_.erase(it); diff --git a/src/components/utils/include/utils/system_time_handler.h b/src/components/utils/include/utils/system_time_handler.h index 15b2dd0cca2..2013622f309 100644 --- a/src/components/utils/include/utils/system_time_handler.h +++ b/src/components/utils/include/utils/system_time_handler.h @@ -50,6 +50,11 @@ class SystemTimeListener { * @param utc_time current system time. */ virtual void OnSystemTimeArrived(const time_t utc_time) = 0; + + /** + * @brief OnSystemTimeFailed Notify about system request failure + */ + virtual void OnSystemTimeFailed() = 0; }; /** @@ -96,6 +101,12 @@ class SystemTimeHandler { */ time_t GetUTCTime(); + /** + * @brief ResetPendingSystemTimeRequests resets waiting for system time + * requests flag + */ + virtual void ResetPendingSystemTimeRequests() = 0; + /** * @brief Checks if system time is ready * and can be requested by GetSystemTime request From c7d79190ddd59156c76a5aee1774611ad72d3709 Mon Sep 17 00:00:00 2001 From: sniukalov Date: Thu, 30 May 2019 09:44:36 +0300 Subject: [PATCH 03/19] Add UT's for service status update to HMI feature --- ...service_status_update_notification_test.cc | 96 +++++++++ .../test/application_manager_impl_test.cc | 104 +++++++++- .../application_manager/mock_message_helper.h | 6 +- .../message_helper/message_helper_test.cc | 86 ++++++++ .../service_status_update_handler_listener.h | 6 +- .../src/service_status_update_handler.cc | 9 +- ...k_service_status_update_handler_listener.h | 57 +++++ .../test/protocol_handler_tm_test.cc | 16 +- .../service_status_update_handler_test.cc | 196 ++++++++++++++++++ 9 files changed, 569 insertions(+), 7 deletions(-) create mode 100644 src/components/application_manager/rpc_plugins/sdl_rpc_plugin/test/commands/hmi/on_service_status_update_notification_test.cc create mode 100644 src/components/protocol_handler/test/include/protocol_handler/mock_service_status_update_handler_listener.h create mode 100644 src/components/protocol_handler/test/service_status_update_handler_test.cc diff --git a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/test/commands/hmi/on_service_status_update_notification_test.cc b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/test/commands/hmi/on_service_status_update_notification_test.cc new file mode 100644 index 00000000000..5df1d6e2076 --- /dev/null +++ b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/test/commands/hmi/on_service_status_update_notification_test.cc @@ -0,0 +1,96 @@ +/* + * Copyright (c) 2019, Ford Motor Company + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following + * disclaimer in the documentation and/or other materials provided with the + * distribution. + * + * Neither the name of the Ford Motor Company nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ +#include + +#include "application_manager/commands/commands_test.h" +#include "application_manager/mock_application.h" +#include "application_manager/mock_application_manager.h" +#include "application_manager/smart_object_keys.h" +#include "gtest/gtest.h" +#include "hmi/on_service_status_update_notification.h" +#include "smart_objects/smart_object.h" + +namespace test { +namespace components { +namespace commands_test { +namespace hmi_commands_test { +namespace on_service_status_update_notification { + +using namespace application_manager; +using sdl_rpc_plugin::commands::hmi::OnServiceStatusUpdateNotification; + +typedef std::shared_ptr NotificationPtr; +typedef hmi_apis::Common_ServiceType::eType ServiceType; +typedef hmi_apis::Common_ServiceEvent::eType ServiceEvent; + +namespace { +const uint32_t kConnectionKey = 1232u; +const uint32_t kHmi_app_id = 321u; +} // namespace + +class OnServiceStatusUpdateNotificationTest + : public CommandsTest { + public: + OnServiceStatusUpdateNotificationTest() + : message_(CreateMessage(smart_objects::SmartType_Map)) {} + + public: + MessageSharedPtr message_; + NotificationPtr command_; +}; + +TEST_F(OnServiceStatusUpdateNotificationTest, SendNotificationToHMI) { + (*message_)[strings::msg_params][hmi_notification::service_type] = + ServiceType::AUDIO; + (*message_)[strings::msg_params][hmi_notification::service_event] = + ServiceEvent::REQUEST_ACCEPTED; + (*message_)[strings::msg_params][strings::app_id] = kConnectionKey; + command_ = CreateCommand(message_); + + EXPECT_CALL(mock_rpc_service_, SendMessageToHMI(message_)).Times(1); + + auto mock_app = std::make_shared >(); + + ON_CALL(app_mngr_, application(kConnectionKey)) + .WillByDefault(Return(mock_app)); + + ON_CALL(*mock_app, hmi_app_id()).WillByDefault(Return(kHmi_app_id)); + + command_->Init(); + command_->Run(); +} + +} // namespace on_service_status_update_notification +} // namespace hmi_commands_test +} // namespace commands_test +} // namespace components +} // namespace test diff --git a/src/components/application_manager/test/application_manager_impl_test.cc b/src/components/application_manager/test/application_manager_impl_test.cc index 1f0b705f41c..cc6c1418c4f 100644 --- a/src/components/application_manager/test/application_manager_impl_test.cc +++ b/src/components/application_manager/test/application_manager_impl_test.cc @@ -105,6 +105,13 @@ const std::string kAppName = "appName"; const WindowID kDefaultWindowId = mobile_apis::PredefinedWindows::DEFAULT_WINDOW; +typedef MockMessageHelper::MockServiceStatusUpdateNotificationBuilder* + MockServiceStatusUpdatePtr; +typedef hmi_apis::Common_ServiceUpdateReason::eType ServiceUpdateReason; +typedef hmi_apis::Common_ServiceType::eType ServiceType; +typedef hmi_apis::Common_ServiceEvent::eType ServiceEvent; +typedef utils::Optional UpdateReasonOptional; + #if defined(CLOUD_APP_WEBSOCKET_TRANSPORT_SUPPORT) // Cloud application params const std::string kEndpoint = "endpoint"; @@ -119,7 +126,20 @@ const bool kEnabled = true; #endif // CLOUD_APP_WEBSOCKET_TRANSPORT_SUPPORT } // namespace -class ApplicationManagerImplTest : public ::testing::Test { +struct ServiceStatus { + ServiceType service_type_; + ServiceEvent service_event_; + UpdateReasonOptional reason_; + + ServiceStatus(ServiceType type, + ServiceEvent event, + UpdateReasonOptional reason) + : service_type_(type), service_event_(event), reason_(reason) {} +}; + +class ApplicationManagerImplTest + : public ::testing::Test, + public ::testing::WithParamInterface { public: ApplicationManagerImplTest() : app_id_(0u) @@ -133,6 +153,8 @@ class ApplicationManagerImplTest : public ::testing::Test { new MockAppServiceManager(mock_app_mngr_, mock_last_state_)) , mock_message_helper_( application_manager::MockMessageHelper::message_helper_mock()) + , mock_service_status_update_(application_manager::MockMessageHelper:: + on_service_update_builder_mock()) { #ifdef ENABLE_LOG @@ -149,10 +171,17 @@ class ApplicationManagerImplTest : public ::testing::Test { CreateAppManager(); ON_CALL(*mock_app_ptr_, app_id()).WillByDefault(Return(kConnectionKey)); ON_CALL(*mock_app_ptr_, device()).WillByDefault(Return(kDeviceId)); + ON_CALL(mock_session_observer_, GetDataOnSessionKey(_, _, _, _)) + .WillByDefault(DoAll(SetArgPointee<3u>(kDeviceId), Return(0))); ON_CALL(mock_connection_handler_, GetDataOnSessionKey(_, _, _, &kDeviceId)) .WillByDefault(DoAll(SetArgPointee<3u>(app_id_), Return(0))); ON_CALL(mock_connection_handler_, get_session_observer()) .WillByDefault(ReturnRef(mock_session_observer_)); + std::unique_ptr unique_rpc_service( + new MockRPCService); + app_manager_impl_->SetRPCService(unique_rpc_service); + mock_rpc_service_ = + static_cast(&(app_manager_impl_->GetRPCService())); app_manager_impl_->SetMockRPCService(mock_rpc_service_); app_manager_impl_->resume_controller().set_resumption_storage( mock_storage_); @@ -250,11 +279,83 @@ class ApplicationManagerImplTest : public ::testing::Test { std::unique_ptr app_manager_impl_; MockAppServiceManager* mock_app_service_manager_; application_manager::MockMessageHelper* mock_message_helper_; + MockServiceStatusUpdatePtr mock_service_status_update_; std::shared_ptr mock_app_ptr_; NiceMock mock_protocol_handler_; }; +INSTANTIATE_TEST_CASE_P( + ProcessServiceStatusUpdate_REQUEST_ACCEPTED, + ApplicationManagerImplTest, + ::testing::Values(ServiceStatus(ServiceType::AUDIO, + ServiceEvent::REQUEST_ACCEPTED, + UpdateReasonOptional::EMPTY), + ServiceStatus(ServiceType::VIDEO, + ServiceEvent::REQUEST_ACCEPTED, + UpdateReasonOptional::EMPTY), + ServiceStatus(ServiceType::RPC, + ServiceEvent::REQUEST_ACCEPTED, + UpdateReasonOptional::EMPTY))); + +INSTANTIATE_TEST_CASE_P( + ProcessServiceStatusUpdate_REQUEST_RECEIVED, + ApplicationManagerImplTest, + ::testing::Values(ServiceStatus(ServiceType::AUDIO, + ServiceEvent::REQUEST_RECEIVED, + UpdateReasonOptional::EMPTY), + ServiceStatus(ServiceType::VIDEO, + ServiceEvent::REQUEST_RECEIVED, + UpdateReasonOptional::EMPTY), + ServiceStatus(ServiceType::RPC, + ServiceEvent::REQUEST_RECEIVED, + UpdateReasonOptional::EMPTY))); + +INSTANTIATE_TEST_CASE_P( + ProcessServiceStatusUpdate_REQUEST_REJECTED, + ApplicationManagerImplTest, + ::testing::Values(ServiceStatus(ServiceType::AUDIO, + ServiceEvent::REQUEST_REJECTED, + UpdateReasonOptional::EMPTY), + ServiceStatus(ServiceType::VIDEO, + ServiceEvent::REQUEST_REJECTED, + UpdateReasonOptional::EMPTY), + ServiceStatus(ServiceType::RPC, + ServiceEvent::REQUEST_REJECTED, + UpdateReasonOptional::EMPTY))); + +TEST_P(ApplicationManagerImplTest, + ProcessServiceStatusUpdate_SendMessageToHMI) { + smart_objects::SmartObjectSPtr notification_( + new smart_objects::SmartObject(smart_objects::SmartType_Map)); + (*notification_)[strings::msg_params][hmi_notification::service_type] = + GetParam().service_type_; + (*notification_)[strings::msg_params][hmi_notification::service_event] = + GetParam().service_event_; + (*notification_)[strings::msg_params][strings::app_id] = kConnectionKey; + + AddMockApplication(); + + ON_CALL(*mock_app_ptr_, app_id()).WillByDefault(Return(kConnectionKey)); + ON_CALL(*mock_service_status_update_, + CreateBuilder(GetParam().service_type_, GetParam().service_event_)) + .WillByDefault(Return(*mock_service_status_update_)); + ON_CALL(*mock_service_status_update_, AddAppID(kConnectionKey)) + .WillByDefault(ReturnRef(*mock_service_status_update_)); + ON_CALL(*mock_service_status_update_, AddServiceUpdateReason(_)) + .WillByDefault(ReturnRef(*mock_service_status_update_)); + ON_CALL(*mock_service_status_update_, notification()) + .WillByDefault(Return(notification_)); + + EXPECT_CALL(*mock_rpc_service_, ManageHMICommand(notification_)) + .WillOnce(Return(true)); + + app_manager_impl_->ProcessServiceStatusUpdate(kConnectionKey, + GetParam().service_type_, + GetParam().service_event_, + GetParam().reason_); +} + TEST_F(ApplicationManagerImplTest, ProcessQueryApp_ExpectSuccess) { using namespace ns_smart_device_link::ns_smart_objects; SmartObject app_data; @@ -844,6 +945,7 @@ TEST_F(ApplicationManagerImplTest, std::shared_ptr nonswitching_app_ptr = std::make_shared(); + const std::string nonswitching_device_id = "nonswitching"; const std::string nonswitching_device_id_hash = encryption::MakeHash(nonswitching_device_id); diff --git a/src/components/application_manager/test/include/application_manager/mock_message_helper.h b/src/components/application_manager/test/include/application_manager/mock_message_helper.h index eec8d464a56..d78946efd35 100644 --- a/src/components/application_manager/test/include/application_manager/mock_message_helper.h +++ b/src/components/application_manager/test/include/application_manager/mock_message_helper.h @@ -354,8 +354,12 @@ class MockMessageHelper { const hmi_apis::Common_ServiceUpdateReason::eType service_update_reason)); - class MockServiceStatusUpdateNotificationBuilder { + class MockServiceStatusUpdateNotificationBuilder + : public MessageHelper::ServiceStatusUpdateNotificationBuilder { public: + MockServiceStatusUpdateNotificationBuilder( + const MockServiceStatusUpdateNotificationBuilder& obj){}; + MockServiceStatusUpdateNotificationBuilder(){}; MOCK_METHOD2(CreateBuilder, MessageHelper::ServiceStatusUpdateNotificationBuilder( hmi_apis::Common_ServiceType::eType, diff --git a/src/components/application_manager/test/message_helper/message_helper_test.cc b/src/components/application_manager/test/message_helper/message_helper_test.cc index 249d7231d7d..966548d7072 100644 --- a/src/components/application_manager/test/message_helper/message_helper_test.cc +++ b/src/components/application_manager/test/message_helper/message_helper_test.cc @@ -1113,6 +1113,92 @@ TEST_F(MessageHelperTest, ExtractWindowIdFromSmartObject_FromWrongType) { MessageHelper::ExtractWindowIdFromSmartObject(message)); } +TEST(ServiceStatusUpdateNotificationBuilderTest, CreateBuilderIsCorrect) { + auto service_status_update_builder_ = + ServiceStatusUpdateBuilder::CreateBuilder(ServiceType::AUDIO, + ServiceEvent::REQUEST_ACCEPTED); + auto notification_ = service_status_update_builder_.notification(); + + auto message_type_exist_ = + (*notification_)[strings::params].keyExists(strings::message_type); + auto message_type_ = + (*notification_)[strings::params][strings::message_type].asInt(); + auto function_id_exist_ = + (*notification_)[strings::params].keyExists(strings::function_id); + auto function_id_ = + (*notification_)[strings::params][strings::function_id].asInt(); + auto protocol_version_exist_ = + (*notification_)[strings::params].keyExists(strings::protocol_version); + auto protocol_version_ = + (*notification_)[strings::params][strings::protocol_version].asInt(); + auto protocol_type_exist_ = + (*notification_)[strings::params].keyExists(strings::protocol_type); + auto protocol_type_ = + (*notification_)[strings::params][strings::protocol_type].asInt(); + auto service_type_exist_ = (*notification_)[strings::msg_params].keyExists( + hmi_notification::service_type); + auto service_type_ = + (*notification_)[strings::msg_params][hmi_notification::service_type] + .asInt(); + auto service_event_exist_ = (*notification_)[strings::msg_params].keyExists( + hmi_notification::service_event); + auto service_event_ = + (*notification_)[strings::msg_params][hmi_notification::service_event] + .asInt(); + + EXPECT_TRUE(message_type_exist_); + EXPECT_EQ(static_cast(kNotification), message_type_); + EXPECT_TRUE(function_id_exist_); + EXPECT_EQ(static_cast( + hmi_apis::FunctionID::BasicCommunication_OnServiceUpdate), + function_id_); + EXPECT_TRUE(protocol_version_exist_); + EXPECT_EQ(static_cast(commands::CommandImpl::protocol_version_), + protocol_version_); + EXPECT_TRUE(protocol_type_exist_); + EXPECT_EQ(static_cast(commands::CommandImpl::hmi_protocol_type_), + protocol_type_); + EXPECT_TRUE(service_type_exist_); + EXPECT_EQ(static_cast(ServiceType::AUDIO), service_type_); + EXPECT_TRUE(service_event_exist_); + EXPECT_EQ(static_cast(ServiceEvent::REQUEST_ACCEPTED), + service_event_); +} + +TEST(ServiceStatusUpdateNotificationBuilderTest, AddAppID) { + auto service_status_update_builder_ = + ServiceStatusUpdateBuilder::CreateBuilder(ServiceType::RPC, + ServiceEvent::REQUEST_RECEIVED); + const uint32_t kAppId = 1234u; + + service_status_update_builder_.AddAppID(kAppId); + auto notification_ = service_status_update_builder_.notification(); + + auto app_id_exist_ = + (*notification_)[strings::msg_params].keyExists(strings::app_id); + auto app_id_ = (*notification_)[strings::msg_params][strings::app_id].asInt(); + + EXPECT_TRUE(app_id_exist_); + EXPECT_EQ(kAppId, app_id_); +} + +TEST(ServiceStatusUpdateNotificationBuilderTest, AddServiceUpdateReason) { + auto service_status_update_builder_ = + ServiceStatusUpdateBuilder::CreateBuilder(ServiceType::VIDEO, + ServiceEvent::REQUEST_REJECTED); + + service_status_update_builder_.AddServiceUpdateReason( + UpdateReason::INVALID_CERT); + auto notification_ = service_status_update_builder_.notification(); + auto reason_exist_ = + (*notification_)[strings::msg_params].keyExists(hmi_notification::reason); + auto reason_ = + (*notification_)[strings::msg_params][hmi_notification::reason].asInt(); + + EXPECT_TRUE(reason_exist_); + EXPECT_EQ(static_cast(UpdateReason::INVALID_CERT), reason_); +} + } // namespace application_manager_test } // namespace components } // namespace test diff --git a/src/components/protocol_handler/include/protocol_handler/service_status_update_handler_listener.h b/src/components/protocol_handler/include/protocol_handler/service_status_update_handler_listener.h index 6e1e4ee6c22..e784ae6eb68 100644 --- a/src/components/protocol_handler/include/protocol_handler/service_status_update_handler_listener.h +++ b/src/components/protocol_handler/include/protocol_handler/service_status_update_handler_listener.h @@ -42,7 +42,7 @@ namespace protocol_handler { /** * @brief Converts service type enum value from protocol_handler to hmi_apis. * @param service_type protocol_handler enum value. - **/ + */ hmi_apis::Common_ServiceType::eType GetHMIServiceType( protocol_handler::ServiceType service_type); @@ -50,7 +50,7 @@ hmi_apis::Common_ServiceType::eType GetHMIServiceType( * @brief ServiceStatusUpdateHandlerListener provides callbacks interface with * a purpose to notify HMI on successful or failed state updates of different * services - **/ + */ class ServiceStatusUpdateHandlerListener { public: /** @@ -63,7 +63,7 @@ class ServiceStatusUpdateHandlerListener { * service start. * @param service_update_reason enum value containing reason why service_event * occured. - **/ + */ virtual void ProcessServiceStatusUpdate( const uint32_t connection_key, hmi_apis::Common_ServiceType::eType service_type, diff --git a/src/components/protocol_handler/src/service_status_update_handler.cc b/src/components/protocol_handler/src/service_status_update_handler.cc index b0ffaee9b45..27eb6790993 100644 --- a/src/components/protocol_handler/src/service_status_update_handler.cc +++ b/src/components/protocol_handler/src/service_status_update_handler.cc @@ -3,6 +3,8 @@ namespace protocol_handler { +CREATE_LOGGERPTR_GLOBAL(logger_, "ServiceStatusUpdateHandler") + hmi_apis::Common_ServiceType::eType GetHMIServiceType( protocol_handler::ServiceType service_type) { using namespace hmi_apis; @@ -76,7 +78,12 @@ void ServiceStatusUpdateHandler::OnServiceUpdate( Common_ServiceEvent::REQUEST_REJECTED, update_reason); } - default: { return; } + default: { + LOG4CXX_WARN(logger_, + "Received unknown ServiceStatus: " + << static_cast(service_status)); + return; + } } } } // namespace protocol_handler diff --git a/src/components/protocol_handler/test/include/protocol_handler/mock_service_status_update_handler_listener.h b/src/components/protocol_handler/test/include/protocol_handler/mock_service_status_update_handler_listener.h new file mode 100644 index 00000000000..37485aa3ac4 --- /dev/null +++ b/src/components/protocol_handler/test/include/protocol_handler/mock_service_status_update_handler_listener.h @@ -0,0 +1,57 @@ +/* + * Copyright (c) 2019, Ford Motor Company + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following + * disclaimer in the documentation and/or other materials provided with the + * distribution. + * + * Neither the name of the Ford Motor Company nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef SRC_COMPONENTS_PROTOCOL_HANDLER_TEST_INCLUDE_MOCK_SERVICE_STATUS_UPDATE_HANDLER_LISTENER_H +#define SRC_COMPONENTS_PROTOCOL_HANDLER_TEST_INCLUDE_MOCK_SERVICE_STATUS_UPDATE_HANDLER_LISTENER_H + +#include "gmock/gmock.h" +#include "protocol_handler/service_status_update_handler_listener.h" + +namespace test { +namespace components { +namespace protocol_handler_test { + +class MockServiceStatusUpdateHandlerListener + : public protocol_handler::ServiceStatusUpdateHandlerListener { + public: + MOCK_METHOD4( + ProcessServiceStatusUpdate, + void(const uint32_t, + hmi_apis::Common_ServiceType::eType, + hmi_apis::Common_ServiceEvent::eType, + utils::Optional)); +}; +} // namespace protocol_handler_test +} // namespace components +} // namespace test + +#endif // SRC_COMPONENTS_PROTOCOL_HANDLER_TEST_INCLUDE_MOCK_SERVICE_STATUS_UPDATE_HANDLER_LISTENER_H diff --git a/src/components/protocol_handler/test/protocol_handler_tm_test.cc b/src/components/protocol_handler/test/protocol_handler_tm_test.cc index 692b1a7134c..600884bae16 100644 --- a/src/components/protocol_handler/test/protocol_handler_tm_test.cc +++ b/src/components/protocol_handler/test/protocol_handler_tm_test.cc @@ -39,6 +39,7 @@ #include "protocol_handler/mock_protocol_handler.h" #include "protocol_handler/mock_protocol_handler_settings.h" #include "protocol_handler/mock_protocol_observer.h" +#include "protocol_handler/mock_service_status_update_handler_listener.h" #include "protocol_handler/mock_session_observer.h" #include "protocol_handler/protocol_handler.h" #include "protocol_handler/protocol_handler_impl.h" @@ -108,6 +109,7 @@ using protocol_handler::PROTOCOL_VERSION_MAX; using protocol_handler::ProtocolHandlerImpl; using protocol_handler::RawMessage; using protocol_handler::RawMessagePtr; +using protocol_handler::ServiceStatusUpdateHandler; using protocol_handler::ServiceType; // For TM states using test::components::security_manager_test::MockSystemTimeHandler; @@ -139,6 +141,9 @@ using ::testing::SetArgPointee; using ::testing::SetArgReferee; typedef std::vector UCharDataVector; +typedef std::shared_ptr< + testing::NiceMock > + MockServiceStatusUpdateHandlerListenerPtr; // custom action to call a member function with 6 arguments ACTION_P4(InvokeMemberFuncWithArg2, ptr, memberFunc, a, b) { @@ -186,10 +191,17 @@ class ProtocolHandlerImplTest : public ::testing::Test { session_observer_mock, connection_handler_mock, transport_manager_mock)); + std::unique_ptr service_status_update_handler_( + new ServiceStatusUpdateHandler( + &(*mock_service_status_update_handler_listener_))); + protocol_handler_impl->set_service_status_update_handler( + std::move(service_status_update_handler_)); tm_listener = protocol_handler_impl.get(); } void SetUp() OVERRIDE { + mock_service_status_update_handler_listener_ = std::make_shared< + testing::NiceMock >(); InitProtocolHandlerImpl(0u, 0u); connection_id = 0xAu; session_id = 0xFFu; @@ -390,6 +402,8 @@ class ProtocolHandlerImplTest : public ::testing::Test { testing::NiceMock protocol_handler_settings_mock; std::shared_ptr protocol_handler_impl; + MockServiceStatusUpdateHandlerListenerPtr + mock_service_status_update_handler_listener_; TransportManagerListener* tm_listener; // Uniq connection ::transport_manager::ConnectionUID connection_id; @@ -737,7 +751,7 @@ TEST_F(ProtocolHandlerImplTest, AddSecurityManager(); EXPECT_CALL(session_observer_mock, KeyFromPair(connection_id2, session_id2)) - .WillOnce(Return(connection_key)); + .WillRepeatedly(Return(connection_key)); EXPECT_CALL(session_observer_mock, GetSSLContext(connection_key, start_service)) diff --git a/src/components/protocol_handler/test/service_status_update_handler_test.cc b/src/components/protocol_handler/test/service_status_update_handler_test.cc new file mode 100644 index 00000000000..fa64ffbb3b7 --- /dev/null +++ b/src/components/protocol_handler/test/service_status_update_handler_test.cc @@ -0,0 +1,196 @@ +/* + * Copyright (c) 2019, Ford Motor Company + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following + * disclaimer in the documentation and/or other materials provided with the + * distribution. + * + * Neither the name of the Ford Motor Company nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#include "protocol_handler/service_status_update_handler.h" +#include "gtest/gtest.h" +#include "protocol_handler/mock_service_status_update_handler_listener.h" + +namespace test { +namespace components { +namespace protocol_handler_test { + +namespace { +const uint32_t kConnectioKey = 123u; +} + +using namespace protocol_handler; +using ::testing::_; +using ::testing::Return; +using namespace hmi_apis; +typedef utils::Optional UpdateReasonOptional; +typedef std::shared_ptr + ServiceStatusUpdateHandlerPtr; +typedef std::shared_ptr + MockServiceStatusUpdateHandlerListenerPtr; + +struct ServiceUpdate { + ServiceType service_type_; + ServiceStatus service_status_; + ServiceUpdate(ServiceType type, ServiceStatus status) + : service_type_(type), service_status_(status) {} +}; + +class ServiceStatusUpdateHandlerTest + : public ::testing::TestWithParam { + public: + ServiceStatusUpdateHandlerTest() { + mock_service_status_update_handler_listener_.reset( + new MockServiceStatusUpdateHandlerListener); + service_status_update_handler_ = + std::make_shared( + &(*mock_service_status_update_handler_listener_)); + } + + Common_ServiceEvent::eType GetServiceEvent(ServiceStatus status) { + switch (status) { + case ServiceStatus::SERVICE_ACCEPTED: { + return Common_ServiceEvent::REQUEST_ACCEPTED; + } + case ServiceStatus::SERVICE_RECEIVED: { + return Common_ServiceEvent::REQUEST_RECEIVED; + } + case ServiceStatus::SERVICE_START_FAILED: + case ServiceStatus::PTU_FAILED: + case ServiceStatus::CERT_INVALID: + case ServiceStatus::INVALID_TIME: { + return Common_ServiceEvent::REQUEST_REJECTED; + } + default: { return Common_ServiceEvent::INVALID_ENUM; } + } + } + + UpdateReasonOptional GetUpdateReason(ServiceStatus status) { + switch (status) { + case ServiceStatus::SERVICE_START_FAILED: + case ServiceStatus::SERVICE_ACCEPTED: + case ServiceStatus::SERVICE_RECEIVED: { + return UpdateReasonOptional::EMPTY; + } + case ServiceStatus::PTU_FAILED: { + auto reason = Common_ServiceUpdateReason::PTU_FAILED; + return reason; + } + case ServiceStatus::CERT_INVALID: { + auto reason = Common_ServiceUpdateReason::INVALID_CERT; + return reason; + } + case ServiceStatus::INVALID_TIME: { + auto reason = Common_ServiceUpdateReason::INVALID_TIME; + return reason; + } + default: { + auto reason = Common_ServiceUpdateReason::INVALID_ENUM; + return reason; + } + } + } + + public: + MockServiceStatusUpdateHandlerListenerPtr + mock_service_status_update_handler_listener_; + ServiceStatusUpdateHandlerPtr service_status_update_handler_; +}; + +INSTANTIATE_TEST_CASE_P( + OnServiceUpdate_SERVICE_ACCEPTED, + ServiceStatusUpdateHandlerTest, + ::testing::Values( + ServiceUpdate(ServiceType::kAudio, ServiceStatus::SERVICE_ACCEPTED), + ServiceUpdate(ServiceType::kMobileNav, ServiceStatus::SERVICE_ACCEPTED), + ServiceUpdate(ServiceType::kRpc, ServiceStatus::SERVICE_ACCEPTED))); + +INSTANTIATE_TEST_CASE_P( + OnServiceUpdate_SERVICE_RECEIVED, + ServiceStatusUpdateHandlerTest, + ::testing::Values( + ServiceUpdate(ServiceType::kAudio, ServiceStatus::SERVICE_RECEIVED), + ServiceUpdate(ServiceType::kMobileNav, ServiceStatus::SERVICE_RECEIVED), + ServiceUpdate(ServiceType::kRpc, ServiceStatus::SERVICE_RECEIVED))); + +INSTANTIATE_TEST_CASE_P( + OnServiceUpdate_SERVICE_START_FAILED, + ServiceStatusUpdateHandlerTest, + ::testing::Values( + ServiceUpdate(ServiceType::kAudio, ServiceStatus::SERVICE_START_FAILED), + ServiceUpdate(ServiceType::kMobileNav, + ServiceStatus::SERVICE_START_FAILED), + ServiceUpdate(ServiceType::kRpc, ServiceStatus::SERVICE_START_FAILED))); + +INSTANTIATE_TEST_CASE_P( + OnServiceUpdate_CERT_INVALID, + ServiceStatusUpdateHandlerTest, + ::testing::Values( + ServiceUpdate(ServiceType::kAudio, ServiceStatus::CERT_INVALID), + ServiceUpdate(ServiceType::kMobileNav, ServiceStatus::CERT_INVALID), + ServiceUpdate(ServiceType::kRpc, ServiceStatus::CERT_INVALID))); + +INSTANTIATE_TEST_CASE_P( + OnServiceUpdate_INVALID_TIME, + ServiceStatusUpdateHandlerTest, + ::testing::Values( + ServiceUpdate(ServiceType::kAudio, ServiceStatus::INVALID_TIME), + ServiceUpdate(ServiceType::kMobileNav, ServiceStatus::INVALID_TIME), + ServiceUpdate(ServiceType::kRpc, ServiceStatus::INVALID_TIME))); + +INSTANTIATE_TEST_CASE_P( + OnServiceUpdate_PTU_FAILED, + ServiceStatusUpdateHandlerTest, + ::testing::Values( + ServiceUpdate(ServiceType::kAudio, ServiceStatus::PTU_FAILED), + ServiceUpdate(ServiceType::kMobileNav, ServiceStatus::PTU_FAILED), + ServiceUpdate(ServiceType::kRpc, ServiceStatus::PTU_FAILED))); + +TEST_P(ServiceStatusUpdateHandlerTest, OnServiceUpdate) { + auto service_event_ = GetServiceEvent(GetParam().service_status_); + auto reason_ = GetUpdateReason(GetParam().service_status_); + + EXPECT_CALL( + *mock_service_status_update_handler_listener_, + ProcessServiceStatusUpdate(kConnectioKey, _, service_event_, reason_)) + .Times(1); + + service_status_update_handler_->OnServiceUpdate( + kConnectioKey, GetParam().service_type_, GetParam().service_status_); +} + +TEST_F(ServiceStatusUpdateHandlerTest, GetHMIServiceType) { + EXPECT_EQ(Common_ServiceType::RPC, GetHMIServiceType(ServiceType::kRpc)); + EXPECT_EQ(Common_ServiceType::AUDIO, GetHMIServiceType(ServiceType::kAudio)); + EXPECT_EQ(Common_ServiceType::VIDEO, + GetHMIServiceType(ServiceType::kMobileNav)); + EXPECT_EQ(Common_ServiceType::INVALID_ENUM, + GetHMIServiceType(ServiceType::kInvalidServiceType)); +} + +} // namespace protocol_handler_test +} // namespace components +} // namespace test From f52a562c71690dab5d2853e44459b89b60f2c08a Mon Sep 17 00:00:00 2001 From: sniukalov Date: Thu, 30 May 2019 09:45:30 +0300 Subject: [PATCH 04/19] Added ServiceStatusUpdateDocumentation --- Doxyfile | 3 +- .../docs/SDL.SDD.ServiceStatusUpdate.dox | 116 ++++++++++++++++++ .../assets/PTU_for_EXTERNAL_PROPRIETARY.png | Bin 0 -> 92488 bytes .../assets/ServiceStatusUpdate_classes.png | Bin 0 -> 429855 bytes .../assets/ServiceStatusUpdate_sequence.png | Bin 0 -> 79236 bytes .../docs/assets/invalid_cert.png | Bin 0 -> 57118 bytes .../docs/assets/invalid_time.png | Bin 0 -> 52580 bytes .../docs/assets/ptu_failed.png | Bin 0 -> 34454 bytes 8 files changed, 118 insertions(+), 1 deletion(-) create mode 100644 src/components/protocol_handler/docs/SDL.SDD.ServiceStatusUpdate.dox create mode 100644 src/components/protocol_handler/docs/assets/PTU_for_EXTERNAL_PROPRIETARY.png create mode 100644 src/components/protocol_handler/docs/assets/ServiceStatusUpdate_classes.png create mode 100644 src/components/protocol_handler/docs/assets/ServiceStatusUpdate_sequence.png create mode 100644 src/components/protocol_handler/docs/assets/invalid_cert.png create mode 100644 src/components/protocol_handler/docs/assets/invalid_time.png create mode 100644 src/components/protocol_handler/docs/assets/ptu_failed.png diff --git a/Doxyfile b/Doxyfile index 36155e37a7a..8674bd31144 100644 --- a/Doxyfile +++ b/Doxyfile @@ -899,7 +899,8 @@ EXAMPLE_RECURSIVE = NO # \image command). IMAGE_PATH = \ - src/components/security_manager/docs/assets + src/components/security_manager/docs/assets \ + src/components/protocol_handler/docs/assets # The INPUT_FILTER tag can be used to specify a program that doxygen should # invoke to filter for each input file. Doxygen will invoke the filter program diff --git a/src/components/protocol_handler/docs/SDL.SDD.ServiceStatusUpdate.dox b/src/components/protocol_handler/docs/SDL.SDD.ServiceStatusUpdate.dox new file mode 100644 index 00000000000..dea9ae5d0b6 --- /dev/null +++ b/src/components/protocol_handler/docs/SDL.SDD.ServiceStatusUpdate.dox @@ -0,0 +1,116 @@ +/** +\page service_status_update Service Status Update Detailed Design +## Table of contents +- \subpage service_status_update_intoduction + + \ref service_status_update_rationale "1.1 Rationale" + + \ref service_status_update_scope "1.2 Scope" +- \subpage service_status_update_detail_design + + \ref service_status_update_design_solutions "2.1 Design solutions" + + \ref service_status_update_class_structure "2.2 Class Structure" + + \ref service_status_update_sequence_diagram "2.3 Sequence diagram" +- \subpage service_status_update_data_structures + + \ref service_status_update_data_structure "3.1 Data structures" +- \subpage service_status_update_references_and_history + + \ref service_status_update_history "4.1 References" +*/ +//----------------------------------------------------------- +/** +\page service_status_update_intoduction 1 Introduction +The document is intended to support software developers, +maintenance and integration engineers with sufficient, +detailed information concerning the design, development and +deployment concepts, to accomplish their respective tasks without reliance on the authors. + +\anchor service_status_update_rationale +## 1.1 Rationale +ServiceStatusUpdateHandler and ServiceStatusUpdateHandlerListener classes are +implemented to provide adequate levels of abstraction when passing data between ProtocolHandler, +SecurityManager, ApplicationManager and PolicyHandler + +\anchor service_status_update_scope +## 1.2 Scope +ServiceStatusUpdateHandler is a part of protocol_handler namespace + +*/ +//----------------------------------------------------------- +/** +\page service_status_update_detail_design 2 Component detail design +\anchor service_status_update_design_solutions +### 2.1 Design solutions +The following design approaches and patterns was used for ServiceStatusUpdateHandler: +- Introducing extra layer to process data relevant only for ProtocolHandler or ApplicationManager + + ServiceStatusUpdateHandler converts ServiceStatus value relevant only for ProtocolHandler to + HMI API values relevant only for ApplicationManager +- [Builder design pattern](https://sourcemaking.com/design_patterns/builder) + used for construction of OnServiceUpdate notification object +- [Observer design pattern] + used for notifying ApplicationManager of service update occured + + +#### Design description +protocol_handler::ServiceStatusUpdateHandler is an entity to establish data transfer between +ProtocolHandler and ApplicationManager about occuring service updates +protocol_handler::ServiceStatusUpdateHandlerListener is an interface used +to provide adequate level of abstraction between broadcasting and listening entity +MessageHelper::ServiceStatusUpdateNotificationBuilder is an entity used +for flexible construction of OnServiceUpdate notification object + +\anchor service_status_update_class_structure +### 2.2 Class Structure +The following UML class diagram shows the component structure. +![Service Status Update class diagram](ServiceStatusUpdate_classes.png) +For more information about class diagram follow: +- http://www.uml-diagrams.org/class-diagrams-overview.htqml +- https://sourcemaking.com/uml/modeling-it-systems/structural-view/class-diagram + +\anchor service_status_update_sequence_diagram +### 2.3 Sequence diagram +The following UML sequence diagram shows the component dynamic behavior. +For more information about sequence diagram follow: +- http://www.uml-diagrams.org/sequence-diagrams.html +- https://sourcemaking.com/uml/modeling-it-systems/external-view/use-case-sequence-diagram + +Service Status Update basic flow: +![Basic flow](ServiceStatusUpdate_sequence.png) + +Service Status Update invalid certificate: +![Invalid Cert](invalid_cert.png) + +Service Status Update PTU failed: +![PTU Failed](ptu_failed.png) + +Service Status Update PTU failed (EXTERNAL_PROPRIETARY): +![PTU Failed EXTERNAL_PROPRIETARY](PTU_for_EXTERNAL_PROPRIETARY.png) + +Service Status Update GetSystemTime failed: +![GetSystemTime failed](invalid_time.png) +*/ + +//----------------------------------------------------------- +/** +\page service_status_update_data_structures 3 Component data and resources +\anchor service_status_update_data_structure +### 3.1 Element Data Structure +The following data types are used by the ServiceStatusUpdateHandler: + - protocol_handler::ServiceStatus + +//----------------------------------------------------------- +/** +\page service_status_update_references_and_history 4 References and history +\anchor service_status_update_history +### 4.1 Document history +Document change history + +| Version | Date | Author/Editor | Change description | +|-------------|------------|----------------------------------------|---------------------| +| 0.1 | 02/21/2019 | [MKed](https://github.com/mked-luxoft) | Initial version from the previous [SDL SDD](https://adc.luxoft.com/confluence/pages/viewpage.action?pageId=279677125) | + +Document approve history + +| Version | Date | Author/Editor | Change description | +|-------------|------------|-----------------------------|---------------------| +| | | | | + +For more precise document change history follow github history - +- https://github.com/smartdevicelink/sdl_core/commits/develop/src/components/protocol_handler/docs/SDL.SDD.ServiceStatusUpdate.dox +*/ \ No newline at end of file diff --git a/src/components/protocol_handler/docs/assets/PTU_for_EXTERNAL_PROPRIETARY.png b/src/components/protocol_handler/docs/assets/PTU_for_EXTERNAL_PROPRIETARY.png new file mode 100644 index 0000000000000000000000000000000000000000..19173570aa873497d88709b9a9a38aec6d18df48 GIT binary patch literal 92488 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

y3qe0023 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

xX!bsIaIHBgjziQdBgTWpo8E(#A|#@Z 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 z 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�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ɞUc|vhgV60+{=f`T!>_=WPEtW> zci-Syw`d2x9e($j`^R-~s+$LTzvOAe^$n$y{P_7qOTsA60gaJWklRmdNAkpn?8qUFUM$2jWD&<9}5km(n#26ZgFfm%&ip<)F&3iE4uX@eccDRKM&yXZ0;W6{$Hb#N7meR`nMZg+Z4mzz#wJZ<|4&q+ zsnzF9!kpV4HWUU<6_zaxxAdf_Y@^|b(>=URkxs-4+O9kv!q{Dnv4ulldN{t-B7N0L z-CC-z>wwdz`LKpWc0!`lF9v+-QB|m^jzcyM((fB~`Qt?S{X9!Qk0&l$&Q@7b%s;oq zYU|=-{{$yag$1Jq`r{37msS&< z@X5YZF3Jec8E#B~#`3MX0OM#OGclzxQ)7{}8wF{ah8r$MEyT>;MoKx4{?hu$d;pOX z*6Mts?Ll2(lA8p=uFqORn;ZOH`CSxtlAHXHIE)y!W>!z2$i7;b)s{0eWA*BH_(sp3 zkHG^pGt0o7+&PMpRfklGN0m-Rn{3c=V!+OBHCN2qMr&?VPgqDsW2dyRtFX_rP*q8o z&8B|5us~hn$?(Yh2-eG#(2!UTx`eEh7Q`MDd<`l_TV;YZ$@LerLOlq$2wiyv<2PS8 zp()l55;JXR+B=!fQFB9HEL*|a`YhmCcZpt&hNa%oJWP8AbrYme!T-cPb1-?l%D5~;ot-O{(g%$Jz0+7ww&5q3Pv?B zjssNqz;2bnQX8crqed_qSV9f;i>O*QTgLYvG+Pv5VK*}mRf$*QE*Gu89IA>*vYUFa z9|+SaR_KP4`@kd=Z!o{^*kt>=;=l33pod#*C&0RmSE4$yH8-gGIG#AMjf6(V8pJ9h z_|lzEqOe|QAMa7$rm*8g()|c`XBn`hs4=tyBrt(y!^}Czl@+o)f`b zSsl~$bxzx0fX5~!RGOE2Xp|*rla4#NLQFxaP(Vv6G{|Y}!pn_URG==; ze3}P+^!JonHJ^C~NKsOnhX=4wOu{{9Z7oS|L0h(n;uO8wDD}!K0Sa<3;iM=RN3@)&FMU?fcCyuF+vQ{MRrJs?=B^&jXxemT8J)ZE8i5EK26T1 z{+@N9uiaZMh{@(rfcR~kqL;2o+Fz|C=3;iIjfPn_=Ht3@4ke`} zHlFz~JJt0Z~Bt!iDHaq$2}%7NlaPnwj)=r9FtE*P7< zPl53705xP*&Wd026*EOR2(nE_VWXJquoAPfch0DZQ$@RK?oAj*P8t@bTv0_4;}gz# z!mk&YP>?+$8IWC52Jx4uOKu&vN=vkf?A<5k;(~bf=sr~ zD#z=wLPf@WlMdg<6AHFw&PCZO1nh|Uef5f_wEcjWB4$Xe$xa+}NGOm@E`4eAQ-C0g zf6AaQ3;4TwJ&B5@&?5@Z`FC+wg^K!SA8}wlOM?MlWJD&Qua62IJb^$qAO0vhLp92? zl52kcRz^S%?iJ*Bo`3hXY)tr-oqr4IgKsCRJq19k%sc}IyR&u475#>;}4JCk^gOprpAi3%^j!>Mo(uIev^<_4)Fdd zfeRV`lB~*6HlY zQ+v_Zy_$;m*}J;!9FvJaZno(^+3tFa3q}><6#1~p_?;dhGtX^{Xi6!T+bolvK9pZ~ zqEI|LIFJQ2TCFWV#^o}jl%h+N1Sl&z21{%Kum@sTmGY+MMNLVl73;3vJyx8^UMqR0 zU1%j4BpO8eYM_WW#NF_k3h!-nqAg+ez8!QB|&71$T$wOff_3mJ3H6x4r-YCT=`Dg{6L z*BHE{<|_X&5o4O>NET@$$FNL=t>8->qqLvYd&V?ODurkfA>htdUr7>S8yj{a^-o-+ z(mh3yuk02ZEZtE4c!s-k>M8xHW}4=ujg`LgUo8#71P8O%E=kOlZx@w#siU!+Oou3~ z8eFn#kV)i6DJH8a`~j-Z2Q?P_$cg(X5rRK&*=B?P7rg(4U$$w+eZ=4Y+*21=1 z))Qm8X+u;#8{100wW$14WXm)Ya2Phe_&^a7i(Q#(c7YJVFzELkWdGSj=+eD}?)Y-> zqS(Gpk@KetBAUcGE%(=)r0xYbd7Y|ar(6R~rNIT_4X3uNj`uG#lqwqnjGQ_Ld#-%XBWzoKhWjMTIzS|+zrPEzYC!+b?E^1 z!w34_i6dE|rn*Ye!cr7HqkO$-ddrzVWLTP%x(vzZAGNEL2wH`YJ&Tq+*uMX>L-4_7 zOI1=@(H_(sy)8a(kH`gq_ksz=WR2EDPCg@b>)|;!w+*#2m zW^VkQL8}4&!jVfc2#x$s$O10Gq&r73=I%a*(g?V> z25p}K=0W9!E_j#IQpF!c67HsmQZV|&J|?=?Zz2{SU0=>j-`0VYXW1g7sK;dMW6sR2 zq9uz=0h5graHXY0cgh7*-0dj>{nz|&S0sgHu;1Jlvc72kJpF#5R#y2cir_PLf38wiyajPrZ*MS7aFigdUEVK5GpDodrgxM794csd8~ zW}SIbjm1kw4Q2kl*Go4XygJI%G-WM;Q6FiX#RH4v6Xc*+l3Yh`TB-uy?Qs2Y0+Og~ zG+74JNr#Aff1m$i6k<$u)8$D@tKm`{`$ConYFLBD%zlv~N5b|O+M4-QPT*$P@{BQ5 z&XN?pm6lNNrd zCQ)W;K(}#;35+2g64_>nY>iCfkdO#M<6%pE?gSm9FdoVek}kEuE`QsozQ+=#Dfu^$ zO9{h=bQGh5U!p>#K5qmX+L4zXVS*c}mDi6L2~9C~eDy@ii>4 z9_ns$@4{#2b;~Dw9KD0C9c7uny0lNb1mo2F)b*ZilOP!+iRxCXqG|Drd(?ynG11VY zp7$}k-E)^ZpEOg8I`mU0I6faPH2HI@@X2BfzQVsrxV(}CyW6AC1s`Q^d~?j9iZhN& z0^Ja4R+GQ1c=xUzN8SWt*x+(M;}+*X3ok!a011Ui}#o%K2DvSG{vCvd>7Hw zk$X}6{wi{7Jm?q^t+yuPic@3_j<3sAHPa>j_O(GQ#RbDoHqhldfE3F+N6U zH9Po)M;M{m=(m1wABMyZ=70MhjBd^!EO>zSK+`dD{KeY}cW*ZS#&n6S zk|)2?nTLx|28h4!9-*vy2&OAE7f)t0dfEQ7YCaCySx3YwKe?n)sN-q)xTp7&SM*9> z4Gn8Ul)lPu67a+EF(*5!!Fm!CEYvYXD!UF7YYR8L8No5QM7)>BVlP@tY9Gbp?7Hzo zX%e=@(=gd0DiLB^r3PF&(jU;}e?j21IhTAK@g%6Zt7|rH+xKIwX!o3 zV_shF<2kJoQmjys0yE6A#SVnxjN(Pae)PC(fSh6`cm+x{;Va~6^yO~Vu8FBU9p|Y^ z6)Zd$e{NNAH_{RKw0-`O5)^iPT>X#k?c70(Cj^9z#Z`%yA!%UoUG|YfFWEw|YXc87 zPHX<|PX?yawkR^B+l@l>;e96`P}(ZPOGzj3pNX=>V-7*Pcr~Rbz(Oqk1iSC`t9hyM z4?n5rr^7d&%7t|9$4HI8R(fgqZV%p-D$yqtGml5<0;`y@_-Zea`=Jseqrb|4B_^QG zT%2Aec!CA2#W$mEi!PYF+(VlVFYxCZ0{9`-7#S{qh}LTZX5cAcexO z7G;wPG8wKCL#T$`ah?r=wDAX!hc8Pa4F}L*y5BtETmsu;oKCQtPr!&z8aAkH7YMjK z;T|Gu;GDLt5>d8bru~2)jNpH1NU*z&ZEa+-3q2(Y-G~ty1RbI#zoZM3_fDv(fmjSG zA_QJk?+df74fm=$K%{Q8qcMq;2+{^dy*EJLFnaxr{~1KKMG}GZA4xBF*?IY=0KGkzu0a|IUHtH?dxk2OB1RezxhHw z@qPn(w{BXzzn5~Lh}e55zL~`llFV0um&vtuVqXI42T2|=5)B0x6;V;4$HA(oidXHvm<4^hC2gU4cENtrQM`S~jdqplLR ze22HE9f}@;Q2ivGVq?8XlJ&czk)m9YLCz=u<2HU}eTEVQprOq zP48sW?{-9w<1!P=z25!XN?-8)Cza>%rN^iHBa%P)AMPd|7@JCZq!#0?NW~s3MS#w1(tJR;yJJ?Yk($Ll}i> zd13lz;#YfOG>HGqa@c7XXbJjCsc5}@RLu~(saK;cY;$8PEidq`uu>4mwa;eneFbh~O#&^O8Ru&p7&7y2$iPf6I z#wUky_wWdxJH$%_>N}V3u{Ha z5)FdTN6WWF#=pToio;^Ew09k^(dV-V+wJ&N;(VnZV0@?Z1m`$(GlkWQMy?kI>Kx9@rbd zt#A^PQ5OH}@gF}4^Fl9Ee9?BuFJiHmSF#~J^$1pC`C=7Hw1&vYJv<^x=vL8h?UJ30 z3u1~%+Sp2hicJ>a`1xz&LzKF3zJ5!`yoi#(_7*MvdQ;M*D28n4Tqo!hg%lXHnEq@1 z3mbN|EX;1t!sA_4yCgt?5Ma`pyK>ZK?aN0{3DBN!la%j;6=t2&hsN4uE_O8Dp+U-{ zx+?ZPKT<#zJd~d^y5aTqaUZVVIxBKpd&z7PJ6@1ipB~iHzb%_1Z&X9t<3+82C{IZ& zlgEPaNmeADbiHed-C4W;K>qRWDb)wIoe?WK2+1+Qb!KM}M${^9l0h&>0PFN6;~NrN z#fM(SM^far>R)?5NPS_i+f916I&vqL`2rL%`j%S=~ zpxp6zAJJ$Dm)O0c^17Epif6}SM9xFYrmjj6+9>!9A)e9Er5^Xzg{Sq}j9pPk?W4`O zqDreqm;$<$<}VbTh5G;z1~5@?~(sW1H||tDcvApeO_zY3V)|_QXBi z9O2H*lm|I?cptael^g{jR9|nsirjWEDw=GiN_0>>>%jI58smla7W++?56`C;&pJr| zj`}0;aFXiFE)Op3;P(eV;%W0Rggn_Jrh39u*DkB6 z0M9aua{LrR`8Z0^@>8t>K@-8D(f~K!j`yw7B0T5u;*uR}XLsmZce&SR7hb7mU!5){ zW5Paps^ZG`Mhi?XJl8&Ab_)Daf-{cWtX8qYTylBj-ZoF$jiM#86h24klEb_9{TdYd z-#oiQFitGEb{E!rJ?v5pr)1O>bBrS>D!z|P&Jy$Y+eV{85kDi7m?n5;;3R&^FWN6+ zu_3*MHmGvdJx0CNU?u*y`A-}*)=rIUsYbO+J?-iQDY2vN+a>-$C(0)~q^d&4$C zi=i(*-Wo(+1#A1U@XIgIe|-;dOLu>=lov`K9G&hj)Wq-%pnqLtgriGxo5(yqjK#GS z!{$(9YaB_HXxoMEjR5J6+#-fz5A-EfFbA8Jmm$x}%O4>e{tjQR?%U`&4b~0kJBk!R zW0+jLJ@6F@QMn~ANh0ig+Kl4NG7pZ6r`6qwEOhCKnqGZX&s zB)EGECUG#DEkZpH+Of--c*6CJq7!2@RG9nyO_+1jIJf;#%P!u^w7v_apDMub-7nUy zcBQh~%G*j=u#{C>OriSNc&yXw@|;#Z+jTNx^B0=|}jx$+)*RJ&^(V|g!H&UG(KE4m_WTD^J z>#_D)`s5?oVoeWc_x+O_{25HQr1)a5=f>Qr^r`eAOGXPzjBbj&`ycCmac_E@d;@?C z2FRCf2Asdnkn1!l@^J1IREMC{QBi7JTYFdpCZ5_k)cLo1dtX8y^f$QpCFmB%y0|qe zsL{g3)Uh>C%h5Jy6)$cna0y%E2bMsATab|%eq!_mo2<%GzxxzUC$~m9o%O`mVk2ad zMCEb#0eOzzuL~r_xJDienEUBSYUEk(bcc_EVJtM}Ew(;Qu}H%Y(qMGakR6mwI0jlI zc*BLBpu7qBHxCw!;5nDAw`hQ){;T<391UDFDNcwkBbY4xnCR`tohX)f&cA|WUT^;S zmN~uC+5hg-<635#cy1lv=9?`=Nv?fi#zbGNxW^E3#d+W3fn{$Q?G4wx$2lb|u^SV7 zxY^kEZt9npk$4Y9xI91c)r|>aB6wWuWq03R%gyS`t`?^9wPtd%79L;vc3aUdYm)3} z*XYMY`A+i{+aMhC-my#Vk(6961$<2Oo?KQdkLuK$#u0Hu)}r}8cSmwZNrt?)a-xNx zSx!^ir>P74{}}K{*wN$c-SP3~&J!+oWc`K$cOpp7Dq8SO>GL+m#=Uj8~V3$ceYQT%+O5Lf`)u z&{QV`AEHR+{_3gD{s4IVLSW$J6&t5Y4VDUuI`m?pH_e&nO zD;wFve0X%+t3A<`$oKBv?E^ReSTDKEEus1`ZRUm%ZbRNL>lhAba1;W3XgwmJ4tbu# zi_?U12)@Xd=F6|i`c|hyLCc4m|00y&{wKU+&6pw7D=9C^U(*(Kvl=3d%N&M$KD>3@ zGWO<)>*jEgP8#|dP;iKd&1H$7)=crK@`XFsGn^{cqC4(QbcXkV^7x3joGMez^;xD;Hk%gvK$$@-9qZJaSynpk z8%}u`@hNtF;7E9Cys~w z=RR3$$z~c;sAqcQ8A-5ZJI^B4c0g zGm!dJgvker}#H{~emd{8s7*h5PBFZWU#STtj>Fyg6eFaU#Cj3?7MCk<&hOwNs9Rns|B&?tIGH`+i%!et?>C{ropc!LzJ( zQ{u_)^&d-sfQRJT5BO;7{Ime};p)2@yqvYYIQw>Mi@&t{EodaR@|A0|F;36)i#9f| zS*xdZpdUn6c4%6`Ua5X&SlsbAe{*1N#W#D>jzeXJnrAg zjC1Np2ZCmw%{p@JBS!4eH|h8iO|oM3mx&l#iBhMC)GPUA=zu$;VwnSWecc@uU;L&< ziQ5|Mihvadlj_-YDJ{L+jM<1^#Odcq4LO)-yyqSE<;^RTL^@}P3hy7zH*wpAca zl*SbfIpp+&?F?^50XER|NrQ{A%TSfUv`853TXXS4lxk5)9IdHlDmecS!UnU4q4@N~ z!jfI7HfR19l~&>T;Z6vF<_s7-_bzM_u`FjJq;xEd z_?V;`pXGohqco{}MYI*m!yDp)M(NOmX-c3^v`I&sv`WODSe|_HSHe0KZ@Hi&Q}H~m zk*2pP&T@kF0vxJ_qQ~n8EL(iMQ4ynBB_QzBL~pN9y}|%_cVkj-5wBkL*0;s3`aGjygN+C zo~>xJGYSHPlG5$ZJXaPCGe<=ZQc)T#J;#a*&WK1{i3i^CY(za!`raTW!HCR%05$E; z`PM=B_*FRoliJK>%T^f}8%PgLS$1Vrv1TJNR&z&klc(b*l?%+R3nM@HHzfh$*G7|K zFMS>=6V>Q{m^1*6A`0&SX;uhM(8qo&gF1u|kxaP{?SENh!}IJ=g>T5h*D}^9?gvZj zHf~Ui1Zp_Dv&EGZ4o4#L(NCIl6ssjJKR_X?KJ0WW<^5p9RMw;RUQuW=GTg;K7Ihy60q!qb9a7*2k`ld!KLmT_`1GVFftUQiwivt$6ycV@;M`nWe`dj@(5Z z>cpQ~ButYK_LO;or)4`$ykko*xnmUpg;y`aH5(~OA91ya(e+YLV5P?nCOK1X(DiuN zbNpUsN3a(5YsTfYtw1l`z?#`h@+mkA2k6m0g7HjXtmx7Uj2T)kC^+=><2r4*dP0$5 zN~y zT3_55fx(sCt6D5U2GBVJA!y^P@dk;epG~KqYb5!_Az~07oEG$wpFJO+fXZ=h$;T7C zr0ohW&S)R4B!P7t)ofd`N8O#5?B2z@RQMQ44emVxNzeF)iX+QYn- zM-TS4-nsrDR~ILfuv|~F!ESt4%Js5ZAg6d(iIjaU8@r!c4wpbE*~}wWR5c_#VtLzn@6Mx|W#F@~RG0Lea)le1TvPSO<=9@(9e} zsaG^V1%loZJxO)n@+9aEg2j;bj&I(n7Jd&XDmL;RqlSMv$b`I|>Vd@%?&(LR?_-cy zJR;jb>8oZ&4MQ&ljOlkT!C8ipAIWf2Ll54xX2xO!_W0j*@omS z8bg^Ghp?s#M8GqbKTjzySaE3KDI7grw>h|V9P|li<<5% z&OzJNPwm^ou(+8`_$fRDRaf`~q)wPFW)rxACujp3?i;*Oek5;L0bDXx)TTe6o)V0% z?63ZCaWc{aCvTfQMTK_hKOQ~_E@b=RbngWi5-y)|<$E?PM%f_s@`BB+50#SyQf{2& z5i(9zCSd`z_h3W2=8ej$ik?tCr89GElkWvJsyM~mmVL+rC zM7kuTyOEae?rzX`e*f!wzZ1jr9M0K$?R%~BhIsmgzeHT!Yd-Uy=-R@aR`t@H);s88 z!+%d&BdFRB5Sa~qr?K_N@Fb7f^cVcADodHZjhl)r;TsmRcNM6ELV)6M_V%(p!IhLm zii4^PhPA#%TV`ih$<3jw_d7t$kOZi1q~`|op(gneN}$TDZO*d13KtyRgxW=gbdF9C zcUF+7G@#u?RQi0MgMkV^BA-|al9FpEN~Ss4p7X`4AHTaoPUo9LsoRTJ;2%X~(Y)D* z^{xZfW6vyY#xJyl#aV zPXm2KDUwc^Jfkw`-f3;gtr(=-L*Wz$t)dA_Fga2B=QWeK9Dc zLOuVrz~};zGq8XB_R{ zuDOS*?}62Wu1x4mY^NT#uSk=t3=2VFOzAW1rQKg;g1i5IOsN;uQHnA3!3Eg3(Zk0o z@1Q#jp)I)TT}j>rTKE9vrZq0*eRz2m8UpW6#B0(5HLzif^*0BLj_07LHtTn92Peli zHIU#M*oFk05Vw4ds6RGL*D85_I;5b9f`=4tH88Qtc6}XKxDM@`&Kd z5yVv8Od6052lZG>XXgaA&4yj_Zp)CNeswtQ{*;tpK$kg`%A*#Uo{grM_(TPH_2Z(H zpZpGbnX8asJm$W^sXV?`w70U;m9J4TDjymZ?|0F|N47QU2XdQI$H$EqyG5`KPK*G! z<;gi2@7@~N#h>wDqzh%a0F)_feQfkrH=r6nZW^=$!DNhj1$2oCEH{R{hTj@%&+EdQ zso$rYM^1|?W;uzpcZu*RzLdbzBw$|uP8u-z=gX_Mi#+(1L2eghL;YnP(=^L_`ddVb75!8} z?8l^L{jI4m+bHI=!BSh;5IvYok|#@t_45Mk2WU=rxy?1IxyBU`x%k@YGEH9u5b0)D ztc^kus1i@j{L$W>BRHvd^VqA0@4uhu#cV5}7W)XbDSFMEH=n?%^P8FoP%NRrX+zLYR-drMrS=x`I9ucBNKw$?f zu+F+f2)y7od6u)K1x9$7&b3GS)f!5Eb7q;Smg{mB_t;g^uQK*Y{ zw_N28`Vf;b{D-VO`A!F&iu+P(@zXeg?&B2u88=>;-b0FdI~>Ha%k6&x{KXXIX-b!= zqh+r0`j_)Q6X?bY3s8*f7%tpifC5e!AZ2XGd_VTKP5uswgIrKF{pTTNreN(K1=PeX z;qRvJc0caGkHQ3SNw_5cg0p{n?E}oaOzk;5GbjBzgZI@?&hIV*qg(<7ynElOSknQ2 zQ)5J$>*Njpv^)KqsERz+c;kK!NRKQqM~1j!t3GS3I(_0ZRtWp}Hg0lu=w&VDpFb>I zg0?ocFP0%kQHArrZ4bvADO;k^=4$=cJ?vpNk1VT@1g)Y#n&R>fch<`t}l)$DS&afOJY2$o~ayb3Fpgk#Q>T zGq(Xf1}HKu#|3&v?+p?U2230^)MW@Psx!XAGn_iE8O?j|nZ{W9Zm=%4Xu zp4aEr^9+XP5{~%>8n(U%9G4%USq`4L{p<{%-OOzmb%z~t!MoPit^clp-YeSgMxl^) z?lW-7v&nulXNvZLTD>FubAW8nKasfU?%>{?j2>I$KkJnSJK3;2 zWs+C(jMJae^8@>K)7Z!7&=zm(cP5dEhVVzJdWLq=*eP)3rn~2swX<5|Y5#K&Pop5; zTaVW}-0=>ZiKJ^+T|}O!je!0K0=u0{lu*q#mV%$sPev}X0Kej%p+~WrD7uo5I3sOf zma4gwI+S=bPL8Z(>Vd z(pF+E?#uo$r4nO3vFWzaW+I6ir}M7WY()3 zk$>EiM{H?m^sET?ug7i$O(0Kb-NQJv;nDW6^yL|Ii@$A=SLN})IXH!`l&NE0$M47U zeH1Bvu?z>RJLq^;GJ4^=0HHXLPL|J7pCd<22t?{E@#jz{PN7H zTdFLsMdIianjd)6s|17{KDEy@#_;B7=gcGJlxQ>d=X*wnB2K@eTI5o06mCs}K zERgBZ6@(QqH9nzNrZD)yd3nj099~8Tp6i~Z^I)=4-iEg#VV%D>}A=ly{LiuCe zL9!z1;wT=RK+!?nZsi(y20jg`^FH7hM6#m(nnW02vK{wX$g2s%?6JHTXdPQ#t6oZ_ ztFY^Ue#BW^vG=Nlk%kC~ughF}>oN&IGP|#o{4{K~s6phqkf=yVK;*#6dT(k`yMBPE zvS|I9P<^)HdGYTMW%UP5Rd4!Y`i(PTa2ER&?lir8#;V5Cr=s$Mn| zK5z0?%9vn0@N1Ep%!(5k&zz0@qp7!=wv)3N@i5;Fzjpek+*qN-9fDopG70B+0p{1{GxEX7(Rz+|PXf z4+*}?E3RY0n={Vc_Am5#Jus6X=fR43CE(b~QpyUE@x8f)a;=jh+ug^dvwp1c!73z$r;lVJ~x+MD<6Pl)N?=MNGE4&MhO;xL1` z^ErfBT4Q&p2VPq6?Gk1?@AF_f^!q~h`Q+j2IO{Zw7Xp&)_Wh8g(PuAtKtGuUEj8N9 zl;h9t5~d^M(vEPvmfg!oTpYg#y4P`xWe~Gj*A%QRqEARW8 zUejT$emN6{*~DSQhi#PV8@3+=H2mA{Sa{&csHio2sqDP<@lV2YDlN8(?Gz%qkN8qx zV{FB+l<9L2X)r_9D|*15uic2jV!KeK2h*76oxmz8`N-4c72O8(jM>fi(441Q3&T!- zkuby$yxPtHDVkY4X0LonFx$WB@9!_M0`0zB{Or4=D#+?{R`!9mWPR<}t(T4v#cyjt zGUq%jcC5uxoN=}}U#9aV{%f^zQ|7#Ax&YnUkX&X_vA}bWzKhiZ*A7&ZpQ2f#5Zd>V zdp4cP>}IHNx5$VYEZY7i^7wmb;_@QasrA_n#$_X+Bb{2pbq}s88dDWZAj3@8Lr?v{ z=JStD|9aERA<@Zeb@rN-{Q0oSe^{z5>qay$xGMTL9SC6**FREfH<}F9Mek0P|9R5m zo@%DRLAMFI&HCpVo<@5;wQ~^+4%Ok8g*{Iin_LdKN^~XmdqYB7Xd-{6PtrNtiYrAH zEi^nLFujL1p}izX9L>xWXPl!G%MEBU+r&<0B=--HX#Y^YsYY?KX_q zA-jG-e=Xx_8N=YbEdGmpsWAB)lHznG;h*Z2)$4yyL@*vkqD=_1GYCcKKdL69q3TDT zbh}eqUpaeQsQ=Ee2!idh5qbphs)os1jPi>i3PEyDT zGF=!G$OK=!+UN*B)U{G#!z1s$2)*aC)9m5R$Keg2BNO{cx8$ViM%GrnW+=YrG?v!d z@V68OO4YS;%Cs%IYsGA5iW8L0P;|fyBTtBOAR=#Y>~LI*<;{z&f#BHgD6oZjuFnw< z=q*)c-^%<{MEhF9chW=U)^TOg@~)ev`eTe$hehqqfcZ#bN1kR6R!v#~`3cK7<-hoP z98Iq3J47I}UY{=MG9#pi9Jh;*AXPY?!3@m_x&s^>_|g5)TaLOhrzTkPt{T<4?9Da8 zOeOWsheAb}yLu##JYO32Uy~gjb$hYcOo)q(#T+CH5^39`4_bODOGwMxxV=*5(YLt-H?p1DYa^EqODgr-$or_DAmxPp8@+h#WVy9_C$B;;_a1AsoT^1KQsts4hb zemqgbEMd1aV<%(5HY7$gEql3-9&La1EILcP^Fl!-4?=-Q3=xRO`7nSnBqLMh@B^?2 zmF#k8IygE%@Vd4+CCdKNV~M=Yxyb5A2$Oo@r95(>anD&PHrlS}AxV7pS(d0O`u&KE z-0EV-2|1OX`&@Bqg0twq_iHIsi>RgMs3c%ASO-Da66FN{K*^5T#SrHb4>M*>Qw_oT zx`%2$aBc|0HLAlIIFxoK7W6PGS$Xic_2Jp5;Xr`(%RO%v>6q8YMYmLq5#s?;ha0YM z+aq!F=aPR9jKlE7FsC%v4PPswg-P=C$1!7%K;LAjFycx=>qP0JT$Q~gHDo;a?l5=j zBCq`~xqO}c`}$Fr?0A!eN@w;3L$L!DV~j{&^EFcVf+_pSV}w4^OvIOki_(`)$tFJ$ z36);Hkb|1yY4rIw?vS@$dIzz+Fm96HGFw}lIij*{V|nq2h(H5Twr@TY$-WyBQf)r#Zngi<0uXA^$hjR4181BI2%6NHx(nX>XQAEwzIl+#P2cyn zf0g+93`59N*`kE6R7X#~f;F{sPu97_v~&apItiH=bz*5klC4I-EO{bSXWFDMW#LeU zlZTR&zN3+~2WPxpvulr@0M4Pj7qIf33w$vUYRw_D2k2!43* zSSqXXrX)%pYJM%;XQL&z{nsOLO=Sl-kq{A%Wr^?JPBC}n+)dLwg9E{h11HHc>bPO*bzZhmExU&HM1PEoVH*zcVV`eSN>G~`kP48e6&}( z`7rM9J5UIXc6Cp|xOvFjGGTzJvdpd4JyAXgQi4sL6^?}gO@8J1zA0Y|DU+yJeK{;% z6J?sEEYBKJ)9gHfOfJr6&>2&*_HBa@j88z^ihnHI zA86ycK}YGNWaf5f66#J($Dc(&h-d8c07V%Yr!aX-Gd`G*k|e6ILlrc6=3g%#rvPEJ z&c)(^Fg;;WD{(2DgypaN*@1A7wuII2WNR!zw>&YV2@!9Tsg2(i^1Vx-ofM&xY z-Ar~2K`VQANx$na^O=~{DmmuGdX24CVKv2?&GWOaPQ>^ZiSRzhzy?x4q%%lTUVtEH zyqf;|)Sw%`HZ>bS@*e8QDnmrUE3H{gd>Gnh<@;&2^IHo`@A&1M*Asu_Ys z3^@^JqcIK9@B^9k(~psc%O-6x>;uIx&_X0_zvaXO2tRpWA6?*YKvT8}ISHtO=yXY^ zUI2(@(Lefi$_x_LexE{VhcckML#8jOtFsk}`NMs&S!LJu-{#`*w@GAAAfnOh(40AM zRYnNSMb~s0I-Jfu;(kDi5=B`bB(n1cX+6a*^f*b7IK`(x6=H>@7vE4y>6`*K`{dkW zFnYqehwn$|GJ`}RUr_{Co%MnvKTbn7DvV&8%Hb2KpB~f4N%b6k$s25%8}$G3(Yt9W zNjbx+unnrgESf9ME~=2k4X769ihKc) zJB&Ll*3Iq{?qgEU!bP|mvNNqd{k~MlhFmIuvwjV&+7*e%=v^HAIg}i1MC*h-S>!i_ zyKTZMcFt#~rTi?7vu73bAQVr+ee_XLfH zBEkju-G~9UJQT!SEioC24Q{TXIPb}2AH@D@l!Pt~fFe5?XgydS)8nCm7IQ(|+G&1A z(MLXwW@ZwBvNl+p7h?A8kTe2XL6Y?yJnqN_Hq^`;eoTPPf|qEDS;7cmPNB1}t7aQR-pZ z_LDHQk}518s7&KKhQ_zK45BPQaDw2w*kl{cI7+YAeSumae$y8cQQsbV zR1c_^8vUBqX541Em!fsW2@bMkOtYp3NvwCq=t-QC8mQcU4lnj)vQ5~uG?rtE|{4^kKO^1yQ3cViFuaEvJi`C z_)5&^3@X{f&Cpl6JK`ihP59#S>dbU^@j`$ySFC2T7mN z8@t^Nyt;Ne824+Gd+1pY%C2pFj|#qr5>${Nak+D=rcEx11UpZ%e~KQDOCLWz4fPc= zK+v)prGnuhMzpXGn?7VR>p;T{8L%%im{6|z%6E?=vqFE3%Ncauy+>uPz3C@)K;ggJk?u1EH#Ul&t41s*JW`@E9;2=OV(r)hUoQ-ap)2+rDhf&9^dKJbsGw%`~cTh2~HdowVO;JjagEDA7_f=qD38n83Maq+bM*&9`5JL|7dtLEVY~761*B$=N^k$g+}a62djxR%r`ZG{17H4T zRb{YNz?;e21v3YeC3pztE9aF3NJ(C+T;4c42^FrA=O)xv8h|zA!TyN26Bbz597NlI zeiebmg+Ac;${u+KEfa3$VuYHkfMsosv#$+#J)DWpCsxp332ir|Z#5IjvZ*@SyK1q` z+}=QL9Jgkc5y&jBOk7dgMT4 zZ+5LfW0?OLXF4RIPJc$_ddftW^4HB`s^(j;(8HR1&$SgfxaKgv4=-fgqSdI63yOHng-dR4_ z?BC)}$n2-JKBtoP(u5$ zsyp(OzB99XB!@MS*&)yT`~tJtEy`?)0|xQ|_?^1Mrw~u(i;@YY`U>JIKn=HDDY&qf zzO1pbM7&utTOcfiI(Z$?ZVzseKM!S~=oI$?+vX{ZV<^;XnGG47L4;;+@BT)KlEt*c z&?zh+Y*<-Cr~>US>+7^+-97Mgb8P;KX^0$K6F0lWmek&Q)h!H#7#mQf55RT6a==^T zPl03Xha0%I3k+2OaDAJ!d;UB!cU5ePY<;H*GQ~BoEVg?iXC*46&r4NxYd6}#r=<&s zj3atjI>RKx~&&vh4K+4eU_+0VP4*#6kM32YDe<;2Q+a1%`HAV(qllf zP$#K?mvajPk!uR-=D%5rqShdqx|5<&tp^jRDG<%1+-M z+wF1PUVIk;f?p0Ifih zfSoM`@>d<_u+D=~B2&ul%(6Iwerye_HebRcOL*v!luSgpdUa*$X5M8`N26j|1M6Nc z@#7i40L2|<^Kio@zW>c$e;!wx?|dY1ehpvHV0Uc6C6Fv;$V`Dga*lU@C~Ya{AeY>U zyikCS+Y%B1^Aj+wN}-^`Q`8k2;G*3<_X$p0^Dk(TZ#wK=L95~0Qhyf;$AGh)CRfbo zNylLr(5o<8bWcPKiU^x)igZ7#DTkb6<%2$JApsW(x;TZvj{{wh$-fU+jJIce>*Q#E zP15xbTl_n->=^+yeiG*}E8i(IUo$5RRmw?bIj+aLLIoJ;HK#xAUXR|~9d;GbF7U)TS=F>^EZkfXbp1%uoOw+MJp*?vMk7dnX`DQ-!+LLEJwOuNuH6j8Sn3uLue z@$z~gRqL$9rXR~$m2chH%wrc@1Aga(*%Lb|TzI2}Xo5e9|B~g_XJg;F_XplavUjFC z)bL%tUX^`&#zu*Hj<{g{L8NhK!rt-B@*6PE4Vu<5cPNzXC3ux1^vCenfL@&vA=r6e*~aJm^?RPv*mkw8N{BSu!^ZmuIaM6t3>Hnd z-kP#_95@jY2g`K$w4d3ts^dikrv(SoQ*)UJF_6RB#bF@uyiNdaAL9zSJ(#==RO#P% zGyX_WydEUcG9@DjUCi2BU)r-JArrt6>f~1!{M7UMbImJ_6~Ix8X<> zX&8l&)mU>#{z`0=ULeQm+#&jACCtlo-8(&8 zeb+97IuFO7R&D_y%70E2APsebonPZ7I536O27O_mch_XguZ;BgXZN*{kt)$e9Z_v! zuW)#$GY?_wZ#zmk%)FJlB(gaEd8|>Q4A)myF2Kkr3C29I+pyb;3emlfk)O>ts)t&e zIz+L_lN_AD=97WsTJn6bwE-N74QGfP`f9(a4Jfty{##h0&>eq3Io=2AEmCPJQ_!kGK#-g$$d>Lk@m`hcs@c|09h^%uBX$`?nDE8OR zw+pAtq)~wY^2WASQo7daJdxnj7zW2HW#=EH66BamK5H`Z&kinP=L%mLa+b#f)mOI& z=ekX#UE!{QA7hpoDS>W262`pLa@}jxH|DE@?wVy9lT_IN@5PqPE#YpJvzJ~fIMm0O zh9i`yp`{UFBcuvIt{Z+|+n+0&xCA;y!J+LOt^Nci%M`+8~(uwO3 zU!Hga+8+7Co_kdpHK3AEW71AIW71*b-=`tJ0%Nk>FGG7@gVW|;t5|CuL<6q{AKxo_ z{ZaaIG4>LYn}cQ_uxAi7?Eke{`I)SD+(WYst}B+jb-)bw$)()jx$IZwoQ z7e(-<+=AZQw>J)nXrz&II8YBwYP@JqE~4*yGd9JUt>rg26;!JAa$nSNyf68a7iuB} z<^2SU#g&9B$U;nA&;LF{Q^Z%zk&IS@CbUJp6JU6*(~z6TQ)y%O)ren1qP0+MQ}DMFi|$O!(U4pTCh?3E>{BQ>F{~ z>{1M;*!ZCjtBl1xsJ=jG!F|Wnz;&rh@fT!5HqttGV#R(<(Dal!T#gN>xW`q}=N^QA zr#~olNb`9jQ(Bs`IZR(mW)nJBGy289X%&L^hDG0BAUNH*H6ZdKb!iBaC4bg75Z?7j z-lz*099}>seiCaTv1z0fvR{dXpKM;MqWn5WM`Z2AcZ`H(I$`0#u`!l=l$`*>idN?N5%kVRyX)eR~oZcyHeAIO`pJOY@y_H7Mixovd# z)Q=6oFbg7hw!u8{5n7Tmqgs2gdQn!M^E@_$^lMt3Z=wpv0MA)Jd%H~V5qtfu zur#n}gyP38qWu!?CM$N2Y9WYJhhmYz<+~sU1eYl7dNb@=+8wvR^L&%M`EHihEucGk z7LuF`9Htujtnl%AeyDvL=w5v0m?RkoEOwkc1a{6M!aLr(Xd`9tU~++OZo9THC6p6j zbp|H$_$$wWLq>-d-TtB>lBsQqXJ-$MHY>V!-XY5m^6WzqzLvB}zt}UoQR*_+GQIW8v@)dLU3( zH}Y1zas8v)0h*}l39#-NYC7B*K=kgfUje?PXEnu+$1Yfh8%eFL$HHoGS$>bKf8ZM| zt{lW`Mn`o7>!>H2X3UBrvB82rnkZH7os9N3)87A{Vih8HVQqO{rvABriU}E3h+oq5wD5G&%8>n;0PCXsmRqTO zOJ7H(9bOO|WO_%m4rJZ{wkebpKB&Hs{$8U>r4(f#ZoF3aoEo{PkSDM6T086B`lH4_ z`nQd0aVdR>@l3}%p85CasyE96xX%LNL)v6a#)TL?AA0V;lDsU|@lm60U!zMXutH|r zW*4GtLJjP`!OTBtRnw57y)!dpCY*ZLS7JFK=r{FNe{(u{!LFb9qrF2iXIp)p)H*uh z8?0}Qg4-}sIoo3GHFOFy`h7Hn;+CsZ?%8i-xL-#a$XhMphaT%ZUKCSLOPL3Hf?sS+ zG|e%b!FaXYjfXqW*&TND>U(#Oa^@=xcxV>$)B|6>AICrBU< zL>Pau0JxBV)sM;`4E!A9Rwz>NUM&N=R@$U>~Sp z?-z`=7^_nHq;#I$_@BcMBPn2jCI;w-{R+vbg#fqG;a3bJj=cZCczd^qEyKm+9)yRe zAPm+rb9>vIm{HZ=8X}5bi!{c<-fjt4BrpJTn)ge)NQ9fZOa#yzDDSa01C8;QrT!;i8DzHFBEt zA9_fGL=TfF?iNHRL)p5APV%|=zLTj1XTE4ax^g-2?6zJj$G*g65`!yi__WKOg}IKnsiq~tg&Ho`n&nkkiMYd^4X|T=!aWwop?t^(emjQBSU|G<#ojb-&A}f-7t3_Dr-0pkF`5zcA5B*etAIhfxp@2XhVBX&My%#ZC0= zU-x>Ho4h#RIdeDN6sgUZ9tR`PilLSA#bZ!*(QJ`%7y)bfg0H>bPa8{~H-WzORst;& zvHyBX_xI-yk0Iv9+kS6sngRtM>z?evIvSOx{!)^5|K_C@?WHGqs857jXE~6lj2HOE zBF`4YZ1A9RmD=N-M~!K9aEv2j6jP+fatxn)7q)Wfv5;AEwFnhg!Jdnj=BG8H-C<*NQ*|e`7 z@Ccr4##x}9r7$RGujGo;ohsaJPeJ>4=3jt}owhLiy!O`wZ$Jce-S(uq@*EzZC}PvR z(NHHeTH%%EDQQsQ2N>L+{Occqd_RMFp!0+SM>QDE#$hIMUAn(}zUFFomeyJFI>OdYmANG5OIfEt}g`Do6dK}@T@z|2^;lMC`1_>NnS{0{4hzpxlIZ+aUsXL;>8 z3`Cc1u=&#hVsE7d84wFGsrZ-BMnHE*7Aw4CU)x;17Xv&Jk6WGHQy@j zD>d#ukKWYR7RH$jBcJYW=t&|*N7nK6I}lYs@txu*8-5`Ek9$z0e|*zSI_TR>m0{Ya zPp;xL3u61ok|=kChr7eSV8~MofKkKJKRB5TjikesOw435K>ROKc>~d?Hi+c-IoBh* zdQE>t_rjs<=N;*pcS)!DdDQ=OVyy5PZKE~b?3*zZZ2-k^E)gk;tuZm)K3r^QfZ|@n zKpfK0vU7#_GyY2C|5<=F)_t^UciNBp4^YYDG#gMUneB*vnw@Zs^jyZp6DC#wW=`A(RN$|H|Y(kx#9~bx7H7Uw0rzPdVFJ)si4AnRDTI=eg z4UmVw;Qcjg1aiwqhmj9a_d<>Fhq743Ihd7bGxv3n0{N1yPf|Z(WL_J9d-3D5M+7R< z;sABY3xh!^j^F(=C|@6-_=Y%SAbu_ehFWH^pMwG(N-{z~=>${AXK=G1fP*yu{nH{6 z$;K@zno{0CZ?Ira;BC_b#%{ah<=p(g3U>X|k<&L@cqPcnrd%<=}MMhkC(m{l}K^3I7$dUrFn!W37pLAN~q%08n zT{~L=FOeU7apC1#GKF6sFPc!gumw!j-*PT+a+&UJXpsrp-PFNji&Q)S{)+GC_c{Td z7t^8WUfMZ>nB5+2C{Qpzj@28`i7K}_ky}odq(^&nsE1enorL76=aElWt5v)jPwYT8 zodk(}kJ;RR+TI_m-+jrv^Cn*O+BVx2xJ{7$=UM;whhbFy`RjFdc5*M`6Lpxh*pq@W zt4SzwGQgMNSIhICifhndvTp|_8+?Qp9^Q#x`^shdApJYU96rpBI@!~#^l%eCGBJ8y zugwBMfKA_foY&+L@sQidZ&&ql;KKAcuH-*DumWo#MT*r@Lbx6DPk|_zvuxrHkfU?K zF<(X|u?`w@hG*-ptb)c-dg zAR(Y^S7OFuO6ngV|D>-Z6{jn`f#0xS@gFQNW%pSz7EKlvdEs8e7EgD)R~)xqp0K+6ncrZ;^S8g&%i|u69d4JCmkr>on2ejw)ch03YE|lN zO?{~P?B4Cf)O7XtEoW`oGS@KdeEWVhvpX3zn^-8Qi4}Lwt#+n+L}xJj*BSD3QOH1p z3cLK*<^bb9Vtq$8I(g@lCz5IK>B7NE9$9)D7oNC+AmlWSS*ekqAmx_z8o?i~h=G`R z^_9;9MABW@Un^J!9V#l)(2eZ=@m-O`jrZbK((;PLE-YFy_f;?ANLJ|kX5BQ(ajP)1 zDRQ-S_)LkCiFmaj*;k+KOpk4#Gj1LQ=SniI%km?G-=9CKck2!kEA(e?PZvF&b`YN& zy%`-VzpT53tFMhqHEYE0h@1FMJ@B+$RiE=qY%bUCJN82kf;<^kbsj65=h*%oADa2o zPo8;|iF>N%p|Tr^z=uwoyO0jpinG1*<~B9_B5pf94rIMvj3K0^{5;-SGyww@^|W8k zZa^!>*{$~t(`{r2j7%872})K?KXv|7G`4`0nx|EWcaxJVC%cT;sx_nUP>3N3)3qDI zD8APL-%n|3)d?^#k0WmzJI1ia8|2oby;%zC0g=n+Uln8*#7laf(NJCpTmXsUxfv_$y4c%eyC#pq$wQSsG(NPo^pHo&TjUp z>GoBU^{>AgJWj3t;$RB4oV`|p^MuFs>*ZIN?OUr zpWC_lp_xDIF1me-0vog52A*@LM5^cZNDUqY!3&aL%)joTzcZ13w2lpE3+pZ!$H|~_ zromMk05`No3h6pDwP{+V``(|Nb_d1NS{$F>JAo|xg1a#|!n_n>l`hv0MAy0-MBZI* z&c*PxcmM3PYH?-}Arh4p0*nxzF*!6ZtJl-=F4$Ecc{<*?ZF>Zy0v8Y#LSzte2OeKH z$qVo0tB}%B4Zi};-%AXYL@9M$>0^ak?DC5{Sr}9g;edXMtCyloPr{7ZM=59M;C2s| zjKMgXAsI3Dm{J?BmvKgi;Y*CXV-fkWBK$jnrW;Eqhd-VbvA^xc1~G#lJm%tv7xTMJ z?0LeE31_LvoYC!|D3XvC3pi$hc3Cv&jpF0VnPs$XhwcV;&d##zl1!$RCJcX_gBF;$g@Z?Gt#K6%=)y zSpe2~>9`KuA1zYh%}(X(bSK@la&lhAiJ+>@R;5?YuGwy;eF?-7K`2HA@i)X!o*_O4 za(q%4SS?wl4X}%yZ9ssZylL7H?%(Yf0R!rQJeL!Ab(m z;KWTppDEd!@tdjtm^Z`8n9Q2LAt4=XC0TnIIrTCXHj%@X)#ww>~mc~mD?WiKzozivP|n=rp=z<~IR31;_Ln|xu7Oj>T@cjYe_;+dC7 zeDrBq7o4OgK}Z(;UREk-%6T>tXx~S-WJw5*czE5vh|f)m-qrl_jN2)|og`art-RkT z2FH{jH|d@#x7-_xD*1I-GFtmO?}|(9rHY3lGoDZg8)^|o#fpgz%A$*)Tm)o zZPk*TB9J3DlPv+_MB`3vn;mJ?(-W@SFKhAU!Uc_EA>D&c4d%E``K4D@Zx|u}4XNV? z=nJsHI{z7;M_~m&Hx*DH94`?WWdDAzLXhZsseq8_KzckY(i;P}W1XCSG@*NxCpa&Q z$)gXPmO%RZ3Acs=+vHW~8KfRMP>LJF&Ga>l){0C;_RbL`Tn_&=ohTG*&v%!%3m+*L zEF%-)lJ>mZhcF4`^Di8311ZKv}s(fFweu4MGIsK#R* z1bw4_&M7;qJ6nR#cAZUiCQN((`Hsrj#C9$7XS}bRG>=VX@SwyVN226ecG6dndVAqSGavJ0RK5$vb)lZAM zGKA|hz8UVU=$B*f&2BC_<7PrRh;ePw$l)v)>_MkvT@1MM;dfOShD%4 zRTo5aq_2@DpBFerCV?Q0KK(yCv1E+0vn#*}~d+dTSS@8L42C%CU!}lc_4*IvuKv zvu`}9C>ahSXp-z7WxFK@ylkZ)8$6Si3*$#77w!al6N`tGP8p)Hi5YleT6#qi^2G@X z_2aaT!73u$N`*-+T`#C-{$P{bK>MMpNJF;_=F|-~@wDoXSG5B z&9%EI3tRrHvQFQ5?wWHgc-z09d|F6A7L7=;F?~SXjSS?6jk%vTc6i0JO#~*(Dk-k$ z^MoD(AG0u3bts~d&z>oXe{UB$Y`cel)bl?NopHeVjFs)u18G;~; z*$BYpp3JO;R)x589hR%UvtDY3GLU{(Du1&TT2jwUQcA181GL<&Q?J&v5ouFb0+!iJ zqN#k|R?sw;prXOq2hG~Y7FqnrMGrO@#%r7TEbtu;irp}z6EAZg6Bdk@AnxcwMo6A2 z%p%*G`Px{9F*LYD3ucyI1#a9tDm?Wnwh~1(Tz!ftH>GuRD1tm}w^sP{O9}ngpH~1v z8Rcmk-=3!l%}>!hV(;nwpL>HjZtWabd86rHGj=L#;(q8{?K%uVnyvacIeNWzF;4gL z4_8yjZv=C%DTtryIgeuc1;AXLwZa!l8_?bp*K9A`vvk)|!nT-@W9UU-%7;)zA7oRi zt0L?ErVHqfmrpIA?TwUUwYF|erQ(2m*5ns2r=9e%7A7~3cn>#rAxJ-LK2%li2~Hm&8RBd{cOkb^cHK=d4<}3;#rVk< zb039qruz^P8wwn(k0^Buze7eYP$FVL@nS|jt^P5Jp(5E4J5Fj*7xx5&-7du$GRsYe z7%A;emO_iG=k3%&y`x7wjs~yQuuaI}bRO{w#*r(<$N!Goar4~=;toy{()@kIQy$|D z7t*u8_;Tymaj_ydQX?Gz9s-Sv40lGH3D#hRG9zc!$70 zD#kt#u!WRQG?|$WG@O6)dH+RV;i9*z_YNXya5Sg|W5xBtSP(6y=Gx-oQc~ zSY$<9SU9Crw`-6G@og^&K+EnP!bhf8z6mgf8rwb$56C6J+DWrfBPtCsiBC{8{ImK) z)_wp38KT*O4~+Z_=+Y-Mn4+WKI)_k(gRqxkfHA!?E47L$=bS6lN*hw=X|u?E5Vxfu zLs4r}Ub~*jXmK}MWSXJh{71lZ+)=feiKUOYdI4BS86dD90#4CHSHN^Qen0e?j;5Uv z=+Es^kr3>TJLo}?U@{js-8&7A4V`a`OQBj74p|5*7{&ecv+^7EUl(>cBCIes9UP%7 zf}b+QpQK{1LRw$~Ja%raFx{pF5{jXu#Ns$O0?aqP8d&gPA@mF&F=vqj+y%w!B0+oq zJFc@P%P&O^9c5tveYm*Hn;Iq9o?*{M2zKu~YOK46F2$|cT7pK?2A0@*^;Q2uCn`-; z1lKNhxBEq;(3Y<{u%;w1$Bm$Oe@ZUj{c60*q~U^XBy?#Km;(2%P3#o`sbG?YU;>!+(1E%3Jf4FtQ>xom8jPQVR=SuAdQf(vP$H=%2FvZ-zmP-$ ze&}J6;LWBf+#08>roQa znZ0}Tp`rQ%Js#C9TZO)#_r{mbtFw=h&7lVa5%-{{>wq)t(IPDyNcS9tkB?`>`m%#t zzYIBw-7Q+T5%@!HW#jgXor5st09d9p=6(YY5$Luf&~^1E+{T8Smbi}WZ%R@A3H-k9 zle!nvfk3w)!EPImx0piLZ}i)m-KST?_QISkNK@QE5IMLTP`d3A2FsS;%@q<>_L9e1 zTfz4X4#Hl*i{>QXkl#MH!Bqm>_L}(^Olm=cxN-S195*P-&%oUU0*`dE;jf)-D~c0t z%F5<}<`yl_08FIRQS>}UQI&3WWn8mQv0+_IiEsoHk0HwMFNPQnqKgu{^Ifxyiw=BW zUF&%q3(eo$9nSpWXb!94y>P1LZbQ|@X)=6;!_jlq@hN!2THyZT znv^UQUE_87s|70C5OR7QBZ_LEPdmABA@}EVblvjCGTxP6A6uc^*;sj$hJ*b~j3ifh z4ZPdaaVAse+%$(GKKU*Pon;!_2mv_y`KSh)-FHon#FPdhi1=k?-5J|~QMxu*>s)pK z|2zct$L~RcUid3H^`l@vrdaDbVL>rO&D2>+!d&-mO#91bh~GSu+0%t>J@OwFl}}P# z4Ios{28I_QN9-tno~lDj+5nMu?E@5Mv^x0EZLE}HKg5!x82IeZC?y+CbZDq|c<0LZ zshxZD49_yKIHDGyGuTau&}((W*MSTd98ZhybK2IB`d82p7D*vUaL?p#PI)MD{y^ac zJn@GGOS*D(bUi;YpTo@I-y`15&rcurXH6?;c}F=lb+`6VG-clwEo&c-G0Ehdd-e%h zS9(1<32mm$JGds`I2ht_kZ0Tb6)KnD>is!YejUW9j^(d;B&MnyyAOlwPu*}*L_Nv) zv!=puUT_eUOAy~ykQ_(_&){`NktE`UAUmCgvllm}#g->fN{qqYEhinb2nbV&Y zB`wO-Q0h((S42t{I=b8WU4>u5vlg=fBG-g5cL~9D?0ex)q zmZx&2<8!$`ONb@?Vf~LJ)jyvWj~&bglsIIVt~U!P8EK|v269_#)PLX|buslKLY#$$ zYTq9x3U)D1M%+v;>x#V{6W z2KzsC44)qJiqib^x-YG~xl2@Z34PlfyMEPcN6Q(3kL7s%LjD`)(rYgX-dB(Ekf=ax zelNcZC&Ueu6Jl>akpDJa6dow}Q4+h8A!bH!P>QDFM$r5KENSY*;ZZ(^<FZquV8?S`GJNPB0>yuN5OR- z--<8#$2GBAD^vT|E3%8H7T;gs<=PjrqZeCmJn-YemK)z}2h5ap|SP@Ia94m{9%+4R^O-DUChGPhJ@%i|%gwLGG3LvCKPJPRJc!yP>s zUTlZ3;g;^uvL6#h-3ug~FfeO1dPBtSUSSu`(D)&u>O*@txaqzfU64mlWSQd5V@^^M z(9v|X4_4{roY>{}S&atRPLXJ|j#|`v&wGD96USzMq4M4rlx$MGKAwK)d44AM`rue# zUr2Xg9tv(1AM&*qo5GZ`RP^CNeqDcoh^6toYve5K6lLuc%6^(_S`%eQJ~1I!L2tDguLS{+qQ@p|DEaT#X$Cc z{QK*QN4@^`lcUHx&cieX(lhpI%7-zImhDfCZilWBpXIUW;4XBoHlxOgMp!fwsCb!a zHlCQRyRa69F^7y<2)^_ew%*oIU}Fn)hG$(se?&PpQSi@}OdT-xa@HD~2d^Jy&Hw zRJv4)=j+8rxwvRo76q-eE6>4;nwcO2p}$cYiZ-^%xQq>FE4>g1b+6)XWf+XwV~l2=Uy_fdk8C zCt>djc9k8WgW?-p2_Noq_X#G8sxJ9oGG1<@+7j{6wi*w2CV>Hx5YO~8L{LEpPV;2u zzXA=AeP}EafJ#+|GPaku^+FaVO@1CJV?#CT2A}NMk_jIfdBoSeB-X#;N5ifea!bb+ zqK;mL8#l*pY;NB#GjSITcGw+~&x1{L#ufUbIW0WY+f%p z9D>}&q(I3z{7w5iu&{^zcnZ1w7@ISGaZd(r?$u&qt~~Z_@fl=}lE)V|6U{O&yOBoIidY&VrT~9(>2E064JvJlt^vF}O8?h{paKkG? z$}<|Oh6#f^fqqiE%g2>H_vf3CYAbkRxV^VKpMq5VmPa-gKOy`vdORj{RQPVSL3Wr@D=BnDn=_H zGKAoriwJ2o)wtP*6Bi*NifM7(oO>?}*GTSnqQ0Nxsm1;BeH+5mw1fOX_#wU`mGD&N zSWRgSLipu3w|@|^?j3~0HtP(w_26=adeY=Xs3)p=%}@FVc(Jj>Ggir|(N}0c?(!gx zsFT@Q*BSa_yCJ!?X4wu*5i;c*hnlYW^*;1E^*E_W(lFqEYZN=fl2G{0HQ?&1+(L!@ z2Z6<5t?S`C=&|hY9B0vge>!^}Po3!2%eM%LR+m zQUe~S{Fy9x(*u7s621^{9lt+7kI&=Hrgs z)^ic^rRK2b!UWqvLy$!-7g?+$tTIvHyW*!?C0E>ly?90Af#%mxfn0J34q0Bpd*AQH zZS!A0jMde*T#jwUt458)swe~Dl9YnQ}#^AN?7wMFgSXik~{&IdWA~I z1E9^%3cCNSWb60-I3G#|FC7CeAbN~<&}5;#?;(ijy9W+%bD|N<$Dh`KQ8JjH<;7ql z?EaBSXCz==1``6@yHp2{IDPI=j`Li%;4JCVEpFw}?dMNjKPkXlol$*Xo)OoEaY0iq zeov;;R8ZANEexKOt?x4|MN5Q9bae6bcK+dMrQm)eQm z?z$MXuQ8?+PYgA4hwBEd)O0xJh5@=rx)0${v7#(yramb!xrov1(%PY;T(AeAdl5QQ zS^-2VL=Ynru#u^$_xsIP;*S{RH<#1Y*!goDf?+~cm$!8@h(V%hj%-s{(rIpaZ?7`*bJ?K zFkh0Cb7)9WBcMYmV4VU{IPCJoWxtJ*G2GKzfCPZqh-I#?wDFf;tB1;xxl2i|_0xAr7Bd8W`X6s37}(9o{pi zI|=l`uS-`BOASupdzKVWCmrGW^VJAF2pD2I;BCai=N&)tnKGZQ0eSH&)80OrPC4tjt$oEdun?;v$wSDIABdkBXP56NUeYk;_AYauR)RtnbA^?25MV9ZYG z9L%y-sit`32wb9LeDB(+Lkz;r0!qRL$Mrf*gkpD4Gr4Ns+@< z-^DT0{^{7EZ%rmi21|384ZzVH#llNHfPZ z0*Bp0ehTwnz5hLHB2NE+1vlY(c`KU(aLz#tWylB=O2yGz~67O^b?2R?<1K?{h~TrPo#ZqNz?8 z5MTR3Rd1v?eS4lfx6G+Yiu=W+0G<_pLiq=24TFh);%vIigwek&AP$o}v?D+`88WxQfC z4QG_q|7M_2nuyuZNtPgMG^;(pymxX?+u(4hibF(x$s)d$4Tlr(RSbF$nY5~@(w#47 z4gp3Hg6TQp?!h2@1d)YypSd6Km~Nl`WcP*Fa$&iy&~Dn$KSJ6`FEqZDq5m7(>0Irq zF@O5LwYDVad-INp^Ssq4s!xX=xBg@M>5uU+(pu3NzV*{h727)p75?*1NB0duNrG!% z((AlfB;Ih@Dexbgezwl#T+%MO4+aaOwwC+v5!th6wHY3DEWXt&#cXf^;(An4P%VTc zu_N4-j{xB~KV$btS+68^hENwi=bXL!vttz9OZuY-M12RK8|+DgAhfYlwL)I^#MREi zGoQw8;b;pj*s^1u3E>z8?NUGiiHo>$sC58?gi~U*uIzup{!$x-o9bhnrlwux6&O(( z=6|QY=yk zB*CVnT}f#v_+>EqDV5Hn7Bk$g;R8%&Tp}LS8r~H2=UR72ErO40odle|sQBvgeR9v#X6ZeDN5|(#IqHzM4Gp-bOZ_}3Ns%Xi@C^68%H)y z1W}uQAb4C*b=BFen695@K(z+p3psRC=&bNc0g8}3JYl(HR`ar zxKyn<_V0GK{esvw*q1B4qm!G48|=m5U&1k0A}v2sdjXN+P-<*j42&PF2v0kML%^3v zFmQb7dpVktDcY&BQ*f#9#N`<*>=1gbtvmM-_&c$ei|w29@DUe-2WOl_-N+7LbF8$` zHw0mR2$sgYMi9~(o*8t74}!4B+e}h`P0GXObZD3Ou>|YhW3be{Vr1=D&B6fM|71~X zO^dVlTpiU1MVs4lok7p>)Bc_LRYJk2O5b%bpF??)eB+` zvK}w`Di)t^l#9%ypjbsNW@r&uAz__zMH~mm2+1!4=Ulp?JGB8RvgqzlFApy0zlsXIhLR zMwKOD9SEUExAGDtI9n2BCCl4I{782EPe0jv~L0KamE+B1*`2{N=1MX$FeF#tN`h zp61VN)>>jm&X*+V7kI#<8l17N)Ad1dy;WnsLBmzuwjQSIBr|8g!#j$ZKiq#7v1%}+ zwzNYJuEO4T1sA#1iRwXq=I4T@yoRY4Sfpowec~#s*`(*FuathLC8Kn=EQg@7h1&Oi zH9~5a-&Kq`P}Z$KDXm!(=ngcV&AVN@81461hH8!UMF!Mze>_yD_qs!!dxd=U>#(86 zYbgRviA%y{j+}Ti) za|Q5m4$kqu9>B#D{C;co3IY?!h^P zJa0f*N?EUh`CGscejge&__Dq{XK{j`b>y9`mwo7Ovzu~Q8wvfB&J8cdL9GC*oA;eq z%a1Ydf`aR2>NxI%T$v)m87>CLKz)N) zO-cKB51sRGO(MKa5IsRAtc6nSP4zaa@)DjYusK}9*@EHXiZeHeSg~k7N541PMazD> z+Ea5aK*N<#`Au2uXAq%jJ}Kql5I7t+J`dw0`ic0Z3_bANi&u4t=%T#wkZs*CnY~-ca!!q+YidI!XBw zA(%4p?r}riNaT+k1c}36yKMN7NgZ*~Lfv2%1qqrd)jgGK22niV`ZT|Ax&u;HOC2s9 zE`BWn+NCm6No=pDqC9Lkh)vqP4FQ$PC$uJo)9_ua?cL&XUO`m`T*Fpt)jk}GTb$5# zmaH(DB)eDcNkx2I9^B?#@;HtQB~)O0A$i0Uo zQVHA(-T1mPp$+;SM9|nU(DUG@jI`FtoC?c8i15E#xU62yK99~PlH}y7u}{JDB6c%h zsBMwVMYLbdnd9w}HZbhD=Bc^|P2KPa1x<%oj@j$3e(QUIU^%s3AS##jQLZa|s35s# zCJ4}Q?;bI{Z@^ifEgA_4s^AG-l)h-s`yL{E4wrN-t3;cA@ROAMODq5yv=s`WM7P^G zszOOdMTuH-kL{Li!#M!4o3N_I$qY*yZf)9a5*uYq9eAB zw|V1Af-xGPZNwJ3i+!)C_Hl$hr2e2^i69TbW5>wyZt$h zK>@?5!3=d?k_w!%6^W$m&VTjdxt z$v`MA+@*)YLZ9E==d*^1_ZwZbkyPOyQ)?76#Nj9h83q55R3i*B1}(Ph$XI-vGV&?e-@#C1vW;_*<-4dRHV_GoTX+{1hr=EtIaG~6MWbO72V8u&0heMmZ@z#=$# zLuU}lG>EKQn%tg@bu;Y|WU1Q2bZo%O-%XGRSh{tP7$O&MT=-ok zzB4i##!%&r?ZRYeo!ory1N8YJn=cv#7)1@(Qq83OCx!a>8w3}LZb$XgAh&apT6^m% zM9Q)c)NE ze+T$V%#`o~39IXB`+Ht}re2BNl<|c*M+oUon#D^+g3qrP%Hy>G)lU7q+gkI$1;s9#0))B@py+@VCUF>#YiC>4% z-D3Ires1vu#ZT5_y_dcJ?d;4xU#2%wx;_IgMUtavg!wP$VS@clmJFYX$g_GyQWP#I z%)KjVHUoQyYBYWz?cgDfQB5`fA<+x|sjd9^T^Gr(xA9UKs6(;8I;Df#EGr5>x(o9T zO3Z^O2%WqQO5@ljElfHzajS4s(pX?f%FH&BFjD}^M+doOvU&9G0BllO$C50C@ixy6?@ue;LAxr*$eJHe(bY&z7_o&1-?B8>ePFL zIOr8oXdPY(T@0H@=1oN|zkDG@K+HZOwWSqkGtasHO`1MciJnXhP4nab~mbD917QmCi(T$aM9 z9HvO7z78Pn7IaX3Wz78xFvFC`1auj=oSYwyc?EH6!tDo2`Hd{EwREb>_eJFSDFXYS zZ!|mWvpHLPTfbr-pz)yjz(;B!+pR69Nou%YSiTRf+;nK<$Cem6?-Di_3R0Fm{p4r- zD!HXYhQLgZLjVoQ6Fa2bi`a-BS1YW^Rm_yk6}RTE|Tc2+wAt+EduimAT>a zD!BD7ptWy#ghTcc!&e}eltqHu_{0Vmrhu0j#LqV9*My(>TGGr4u^Z7`7L42&Ori1{v(Pn`!rXI7_V<-2s={Il)) zV*5bk=U04W_84FnuwH7&Iar^Qft&1II?nH`nhy%-zdx`hK!Oz~8^k95D?i!R7UyKLXQ`}D=G(iCp=z)&OEm0nlI3xX^tn{( zZ4EP@(XrE;F9ysmp^`GHrASdR%yKV|c(yl3`5-myE8jL53;K`s9ys)FT-Sf)-Eo>~ z-cwU$6@DEAdwC!JHQn@4dE~wKO4K%#Ek3l;Ef0ID`XPqjLAUq>JGCKJEf|S-<K+ zCpqu;02wOHTN_Q*llFuURx*elIjgp6n1Sn<9~t@ErZ)5~sG@tp9f{rPsgm?@D~YAo zj>@i228vJ5m~4^5!OAFF1jXvDSi8lNxH=RJD>coCm8zh(uwco^FMQo=CoW}U3?uAq zP1wfugWVIBjx-fC;}j4Fuf$kNeHP%0{kLF?s{(q>p}65+`WI=im;Vw0M})$eQJk*; zJwYIbMT4(`CAmsgy>9`i$v>X54ME>{^D)i~cimRa*}SlWTY{$;1W*-VEoU`n=uNE( z#n1YV=4j@s_~u?(qqs38w%mIKX}dAd#(z}vW&*i8wTh*h)93?YfcpkRuQ7W05GK)u zyo_wT*5ZGR!@x}FJ>#yPK^ME@durm>jq1%1b{>j;!!Jv5Ob;IO)Tv@o}(38xK6 z9(3q;Nv1k^+z3F>L|OR+xPd{}xPoyBsj0((IN}?7VnhTh;Gfg|EM!R6Tp`JbMlwm( zbZUMEawL9q)=&hMU6CD-8csA8sJ>7_&Fw-y7$XPi{+&Y%gFbx?Jq%ah1%Ae>k7NyJ zt6m_0cj|V*{?&hV6GOyq!g80R>*~yB7Rgc=bQlsFgu$05c^A|!R9SHkQd8I{GEkfo zQvCPnu%^;g≪hUrx?Bkl3qf`RWNiKIG{I?AP9?921E1VnAxR_{srl!Qrw_`IK+? zR#LZYXm}bcgx}87vkGZ*1aioMinQ_w_B1yNhvS831p`NmRf*P19 zTF)!{6N2N<0GpXkXlc3yRmZq0%3R;-C;c~m70hP8H(??}!1b;cvjCS}ZI_dW84YMF3!Kj0ICP1rcz{dr{X9; z*TTn?Q^E$w)3yuDQ6u$w-zc0fBLimJPu|Ps)#z8oB9Y!a8eAjDF@i@;uE8( ze!Vl8!*R%I=sl6AL64*$tne=Q>R-gQ0%tzlS1=6Bj_d9j-yI(3ubUA^(W_VpldN zW~KU}0R082xz$r=1VKOLzU(VAu7~fQZYnMBf${0nq-WlM3d}gA^O~bL=V&$f7A`~4 zqPpQ*1P4oxaPqobr7K}lgQ%L2oZO+!$1M;AD~QZQo_@9h|eQ^&&}L9&Kqscr6Sy+_5W z*vyeN`ZMe1--U^TXLOnpZ}X>=3_tsv>{IX-U<+p2b+KxMZ%;??4UW}NA_r4!J8a#a z(IFE@BHJ8bb%+i=U``pe)Fd?0#AI9{3w@D19BFH>EHnj3J@A2)HYx!Z)_U<=@heG< zFOWhLi)I>Gm{)SirvN4v51C;jynlj$P7oX4fBY$KbCmR1^Hz2I>Bs!V{Rv*wQ^jji zdV0Z+*QWzN=pYJgaN;4|RWI-+g8Z4{AvwLppT+TI=_U{-6r{CXpd@Fxq z5r6y&3JT$S%xKs7qqn6}JL+b87g*`?RB>t*KlgB!;kxxcq?Z}yj@LTuLfL;}p11{g z)7Vn%oE3Gh?*rZ)BGfsjAn;9)g|8T_+rG*5*;LWc{NBz8c%45qOsE^{kerOIM_(J( zgqhFp*aii<%~|5S%_-8iYbSKxWc!bp339SM#!q|lGdvYSpFAxy*CP+!^IOU|GwuK)G$B3o!mJm#LT*3q~)KY>PX zM=aARP-m{_Z9y-RgXDUaa!j^iN`f_-gCv_M6^=Hv!GJBz3W*t|EW}u&Da(+Oa$7S1 zxzp2t>BmR%p*rS zCV7Q}s^V7Qg0KyQZ!AbuL@*V{Da}tc^*jwt!!-dSoX4S)PMG&PM%Oc|F%AY{FfzO2 z4=tiAIAofEV$R_5nl-?X?vi z6)!$viP*fp^T9kd6wlmYwU2t+%q{r&_*0 zcG1wHlijin`VRAU;V?wF7y@JUSKFf?^Tq06w-nQ=vot#Bl$H_;NC zF7FGrxY~;2``*nscVVJ}V=gcB8>;^>&{1EN@^ZcZY$ElH6rLq>09Gd$%6Bnmg$&qev+4aEE8MmPe<)KPKb#SYC)a%G zQw_gXKVSb|72?`+RXA(F8=DlKPxx{2X7I{{c=B(&2jd|AO6ODcjP9TzS+_igbOplo zhv#4y$i}X5($Dm_?xkbdf9z5?sh+pfjPW>VE<2vwaO8}7Kc3UB>Gc$eh`tg3{;NCJ?|SkBy#A5ap5!+J?tM2@=8gTt;Sq5WX>XsNo{=T`;v z5>Wx|*Ft#R=ePj&S#~Q%I8)d7WCo;dQ(-t!U{3xiYw=he!&O_bbJmXeQoDFQUv^jJ zIXJm{`WR4hwvCF=V~)@CPBd<#eSbD16G!4|(U}LihWrVZI!URm;J}!}rLZb|ER=Vo zM4kT#iGSfNpZfn=0DU-o%dnpQw)DkCqmYvTdhwjUFn1{1XV80i#8#c6XftM^@ z%`Lp8S6bVVmA9nOP-JsgueWk$sBj}sZeU|lMFp0U(1r!QCf zC#hGK=xlCyjr>?716n9m1oW%y*grT)eF=1qT zOv5U|7h>o{((B?tAFnK&(z=5bk*7{Fs`0*Kw~xQF}S=9kUfVPC-@We zM)b<9n1ajsGOnqsl9>RtrFDOpgPRTLOE2jdh19uF5<|5edAiQGirq`oHgr&JSHSr5 z0S)@%iHOenm<;H33C+Z7qnh>`@6|{8CgXc$xYZahmvw^@T1kN*^CB zniPU;JS6mh#@Ae4xLWk4`o^@kh=~kG9?>O}xAP8xmY~lA&QaVM!vca~!Fi?om9+p@ zO_Bjm`qx#E%>D%hsef&^3rYtsGJ`)M=GQ3|rn2^d1bEnj*ETM^f4>7o*u@g!FJvrY zVz}=b{0}F7dDNnyvaZC$mg49SHKZ{gPKGhscj{ne^jU^)WCt%VCZk$|BL=cqCWoAn{7la z+jX3Pk^Da#s9n7rKYREBr6jZ30-^qY#Y;43&B**S!C${&_RtZS@qw7_-M0y~#~!x2 z`WQ_`tCCsi>iB;z3dQWcHCx>A^w~bvj1%hI)Biy6^_qlb@LT{VDHS>=&G`FXKR+dg zD`VDmi8|VWgCZ!w%&dO5sD4#&FVqG|B&G28g~E648wmfXM2o7b8{WTl$>B2%%Vr0c zIg8V8{2x?72c};MCHcpDJykHai-hn`@jp|)k}%2q{z^9WWpYs>nq7&%F&oUitV@qp zZHp0kt3^{ErkM;fnJQ>@mD05=<_Zfmn^hUE{KJm!M~?xw739eE7HbjlNXvJIfrTD# zyOAO+qk4v@L!&U=DkVL4^07oBE;DiyfCQCffFg7X@r|cX8X!ln^_$lmae=tYWm@CB z5N_v3Ol^wTBxDa?;5|}v@6mNACEE03M*P3Jbxi4*5Xek2&T*9rw=2~5AeE?!E=obf ztEXgdc>NKFqioXze`A{u@E^(0VuQo-)4{_wZ2A*( zP7w)<6tHnutI&9W94hr+7mIfyT(NUBm+MlpKpXU7wCVrC52ijY<8lNhIeYFRnFW-~ zFj1o1BEb>7e7$7bvATMmuFwev)xw&DSkFjTWUMr@pDj-T{!&Ap8W5`=J=Shw1d=Vd z9aUQn;@T6k`~(}x!ePT;o*&!w7$wI#gHk3dQhCfU85-ZR0eNuZ;(ZnwB+`!3@{3jRZw}u{w zVfzA_d8BD4|CUgVpQ{ z$#ai&(0q=74skm=NUTX`aigCth}DUJpY-=k8J-=xh`k*P$Obu~RItEtG8VP$Dv!bZ zo=uj*ffSp+x#9}4r2&bh1!eC2tq1}Bbz;>@@qET;*oN{6Q|z?(;uDjdWOrRkDfE?L zF@=0Y*etsj*?fx;u5O3+apDpZ>9}vT_wi5g>}uk6TKlhoD2W)nw98qpNt^D<IW!&l*O4_uE zHESoUx(=Au2j&qPo$sTr7s|vvSHu4_qu7`w+A zUuSxPqrlOkn!0atB*+}2o-%j7)E~&~`*jur{RuyKi2_Vdz7q?n%KwmgV5+=h=1b^{ zw7JAnyoQR5cRF%P@j*v@Mi>p-^ip(3p8qQ{VXYP~#qpr3gfY|vp24yPS@j;m1E)IZ z(nz;lk2UNag>sc_(6kfgFV_%?OG{bpL%utuK_;Ce!)}R;Y-z%&)N$T)n0M~Zq$3PV zaLfh5OQ4Pfpnu@U)>U0BD2bIxnEi}w-$YI09@zaaix3kcJ|up$M+8z^hig+%p^;6k zV)mNtJ&i{TAAaGJn-zb?CNPm;NrD|7Dr8=7i&vUv`BW9~3`4~C?FUf^o^7q4vH^|2QUc!!P>E&KRUV=e-a)A;!hb1&+e6 z{G+S%jgBJ<^PZV?}P#wipcewWN{M7S(a04U8mnVz0x{7yWQeV||p8(51T4a=Up5 zHW?WL(FKIJMzL{HJCD9h#n~Yo6PFj2XFm=m#gF+}$0}Gj7GS68c6l=A zjxXJdQb2(bkEn!JEXBrh3fry|=vU=sAt1F{E1-I<6`{mzV;%=AMDtY$pNe2Gu?gwm z{S!NyR^2lLj5@Ir`>IGLF^v`T2uTq=ofC=xcsT+N_X*m zEb8)HJaCADSapE}gMyA1P!B=>4w@+?H)gH?0d@((3v>If5U7_GV|`xDn?#6#0x(=z zXx;K&-??L6DNu~uaSQK1Ax=~{dj+DyHq)J(S-3OB{i^`9f=fj5w$7l9=&=hjf{Eci zG=#1D^fOtgZ0c}XLv=V004Q`YSjNmvkjubcF%+8}9QGGWTEPm;v7Dm+o ziwHEvkfKC4nA!-$sQ*uKFzyZ1EZzd}m;F+(`TWi!qdknRb!8{z`xr3{nMUk^MM`kr%<$U!R^G zfTh!V;SQo)$uxthq(6F{g13X-N9&qm3lGpvDYBRrtv&p zq|g712WBwnk&-+u31@{VOih~PfK?6Sskn7OQX}SxAaqQ;olZjjsImyd_z_Dpj4j+?tQ0n~sx&`zBLPkId;E-oUAGh`e$Ei;w<%95b|9eyt7#kwXUgPTPAU~@6 zFv<7GvqaRmr8BAdU)VHmpcD31cPs5`9{deGo+N7U9M1ASIl3HoZjWEfKS!0|z z(Y@SBAp9Nsr#K~v!!S~Nod-w*2!TFyoW?f~M=t2;vCCBem!b#rc&v;xUf9`FDqkV} z`}gXiLR$X-HB0;%(HM;e=bu)V*qUjy_l5J|K}B1#Vhs(Yz2;8ByP+;WOWOZUMY`@Wf^ob%QT}PqQH7xO5o@6h>7t*D|nnWy?%V(%8 zurPm;elGMK#QzqYO~o!x2HpRjU%ICC=l2BhBt%wtVEi`ADJ1ovGv%pcjJC4Rw2jDx zj-N>CNJ=zYnD5=*a8Ii6rf7Gx2YzFTFF-|(>74ZI%8b!cC3Y zYA8AN+6>+B%}%-`xf2GS?!}v-FUQv|{&^ICp0eBpXd*&<`ILiH8N*@=K)>rCgvumD zcwSPDS_=$_;d&bDrjjbXeKK|*{_)V!k_S+`=XXfaqyLgf0q#$7t7_8*<<2Th93f$x zBlEu>^HIm#&A~~8Ezaq(L4q*k6r}9-rKK$hnd9>A0P}_;@Zls3J>`8;+#4+Y7^A*C zQsZGAtsuWIwlSyOho|BhORbLz_{ETJBA`k0H;4~lx=xPi!EQ85tL{#cfN!f-TdO72=0#G$Bm*+g9 zbIZrEK+P?UtQ0pPizn!cM~NOV>;q_RK9UHGr}k`OV(Bk4paG=Ko`!%gi^S7Md;$f6 z-S-eF)0|bX-cNEaVd83NDd0YL|BwS>i%amqLqA869r4W`-zNh83>?2{gE$fp%X-iK z_LKM^e3}vG${Tbp58m2t^fW1H-ZGUVs8?$_b6(nMi9h`npJyrptLB8 zhMKhrwPMB|r8R5RE-f*t(<-b|_n{=rf ze%UN~P+*={i!a|aTJ(r9pEj5rguYeDOwHP0;l~7_t+AZu-dXYF#{zE1Qoe8^j<77t zx))2q3MlpT@b`8gwBEcB^AD?(t`uSkH%1>yWKcJMm~_~(u08vc*}@Rkd~9=|TsvRK zjf1b6!q=5!Y27GdB^w_1eEdxs>@wa{{iJ9ynYzAPkfY5B`Rws8^G9w~qp$(FLd_Ez zDa*ykauB&-26>e-1=+RV-Q0VwIWz+u)VYvhM%KVQ9mgAp)nbmxgVZa%c;_*A6_tvB3cRdT<<3^pK)bdnHi5BDT zNxi%!uR+t|-nEU72wfdxOCso0a->s^9tw6i1D-R-r@7Bp?j}R1Ej)FepT@z|668Y#y+wiu z{vVOFXi1~)SD-3p!JQ0QNeL9G3w1GOT3IvEFw{ z^(uCQ0vKXNi6unXw58DWU?CfM3p=S4_{=wp7lE4aqh+h)aHiLCl)9tcd_4mJ7M7O$ z+n!o(kxw@+J^hC{scE&t|8@9Vl^9=F3(b#!KP5+$8GIs48^G}QS;*6h2i?oki)R-9qeHN|CDrvBlwmT$V)S4bM2}}#dqM{}-?_pAp%@2& zg$Sh!YnSEf;XC|LRrvb#RccX&1_0WdMO8+yGB9B zBlog~u)TZTAS&$#RLQ4A=*exJXX&muN%|;qK4J11Sb*bn1Y9fQmbB7kVXd2PR#zGS z;8}$HaZ19&!l)dF0bKaYXZv}=4EBfsWqB${Jb9uYGZUo}*_SVlRjX4wFLEJ@R4zgC zL^65iAV_WLt|s@-5ig;1M(y4wcRX}!Qj%}FOzwZMnIXgRVH#ba$dIB zvn)eWoLys1r3}uz(EjmyR~Odkd_YxsRKuV$6IY*MoH0xB)F|$Dr9#Grv!jM*%ncmB zgl#sbl~$0@rEiM6K=ik0C;|SY@Vf$_P)_dkACA&prF$=)XRI-ENGdi)lEF#phFgh^Z?)N|EyAB_g_0xE` zbP*nxk3D+bdpo-oa&Aux6wJSCIW$468@74$CEhXiT>H6u-_qriWm#X9*o6lN>iE3S zuY7Wg!>Z&2)r;>aF8-j#H<#0|KKveT=hJmo!Mbqa6U{~2U8s}{Z!W*yiTcnQDN6-d z3O@+_bCS11|4}CE>dsL4?Fh+}Hr6!TBX`^TfO}*}3dKS!=r`&)46rk3oTKjzaRt2Z zh9=JUXXn3~E>`|2qVX^0uOUC?5sSJ{odIdWnI8d>{fp7V+!Enn%!r+d1zaQb5AT4 z*K$QoxyQdtw1Q7oha1jsv4+G_WO3flU_zf>o;P~BCR++<)FYV{dqX5%J>W@=J8oL# zNS*6DX9HZxs{u~KPx`ba`>WVlSI!$9zCN(+X#N47wv;JQ1R_Fd!!gWLlR7 z7&;Z=aj$*Lh2HQERkt4|go=*&<1$h8v(+wzEmB_J?F=m~a;}Sr%SJ>hxSo`S7{8BM zEk-z!ai0*#9h0-3tC~tyI3uKfpvxhiWb;fdR=Vm8ds0+=eu_Xxrs*esqj~&%t|F$2 z)l7{aFnuA*|9V8fWVPWDlc{G1E4V9x((c>;dz{pK0ff-w{BpWGtE|>!Me_Y?Io`z8 z_&%wb{+MChau#|D*oC7+YcSDdlS)@v{H_qxHCG#uTYgo`b-EoLI||0qo3%Ps-fi+l zZ1+4j$??C5&EqMrD{hVSumIi|97b_XXRz->GH1OkB>DO! z|7&M1wYCiXNmg3QdK|)jF5Rk*G6Cz#2^L zUC!~unzcV~~z@x5QIIC<2VrKGk7C zYFE;W9M1L&EbhrEn^`BZR^^$~{D`i6F1WuRXh^l@`h>F7Y%W#1)mQtO7GcbccM&=~ z`i9Wp`@lPk>=Fqny)6nMc^U}8EH`T}nqvWP2UHI6}vdMw8v{9Uv)xB|IpBY>B zGyAgXurAF-lg9xO$vj|qJeiwX4?m}5CB|5o=`%TrSMQ52A~_3gq}q3uOsg8*u{3s< zTmRbwG*fr1ytm|D$OJCRdpF0wEsqE4h*h0TriJ78Xv&GcDG;g@OGLVT(_|#j94yG; zc4#|iYBYtLU%e;A9d7@S2gXh5n_)fttZhWeT|f8G-7bW3{%3E{CmzW`oez{QLwze# z$7@o8+Xb_{!n-$fwllZ5w%wlL5Ii1oV8z$iwr%!Y#SzYj7KMG^w|SdS8Kt{dTc|-% zwiBu>jS5kklrHhOG;4=OyxMxEJrn!c6MA>MkA`I%KSI=A{sW&B}yH zxo7A6t%$Zf|9F}amM{D&tBuLiJFyB_omekOnKZbyC=2GcA%{pev8MdoBJ~H62-WGG z7gH~eSbZl!V%pOROH=|ES8{u*Qof+6kM(AlPLIOdK`HN-dN`la zyBR}@fSEON?7=_CFJlYw`ueYFPUTVBQDm0J_k5Lbu5W6|8Q*V$w+jb0va0w6#@KOx zP>OtHh=fXAp)Jl)lAM(Psf_;|bCf_*bDbO||GL?qiB-NaHz8U&HJ_l>H9qe5;fDCd zLgmje(>E%)2qATvv}#Sam<$jlx8IZzKI*R?E6Uc|nckQCGk=lxHdedhXTFzL?jO_v znR{)e7J?W`y~+8xjFQc@yu49_*;HV9Lk$`hUj7&@7q37y5%p3FJCH_Ec9R{kog9cd zNuvV-cMh=uGMo&Qmb*G@=kNT^N>gYe?R{$#1b)G+a_$ncpS94k$6U3f3(&SsYv zT1P{dl}_r}S;Zc~c67jTfZn)cA=H3Zqj9dOuw4fXKcjx}`qY+}BHtB=w=C#$tOgHD?V#&G{~|AGGNgpBMV{E8hti|L@pCi(qC=-~k+J@D zZCE!G`iFz)n0-QGauk_F6MAm0T%!=M0D@ek^4;ngm*da=FKPXqB(3XSdd}tB)b9WE zqYc)f+SnCQFC@9ghyutj{R1mRdRa=)ys-~DTho!=?JBYFVAK9$;hS>M|usG{dMLoJ;mQ=*hh`$%3f;6iX0qv`XXQ?il=}hI|Zp zL`AwuF4;aPfZ()Xzs9i6N`BLG30;!YI~u0^3AQ=7Tj6Ze`>2gRn)E*Z)-pCEfy`a- zs=*_-zEhEhZF++Je_t;$W3nVyyqdZ@g3^8|P$^Ad2IEHqsk<|-n`QqqVv!1=nrJQm zYbwo3#tXVrO;+e?tWP09oyJ9r=INiFN|@XhOm5SOr-WdYvjt{=W*emUq*RXq0q(G? zVI9M#rGuRdSGI1>JMWrohV>%rLCW>vFVuveotW2So&uSNOS=}E4z^EH*=h#U9TyXa z3m80ar?Qq(W^|b)LqlmRKERyQfqLqmOjb8t+*(ugfB~vE%`4Xbt>FMNKvD9XWbPeC zMP)vii~_*LmXtV^b>`QYk8Czoz6c;{y0XWj^$LAh*EJ_EDrvxUR<11zsXIHSnqX zgJD<-#{ds29hf!?=<{^&9D;^h+L>>4FB-229YS`a+eJ=qV~Z6TPeZtZ`d6F)!-C z{TjL8)>Q^MRs)833IwGenrJVA&>PX$AG9U=e_DXLhXdgJ{b}$u9Q$40v8lg6oMEP8 zO0%$15k8k5GhQR*s&j8kK^MjH^-yAVpI9VVG$mFXI-MFJLS;ZpJK!>djnv}myPX3u z938F%l2`CG(*6gb51v!HSgE_iR_n7Az_SstAAkZ>!sEKg=nXEi zY!SX)@mCuPxvx*G?*-Q)QI8lt7Z?~iDSV*m6?#kDsOiDy`t;0B%eqFKWW>3N$=BP4 z!>|9vspKV63Vz^Z)VfI)Q51(RVY%8e3FRINe-=mW@DBuOrOK)3bw^p@Td{q*VjSCybai$5%Iof+(b%MnBOw>Jw2w`IMUA7ktSFU#8?nUk-LlW+- zC+QVo0*Q?Z}|GWMe4wD{D@IiO?3Pd zHfRhY(PZ@&XynTE;JTLb5MzVR0gW;-R^Rr{8jNC9a$zU>*f*A2v3CTA59~!ojDtj( z`9B6)h)KG6{>Bp7QgqA(mKmTFS1TeWLEpe>P%xLCg3#j+b@tjRS=HrO1GJ}A%>{(e z@`xGr0N+YQUV6_ig?t*0BpeQ>dn3dj)o5gVX%jEkXx05hOs6HZ ze3lElN6*I2#9I3AP|D|3?O{6ai%)<3@?Nc6A7Tts?#cIPi#Dbgw@E<6xsIFMQdx|0 z5j-$Y(@_??qdGZR8xEg293oSB&s)0mIPjO@xK)Xzh1vzUS%Hbe1=A?e@1oPAR&;2i;mUc#vO4vsCt zu`*i~L>-|tp8VY~FU^~#&b!;vc}nuGR9FJ!WYyJo95?zJoHykmQ(^rc_)1;KvmKq- z?`&dUFJq01TZnNmbb3EO0wlo(Wnl~R!6A$9EQCMF%vce(Bd6LsyGE!aFEghYrpt|O zv?R*kWfDC(I7y36&)~T`T(^Iio?bPA#t_Dq#T^8h1+c_u=4CA}qzkcjT^vg5p?0J5U3qJ>ab4 zebo{bu>FF1?94k+oklmFiTwT1xO9l)V{pR*Wm|tCQ+~8gX!$iAqkJ%^6DY=Nby^75 zF4C8VZ0|mxj`hiBzs)Zm&<$^^S2p?{V&Q!KhvnOs{7qNN=&8TL)P<-(lYj1rapjdMSzUe` zQT~7u6L2rDB%l3|S)8M6icf?&eu0vEEoAWqlJz@pF@V(yAWUCf2v&n~R0MH@yj6)1 z6*`HegZ8(eY6cb>oD$wqFDVicHGzb6lL>W}vwq$9i78ej4;xPC`(~t5=YljUbBrA- zJ?LM(GYLx6j@l5unlv(A`Wgg=MC8jrkx#Mc5H#$Op<~xeGLyTynQA1BG7ja!tyE(I z5*=P00E9%4>-8A7_2wMV-afS3A|@lQ0~s-aYxwQGavBh8e-RcTnWorH8a*kDpV}x! z{>#Mv6`*C z8?TzTN{!n@XL#_zW7Z>SA5Pn#djdv;{_7<#L2=?YjK4Tcul3YO`-GDWKS&3EAx&E} z57&u~f*Ml|ApG3-4rplUC?)Tfha#NF02_V*^(peC-)Q)S*|~FMmCJ|nvG0vZjF7scTyv=14&WXJF!6E7BWNzc~sDU)p>#|vR%p64>hpt4BBonV;+woUs_+`N{j?jSn2vzel)>kA3kFj zCR2Kwr3J3|gE9-Uk&+jD_uzjIJ`NMDrTCKDNuIgNk)Q?G%6=y$hj#TnbR^^`jibUJ zL+qL{f5o8%BF8+(`TLd(FY_UJ$B);gIDsMbw+*q_3#nT+Xf1etWUt)Dx>CS8ctjsM zBVf2vM-YxpO*8DV0L8XfrgJbByhsu@bye>o4OZ?3BC;v1z$)CYCo5x0WS3y^5f{*J zfWe0XRGg`^U##V03Fy8uz7T=3hs3yUFUk<`D-BVyU>}M%(4Bp2yLIC6Bw~qdWJGCv zDY}8-b$V`Zb9wL+*CImA)ItPYG(C;1o?lT2Apd4%pA}AH zQ6oVa{5CaBWN1?$^r-DM#{c z)^K8Z^#N&v3IS)i_7UK>l;hh}PV9kKnDM1l+H`IfqZ^zQB62L$NBE_iGSrz3r+di| z2#icn&C0oR2D+n^Ff+b)rS46CB6ckV3b>+ta^{1ve`$5ZFDsAQ*YQYd;RCVoThgWqB>|dUuny|X! z)$(76yXo{;9r#(eQ5mDLUNa-dSg`RTZ~PN^xGt_?+GyCiLWQ16qCnE}tF|u1&l-~6 ztPAZFOmHK)hP)G?Lk2!wcS{|~YKXkgjYPSu*m&KvNqiNoaEyFYwCeJ>VOTn3AZKjg z6K%%`##e-7s}~PEd$F2?OsLjB9w62Q00k4IBC2N5o(avdspeJc7*t2(<@|Ib=4+wO z+VNL)PejSh5*GjuO#lw1MNxrnbu1?Z5Ke^|KR(@*>cA+eC%DA!;@MqMREZOtdC73@ zD~y0-g}Gf&9`rWUujhVDDJ;*5mio8uJ5lY0@dr&<3uKU~Dz8@9yM zJd6%o0&7ON0RgKN_6FC7`KaZFq)spRAu-$Ni3B^5CWVlJ2g#6T%hN1n8|1!b%>C^sW~lWDikZG_uX zda0uj{W39Y#2kZcM4!8IQaQb&(HkIhHY3~E-cCm*RQ;Wn2VI*2GesyRo=`+Kdc?CE zizvSBwrvQ9&)yy6OjC=SIOZ6`3m#K-LLxgyC$jfV?kaU8zO*b{L2)kjT(3rH>oRX{ zQObw80^sl4EMXjYSD3vYx}y^XBRV1g>0B0@?zD|ag$Ui3Q4tQgpT|T=%dEioDjtr{ zPdCg2FlRFy`Mms(H!Jj14$u;Xv4xtEfA}y2u9eXQ%*U+O@gJ&^bd0$NXQN=o!m@L^ zt`GdIjQ5JY39Aab0mCs)!op1z_DP2n6|X_*G5o-4BM~C64A|`(k_j8Y(9#wr!_Ng; z{Ud~J&Dng_baEjIRkGH^lZijlSL^9-R^pp8{>eji$lfiiYR3y%GG)=JF_LoiM$3&y zWNImAH4&rn15CI6WI_6s4!8b$Jz95dlMy^6kXwNX zO{&NV)c{x`h)TfX1H0z9Z|iq23JEmBED30U^c$4zNAZ(}-K=P+Q_zhjpCI~Z7AAA= zRpf2}0{(%Vi$!RcSD<@W+Nx=G%RO}F4-bkewr-z2HlG9?-EKP8mkQjg<7D^b z|7?OFrtQlK5nRjtK?=awG#ZN=G>%A2f?rq9wI@)kncmWH8?cp}Rod%9qY^1Ie^?RC z@np_icjaxJYgmDGf+t$2I=i~NeFP`iA~Bl}F;`OQw52_$%}c{ZKJy))DyVOtzc~c5 z6E{-r9jK`;(83a%3|un010Jzm&2r55CnRY?G*$tPPw#uIjY{VICvs0HFqDr9Qx&vw z9-AsbRC3WVWVKn1s?VN;DlZ91R#|tP!l<5sMoT}2E^*g8TDtWS_tUL4#q{_nCjrBA z*x)4XBRbk3BR5whhnduSvlk85enSkorn8W;DM2r-etqou>Y`&#cPpY7_tdNXeqKhu zP6L0Dyl(l}=D<11K)sNgTz8g4FV`dYwnwQnRmlc%jE2BXqNL2To9@OdnNuz!;Y(v= zd;oBFW8*Pk z<69SdBS5~RE2tJr^R4Z~1sG~t@BX%Dtso#jH)oxKTQ3h%j zDL#5|X<4v4A&yV0^U^e^P8%SGF1vVxG^-lzqMi+Vp;yi_i?tX@C(;dyZD{LDW5UZm zoG9%91lo7iqA)Pd>ljshF?#^gtcw3jiX;*3w;IK*PvNCZ)iHz9D3V@1D3@$^18Y$n z>@-En_=K8%)^`&7Lng^CSLq#u(UblKS=7W_6gvt68%!)SV5^e0fzkQA2pZAPcnnI6 zDb1%IsF8|*vywfIB1%))=23J@F@e07Y&V1}63E6*I8tt1yMYr0#;(&_>irzzqax2? zd0sl}8*$8CV5{xhXk$Q;r!PxM2mK^WC3xd0c|Z6@(E}flfDbIi#)6~W0WlVR94*h} zM57d{Kz0X`eq06&UQ$Ib6#8+Z&u)k?yAC>YL!{kl@8=1cf-VKb7Rw6>N|+;E*sXSq zvLVJCF~KxfE@&}E{hI``!Y_{@{h1R%X z6=q7!(J(GLF6_`Y4w_MSLI6RcWmGRy%ZSoS%xuu_dxjQiHb?o$h+$kKmMAMnuCB9I za-9HlP%u5iGQ)xX)ji!<`-`B$nzqeO`Grui3({~gqZoCc&36b84jnvf@>P!(rOh5s z*x>*-b_!LhtbPW2(bE#729B<%1rmXN++gcqgXIm*}##lSuxt;>Dz|oNs0;Fr9-V zu~Qa4)=av*QA(}?DF~HEXIEkl=+`w8`Bvf}Fsk7VI#xcIbqc7%3(YAmSdny9|2LVn zg_^;SifPy9nk()kU`;DedP_E>^C}kebBs*KRGYYl_OHftO3jSK_BmBp^n>C}lNU_N zZ1GEC#ADDfAcY^~oVAH2kG$GHjR!XB@b}W znd!79aft?qprj=Pbu~~^*%u-a^P7`kRotQzFa)xq=0l(}i)!&qFo};Q-0yMhjPF_) z4#{IbyaoVt+3Rm?TPA2sVWc5J%PXeAKB#zg>vdkqce?J=cqA17rI7>-rQ7}*lAdR} zs(HG^u1!=aOrP*Kr1mfa8LK3B^1dSf!O@+EM>ihsbP;-Imowcy_a9_pt`BG^pRT%` zfBub@x^%iSG}W8B-xQ%u%huJ=!2g67CNO#0L!gp0)Is0}$- zTdr6ZrTP9l(#!Sts~>ao=VIL-curMMnC*)HlIr?xoey2NpOByaIm&%W`Qt%;WMI?Z zUk{68FNw8oPiS}Y|tcxR3`GO+XzW)=O=?6HZ zr{OPI|Gz6<|L=-a=u>7f;AW{VSFe`-zweQ10f6d<$+HhnbYvq0Hf4+5uJ-=_-%?O) zD!jZzzbi~H8YqC&E5yDNoBHqA2AuP40Ku;94ej%TU)sjM9xU#im7&6KH(fy=^J0FV z8y>>Wv55V*uZ{k^`g;ibc>VMh=6+C^?ZBe)quxl`^VMIn!7tC7dV4gEf8?<~40>|$ zm-Djt9<2pFL^s3IGie%C6Kk_)@Di@K6!|hU33+sCJl;M&o{x`0_#YmCYJ?bt1*Gc3 zUS1oQza6&mjQ<`rKD~0!$UQ{Py{2$e-b}pLad*Epw#~VGuVKqbvPh~>CUj-mGBU3i zj7v}T8mU*)WBpEUwAQRJm|FOARa8@OOm|zhDPOJDzYqPd!ss0JdpaZ z>mO9Kh3=hLDc(rO#wiR5N&U&Din2k=eHqjZ8d_O1Zk*LEHIhwnq>d2ESx~GBF+TC5 zRlXGR_#&t-#2sCv8P#!r(A&`OK~6ffIDY4G`k|4TyBC9`8q_zIHu-b7Qtj{~-KRE> z=sT@Dz6&Gm&oB@A3`tji*}+7ezm9sncpEmMDeh}jSLC&AJ1Fxe9$UsaVlC?xRD_W* z?OsHgbG(pZx4=rmMmlCGW$IOVKJ(_gvOw;L&rw$MDRN$m7F01FDVxdGkEZ%42|o{EbNTwWT81^8pXOV_l#+UJ+<@dRVDM$zFKL3x&MyY6IocH!6ZSrFKb z!XPNZGIZfrOQFkQrYuLK`E0HVT}C21>4v7uuj=q|ZOO<23eeSF>Kkoa`Se}HEG--7pO!n=dOKyXv-l%GnckSXYCl%t69Zk1dj(m| zswC@l+C7%<&+Rh%0*l9zL@out<-M~Qr$Jzb*k%wD4rqJ5DMRO_KzaC77ZFV%Iw|~9 zij1dHS?kqaMjvDR1$+qGC44CQM`9kMBz46BMZLD<5)}`{)b335^2#R;(EciwA5|B> zdHsY7N{Z5XyjpU+JrJuC0Y{_H$g^VjV><5tKmn1P1v*`;A5>K+i+u}~l7Ad@Qo~li z28~KLHD-f`V8np;5tZXVCw?wS74`VKYy|MqeD(_i& z0(epqSwv7z2bP-6RUk6_fnS9Z_S4})3`#45{3&DuWMMLtl4&A1%*@)0Gg#u_b3@%5 zoTXQE4ED)dr?dGvn6X1Lr`P>GGH}V*^C-Pe+J&IuEj~1=?g+HtT>IsLZ4=_GHN(eQ zld`p;FMgCsfrnLGVqY@YFr28*PbUmphI=T3@FnYN78=_o<>oV1?ecBT+!a7IU%XJO zbOikAO<5?*pwde_b^%>E8}}*rRLT>dFj`@`jS7pE6`;tv)yfDR%D4DQ&HX0MTv4b} z0#>dZ8yGMU^y$ZCV3ofKt5zpFpOV2EH@4_hWk8IBS!-vhp)3;J9^*_+8v@43DIzH> zWM4v7Ka<*4r0q6O(S+eBK%aUMy7{d4wcqZri)Zh5bM@|opY?C zwhPyBeHI;3iK)Fvi)55z+mFj_Ovv~ptP@}z(@@sRNACw(Gj`?4V@d)EdPS|HB|N*r zrar>nE+lsSgihlLK@o{46MGZ;!g9#?1eLAd*$YWiGWcq31bnWRJe?^jx7y~5Wguus zwvBes%A(Cv5x{j~>q%70gZEa~E~<^BsTWY?ne`LTE&)jjWCrK`b*tpk#PQ~pQ*WFF zuwgJ$+4V+h0}5Ko4)1c+4AYJa#xkoRIxis#5n}VO_6ogV$QD3OK$qgypJWJm`m3w= zGW=4xTkPa6sndzRS5S}BX?BG92hJIm;eTJerWs}a&?os&1CF7pJSM9)AGMT;++5OG zl_!N<>p}HvIcy?}+NdOu=3?qd#wI{4tmTEgNrteY7`Nqd>!2sSS%0`WFhBx;9;M@i z2ya8Cv0;P4wY zq2mCJqio+wYzC6Y@_U|hIvyhb6akkUqFlPkb(gsTXz!i5(-o8=xG3b(zzCX_YADUT z)Nb@S^^fdtPFCD}ZaEaft9FvEmrR0D(AmdXv)av3;YMGXi$ARfN5I)>^pGTvI=LAb zjXU{3a3OXb=qvM@KyH0;Lf~%684nzTk$bxVr>_f#*E8DFX7TbA#$>6+-z?XuC=Fad zR2Uk;Mw@!yVGm52uD<+i7;`iJ>AQn;=NmCkzddm%KsYc9RnD7~5r^F~tO}+^^wV_y z%Q-Rk1Y;iM$_u>+#q#h;O3+Z>$1fS2l%Y|r&$^;Vp>3S}GwF}-0Lgl^%{qUG?S$g^ zs;akbe6IzQ=9C0Bah^sm1{jG(Hg6z<>hMfT7N+c>JpFA0d|z`+?Es=kned0U4MR{P zFZjO%m@%(eEn0ppGWHY?5sbeuOgpU$S8dfW%a$oJNDZnD-|M=d7dT8KG%A!+%n0KH0S3ytyDR9 znD=3(tIxMc$dp|7w4yj|qqTfG%f5Oyor$fyi<1db+BMFqeYUlCSB1n1JmqR5rOh%6 z_RAYw=+lu5Y%2Hq`-oPcpwIc~;w|rkDgEtNK{QE5B-@*O<&DIG^6Fdz&bPg(L3fNq zS%}qZ07fJME`Go`lve^By7ajvj7JV7aCP1aN^|0Tpb2DtIf2qIA#Xc|w*_zyiXo!o zERb?DR)^CAB`osi7mxbUC{tBd?sC`5uNRFwn^}SIodKKChu7J$UB-x~W|OLwk zh{Tu508&nbBp`Z}ETy)_P+uZj*ePh&PnwaYl(bPYPA>sn@Pux`m#)}8BCulgjHxCj zBgWa!BCips4M0!RRiC0&Ts*A+&7A@P!_E~>b9zAwzjL9fQ^b!Hmx1KI#Ozx|LWzZ^ z@h|aNCaA}NVr)%)!HQ-Ob4GZz&E26h)CIoXxGaZ|2?y0AF=yU-r(Yx+ZNliejei zEBl`TSG_2RyW|$>xCc-o7}SHVE4#&*UJ{g$_=@;Vo+8-uxA13_Aik=2DP_U}=+H6h zzhIi&0K=MVJsiLH23LN?SU7E*(R-f)8gp5F1P~iZ=90%ZKa+ESB#I9{MFZ`#KQqv! z>XD#Bu|jkTo+4)b{D=$M^lqp_s(H;ax#xb}nz=5I?_HE-m| zB(2OQ@KZ-}a&W$W7dz4Hs$1fk0*O<-q8jYCt0APO;dqLbbzB!OH?pO#NcjAJw6SAL z?d;OAfi24IRAqCIfiJ7+V_x30~1TQ^qPt{vOM*v-F z>3$jX8t}>rGCwz#eA~j;a0Z6F|Re|&`dit+##}7QxEE- z!tgF6xw^b1(<|r;b&6Ok{)AC&H?XjciJWOKd7z6{nfiyqi~QcT zSE0eGh^VEz!uYJPTqW+We%US3;(P5wT9mFTQ4c=R<>{`?jEd5b=%k`)n9CZ-qRa^!_j3dLY(vcJ#*8z6)Nug@I8 zs6Y%{;vq0kv!@VGz@b%@WPQ>Rf%PZwhqxLvt!gB&(uG+$ zLGn^@D+C4IcKBIFM(7dKcOj57qyD0aE!1$MxzWoc=y1$dY_oX2EW!u4j4K|{D zaF{;AasJ{(REabso{o%Dv{A_5b%dIkjV}me4doPk=tG!yR{!gGH`r)#@?{0XopgS& z*(&sC&~UC8@HXly!YSUfC<1(OaKhT&X^~72-kZM!hEiY?0d>laqATuBd+D>GD*A zjzs@y)AsMcOnWIi-;3!!tpTg?Fe`>T?fd~Av+@{{(D}B_Mt`lz^#3|Q3l|m&ru6fC zL$F{@GYJq?{M@@=?>SK5b zzh@@~S1;%kKoUa|u{BxAuGcO=`O=FGE!U)2KoNv>6i8X${Daa>#&tWxS%`VhqN6ri z57SSnN9}5zD%@8d52aNyFLK6fjkE&4}|BV)qF4fO> zyFeux6pysHJ=mq+MUiGAT|FtrsVRJiae7yRdv^Tv+Lk9X4a`J#XVCH0<6xm6A~=`S z^sQJh`ksvdWGGyX{@_2@mkSZ=2NYTtKo?{h^kWpN9XnF{py8g1$ENQ(*U+(q2&?&$ zchfj|U|D14`TrDJCGpSe*|yvetC-*xWX4;uSz|!nA|y8p5YIGSxL?+y}V!J{61rN-1?dIJJEOw3YSbm-<}@YBDYnS`B>$4kko;_ z0raO03AHqKEk1R8@l@1)BRkJa6&?}=dBlIvms9xqKcY+V88G6E3b?^UzAc|3=Nv9j z{jMJ{-AVpQxijoExUxg$1W1ez1>M>IT`;+A<{{eP|CEbquZ7+N<)Y;2W$CuN9NI(z z3R3C0nr_OP`lMfI^AvB;AB6eth6aDwe4#J=b|>1FBI!sJzYYp%dHjrM`^qzRzo#6`IxBm0Quf^Mrf(q5DsrIkP;Ptaxd*>m+|O#eT-g1 zk;E)#+BskrvsX|qc_U3Gkb!v+%Dtv&F8n%Dd@j&ik;=CQQ%vu&cqXXIG&W~j@)XNn z-lrU9gkuVJOdt0Mj_Mr2rCsR>8^^hDPyhN4DCVoJuP7~zrWeT*8qArfKz%B;ho5Tl zUQ)JYtkW?pB?i(wdJ5-`iMGr|ymYnwa!6c?3s;v7@+$*HXQr}B@>$lE8H_NwRFByf zNUXcAssHA3|7C0JL%_R)T)7=>*1 zUERnD^y3YTTz?ObjH!*eR@z?2EoUw3Cm# z6g~fo4-p?~7DV_+xCE7GUT9rOKpx~RdLb=&hfnPZT3muy&L+f_9U8nyCs~cWHfoX3 zlJxlbPis-9yN@A80YsoY@#h{I914}Us$5Z6s9)jeWrIeR*qC$Ck)ciGB)z;#uAWTV9On)u`t&%fu>Z*)>FvVqMl83?673_+z0cu0RX(M%T`nC6fSY<>t)m13bjrd7`w%*(9h*?#yc4| zMM7sxpgpfnHb39`5cB=}^TjcDqR^y`z~}C%$8O(vms8N$Tmc&~v_h-8qD>6QogmYv zS*y~eNQ)Wl7_lLpXp%Xx3(S`28JSfRP~NfxSw^`Gtqfu&_lh|J|gF;u-W@Ctn6Ma@2>3-}Cp zY>Cbin4=1Arix`MM8w{GsX^$}C^1eRHkcB?mNB_bs?~;W^$vieJ15S#Ed5?w`R#&* z%Eqc=^Q0a{`|oW1N_O3Lmw%WxC)ClMTkHdD+?OA^EO_~;AvU$sM-Zzx!$Ihwd58Tlx+Md>3mw?>gv2NkS>CZ>q9-;R?yVkV_! zeEZQSv!^<{rXNdapBNFzh13q^6e5~G%%hx&YQQq)DEcr?D%vl$f`J&K;XAM)tfU=B zr8_F;YhgCm$;o$Q{&uykg8Yn3tcdNq`+mu7B^R9_Nm#pWJdc`9j6eM?Ul_ey=LC4g zfP=eVj6@yxT%A7dH;76xW_Uz=@Z|t_;5#j>-62G29!%SL`xQ*{moH3-)6QE!lYcCr zna>zj-lp8*D4e_{Lg#op*@e&{hh$M8fE>my%kbfH@A@n=G(YQt^Eu^V1mM1#NKX(O zN_d$Xav%(&XQ}Z@SB4SmSRffMHH--J9s04bl84nO7u8ee9{gVFz;cMt;3IS8G+n92K& zde{|P75TqwVqm}t?$prdF@53uK2-S7P~bKfpZbdhd8X{Yus@s+n+z^@fT?eq{_jp7 z4P53?cRp&}G3-3iAbo5e%5wjIpP{?>%=MD9%iDP1Hjmh<82)z~e>I9{2A#aM54*md zMU+4M_}A*se?Mva_r(``_;$T+t`&+t+E|lvs(w5S9+qm%v3J9S(v}9C+QZ-* z65$WDTy%P9i#ejL-|>i8Ki*E|CfqCAe$B(xZ~C$UNf-9u3wOWxuGO?mDOSog_l`U0 zTW>?Odg`d~!2LHi-l7&nmt0?%Drm?i7a7L@Be>|u{g{2vOG%R>GvZaIYRiKGisaS1i6DXA`ti7iNS)5S%=IN^qwnT;mKtb#vXut(u5dJ!p`7LC;1qkGhbNwM_;+M4yvBsiCNd5 z7vqM$w?p}y%;2+maN3ls9du66&PD59`y^Q9OCt#!JFgVvhP(Om#-Q!@@pS`d;`RzI zpZgr?{|{Vy?`J>jS!;dnd+nq5F0rpB8%P}Q zf~wI-9E-FvXgqtF+PvWM$c2n?Qrk2_LXIWzE7$y&;fYk1q`2z#deq179NRXw=gFT5 zoH*pzlEi}#%KNdtw|qTdQ2i)LXdm;=9Kr=vqJf9bk?$jjsFG%@l+Rp=>f`N*o0EG+c6hZ{>bIrjErRo~Tme+QVe?Q7_DCi%o}2_v zTM4IQ5}_mV4!kxjh{Ir2)(b)bC#T+!V?q6ieq#Lmb7F=?%V0863?_fj3D>9X9cuKc zZ2>9ioaEa6$`nJ`Yp1{o#3CMZg=Xy&1_i}d;m%wt#A{P1UGC`f1XUIYq9ehfrB13g zHMcK^VSv&|u0TpL=`X{=6rqm`QWwT#>+4~V(+_IQo0NDZlHN#BUIFo6XJa4D;^X}&uDZZlPn?)} z7$u)1@$_j-;fCgYNccOkdkL=be71CAbDeoY12y{JAB8w7+pfn)n3`2HeqcM!NfI-( zfOsVL;)6eI=*0z~!=0O#pekSkSuD2wLeN8L7!{|U!3+YK+%KmdZ)TakiywtLNDO6l zh6P=XCGk!VdRHsJV{0(bEXIAu|ie=dU0s z8JlXjyMfwT3P-VfYO#~0_43dr90ZD|dfXzZHVxAH#+rXp?z4cq$YhN>Use^4(;x6h z{>0T8L^u_ne<*aF1_w3b5vozI@?c$dTMtQ?xgzxqB$~!QGG_hiQIUTNe~RR}i@y@sj9|leHQ?5HYQ{2zVG}19b zy$DGUp`L_|M5MfG&d$7OoU@D!Mo)RS++?NHJsG0K{bPa@}1gFv9^ozru9eRKnN z(GNAU_LtkexsLmqG~;m=fh@5`ktE3=H$?_|=*V(UBF`Ln=4mAIBXN%=gsaLQcJs51 z7VHw|nQSt|DyymLa`VOKm-@z&7xImV*}tKVw=FE;Hxx&11?ZIW?IuucjDi}qN(;`) z!DA232}S3(7_qUR(J6>$8nY3ObHdhd29miton+rRj9EUs8=pkMQ-%glXikLk)EtN> zHrIn;UhXeKh>ty!cur8{?(o!r-5K|`L}4-`MypsfVN1G>>1~D&bkA_Za6iZIkUkT& z!E(t?`_^#RVy6<4BmJ$E$?LQTGb(+b33wHo9;rISh!;0U*L{@t;Qm0RN}(1*^gEF* zeTqG@@`v@hCM(ozmO<4xGKA=kU3trK;-QFHhec8N^hj%Y?wu5lM^s;=Wa3kqFR&x3 z9#G(L;NAGzWibpqne}3zjOV)^T*>@ia;uzgn%+4&QQxJ0R{s|e3_4mxe zJ`XT?sRLO%yeF|UoQu7v7bf)s(_kK7>pukIE;#Nvdkaox|6wELP6!O&`j|+gYH;_( z_fL!~!1BDHd#b;70UW+BOnO%&e`M5M8|OBDoB@^b&{JuxO2YYRKTUz$LmnF*sKAL3 z0{?ack_m#j5r-o*0_f~$x^#U#zc8CzSONP% zosX8#XBNaE*waKfnnR$$h*G>yB0#iijyUfYL;K>(3AjY~gV5?%d|QWS*tcvp0wAcx9@|OyWg~ z#CRUKZY@uUFXD0a*tTlps%B6^w%2o0h~t!c9HwwuEr2KQ>PLl3f7p7v3kz`Xrpvp@ z?y!7J&1uw~H(pr`steOEb$|%GtSFF|{@FQhEI%7O-39u!+?JSHD5ZI&L64-OXFGR9 zzF;crdkUNjQ`V9X-ryaQ{;Q>2_}{&Oni_J=_}U`F+4~=kCDkB^wBu(6nrjCd z)w@OEig6pAU+fENCEH)Xm~LagsA#mXIRuJJB%bV;rqhT@s!VtV^Hhep3NkRV+37H? zRy;dNGNLPx&xxwMY|-?vKAQp+A!h`iNR^y&1pIt%=yjs4`_uj?Mc8{99W*?BZ=rBe zf$U5X{5~Q=4$YNoCtAqC1q@@D?)+k;l z(7FoZBSa*?JM`q>9(~9ArHrA9;lEjO*PVI*XhGC7%hBNzu#lylV6n;iOo^B27R;|zBP zNsEsg4(nL;=r&@;I5zIwr_WART&x|PXS$ZBd*6D_vqQ! zi?jHWTPZ*P0#U0x%7uiXko)-|^aF~qOBt(p`^>ivd@D@2M2 zvV|2rjW8uihu19ITfzl+WOim0{O=SI$0s%Dro!R!0>9^bb1Uv{z?E9WV7~;p{0of& z*}t|%>S|O`s8gQ?3k&1SO|fgT2vq-kvdQU}=VJ0}(DmCUO2-B_>5`2w6w=sZ3U zh1kZFB~UTPsla}Ug=g)S2IGDvP3EO=LVf!Va%4PI<|9K1s+Bg1!L&G(pBM!{6z+Uc zyZa4@Kgj!!pHgnT;a}hYuCbH($_Hq@Xk~0176L-Xf9K_O=a>XJ8ocrZ(d)|JF4%aZHr6M+1P|If$7lS2Z!Hi zq8xmScNxuy%IA6Sn5Qm&D%I%FYJH_U_9-7e7K2`=4^<^3*v1$5;edK59L`(+Xjg?^ zkO<~UJo&m_J+(g5+UTQCGPRJ1pTp_^svP}^u%4D;TLcR(vh;Cx~O^2`^fs+6n2_iHw9L# z@U6%VneEg9k3)nqej+ruW2jO!@$Pn20;pfS47=sK#maS(A)yvF38pPhw?YG>FlNb`S1&ox#Q>0aX)^ zjB>zTZgaSMDw3ySQr%>bWgQS@3w&FIxn>ABM)J0m6s}t_ArL`>ck--*jCAHtanYvw zI>3(6vDeKRFY5u__gGG)5-VghR(cB_D?ok~gX?xdMeMipI$-1J!aVUqZlkLh758<9^UkVX6dL8lVQb* zCPoWs>uxi(h2K#)zfFa48LS`{zW#|CUkTE1&{c+ zKSQ+;C;1F@^WY!Iw>^61K}qd<>HUb`Bof`KW2`=wdlt>v&mQG3^SO-PK4MVAGJrB* z$wPa%;*GCQm>hR9GWua68|1k2euxAUZDr@}S$?kpr7I~TzGN%-f__X*t;D`GIDuiH z*+iSbpbFML1?s$ydYYJ=))Nx3F9uHlBTy=ToUv9eRciR(T!& z9=fqF3ZWmYk?mysiY6ZXMPKAX9GCwqD=^~MtD|ffyX5(M(6}SyCE#If=`U@eYVmn4)kJq!Lz#^dDxU-F<-lLTtxFt;Zf|>Wb(7 z;C3O14cN+dMJg@QfSN+@!7|XhRV$5kbU+R=DYR+c#xE&zN_MLl{f}>Z7w$tK(vz>qzUlD7+$zc9WtE`)Ah zfz{X&Z09=a(cN8?|4o4tIo%TLoy90rEc!6KzeGgTABpRMMO?fv3i0j+^LFZ|EiHTo zLe`tE;(-_IoWc|I9nV}*6E-yu!!<_IXZqR66C?0(SJ!5qi~6FHVz_`rKDj`iJniA| z!@f9-~vRf(c0}2iU>Uaw4uZNz+Kke=^m5V0hmc@g} zT^(63h>Ih^6U0*R{xB4nf>LJC%M(%EsjG#FWcZ<|Aja~{cL8}vyeQ5<WhXW{*Zzq%a_2;iTNzIwqTpAQp6zfYLx zjL40}k|G*x_|h7XD#XXco*-Dkc(=#9`sI*qi-#K!)g&SciITK8pLT1TJwDTWzs5o! zY4eDXKtW~YNkeq&$JG2T>)+Nkzq*ap5qNlo{kp{X!z?n6xO;CA${)4TkPNAHJ4En? z1brG2Hrcy4j0lj3BqZB0nO->m``lNMuo0BM%;VWO9!TveHN@3I6n0)-0o4`IX_9P~ z?~P~OO9|jL`0H5skjwrzb^O+L=~Lz5kM-X_5c;%Z8Becj(2>f%+sEUN^*awCg;_hO z_;|^OGB#fyX3M0WjDooDS+(bL7W|q46-YiAGA8}Qz7-qr8?=b`2HHhB*?TV~_eM=v(Cz&SsVax^7=zbkU(K8mFt0Df}4*ESsU9UM$fSlKLFI$meu2VrG#~r(Un)FNUZ(v~2ygBM zm6Z!6k*D8Z{+jJ6<68-Cfp_}E4k^?=p;O4g*!(*qVq?XYC5!a~V(gmyL!JjZ!d!P6 zY2ZoglJ0E&kzbTLRBwUbcu*H8zofYmI)Qx$^o%gg3lwCy@`=4b?Dj0vzL$yz8Z!PH z0Kv4y-n)h#V!n$hy{nQA6L$LKLW(0I2DyHDVsG19?f26Cy>!sU1XT_E6%$ zS#Z%OfnJdOT?Sl7h>F%9QZa&%w4Y?fRS7txfauk_4uL|EJ62JFF(s&Y9Ubqq9W8s0 zv(IMas>XhK!}~AnPkyI<*z3lI^WXe@2hcUgRI%qI5Ia75l#=quxyi2#0Bx4KHwVW; zzgaSLI74k?^Wwu4YLi0C;#pfqgLQ7|r zq@x0t-)}?)NZF&jHDQ%P&F!F#I^lQU#tY$#qmu7blMghm1xB1`2D1p$997b_*CvI1 zk>VZIYntvnd5_5@cN_EI8IaesTO}%fU6#O_J;>6tYvVE>>?R}w5GGC+wUEY?Y-0Zx zaKHPy0IQD|xarfBDX6$6Fld*gb+3)r#TdTc(@tN=*KHbOG!~kCo z%uLP|F6w7!&*4{NV!GE#_mGoBTPpAxr5&9aYYo-@ED(;w^5I-h%x`C#k(y_`A?IPi z@1!|;b|NNX+3IdT(rdN=jvl{-S zIE4VSJTo~|S7p?`N2g%hwS5F&y$djo(Xd1jJAHHFQ8_?`Z-|@BFJc`iA7NDr?vf=N`@O2nc34m7|sQ_aV z43!5XF4$lC2LUJM6rH&>F0F#s_9)1Qf51h|UbOd_+aKSOS+&x7Ab~xS%bVnnwJX)a z-KD;|x{gUb8zk)-Nj`j`=OK}Hr^-TMa=`5HBcyIa{Jj7JO-_(sWf<2Byh+xOfsQbE zDb|E;j=GHJOGy7D^CWZZkhAuPA^~-4^xahR>s)wPDze2$bn$uc0HDG>^NKr^d?3|gUXy=7mDGBs) zLa88|$IybC!P3)@Ft#2Uz{Y}33*sS#ssei%Mxy(m?XU4)9GMq@e|XgE#aSPCcc=ae zOcxv!96h@uhtmU<`XAVH!wWNpe5O`!@sYd)Y=X#aOWC=$zP}e7zI7ou)v8|qe=bM6 zdy5oru+3jsZnxcF*M_7nZ$rwPeeWN!MA}m1{ey)ei~y=TpXEC*IXo-cM4arnss34# zp=oQqoA>P;@cnz={~vEmyhVp{WP6sK^LJ$vy@R4R5z&b!mLWrFn6~bZB@F-2U;eB1 z3UqVL*H^^2*Sk_2L6XTuZ{?b}M_75A@QT=oQBI{`sT*X6}vu7-cggZpI!|VvK$!lhjRkrxa&P|onI9Oq%>c03jr;1y1bs$JC(OrW z{RrWa|7faZWc$yq=Oad!125*528>&L+Hd?=SMT}}hq+we*$Ph3-fWu9+hb4-*)UYG zI+o})XdPf}xMSRlPw~yk?JCBrR#q3`QQ$-tEQOZNn55BMUCZFDUzUvLbWj2_nN0(9$BTL0r2JpMHelzHvI^rz<{|H52Ore-$1Gkx(F1{<@$WTR z;|ihHR=D~{%?qoz0yl}^eOKcm_);)-$IrxWSa$L_Ii#90cY~SmKlz?YCs#ofw2f6g z&G*EpmBM+qgN@C6UJrpH8NYdau8+{AC)8>a!x~{2rG>i(Z^!;lO?syvmIIEajI%w>K#$0C}Eud8wy==f;2Hw8xdDJev}<_ z(Ct-r<8de%&LznjlB^X_LHYua(+Y)Mws54MEA`X6>0jZxd|t&^fXLtW0}9%r(mcJ0 zG^CWhC=5^VCuk?Ykg~4&6WaFf1Y%FkzeSV+JJjgalmPBAZQFu*=HfH|;c03d-j*Xx zu|N-}3nDnl{&bpJGOd%v__8uJ*7nYNZawrq$AW9POW`{l?R z|Ir3{UpbK1t>0citKK(ZUuLq_BZ+B{0JG1T{rC^S@s{0g##>YKf9~HxNPX-wL|pK` z-U#NYz>3B{3Q5LcxwZBzxgdIfs6*+a!(S_J-;+aC{7ked9w^K&A}Rcig0=sW(D2Ez z)@+i02Udu)NW_En)=A!m1l*gxyxCoQaTfw#gFxT+3Lue$Q71TH$xg_p#LVS&VO(iHIJVGas_&EL40*Z9n4?t#^_KL4zb74QAI;QYL~zNXh#6S#IvO zmV}H*${An$yOk+IN8W=LxL$a6I0D8^boV`dRbE1L*RRtoafSCPbE7OBbP<@7qL@z8 zGL<`c8LA$PknxQ3H)h3$(%XJ18U7ZKSS*D?xVs~6B<@-kxV=%h^Oi;CS3f;GP1!`) z?s(SoV0>&dBZisDEg+Q)3ztBYSlofooL<;?5r^|n77f>5He216IP}^JBF(}_~Q#V19f*|Y>b8) z84n9T?@TmcI)lx8D#=_USoPE(Wuq

A@1hwuF$^Bh?7sV2wmJ=n7e%$g8vnSJzSbMR=k5nCQCJrA%)xPgUM&g}=)c&N_Ve`bat`Hkr``eT)%PntgV#{E4b%OHeKGl#B z33GuyD#q+9H^8F}Q+u;UyA;-}QqS4#Ckkhcqdp{eRxCpS$TItW8j4xUfRigHyRoKb z+!9BA_+2v<3X90{dQN_U8*5zY4p5`oSaBIziiF>fnedfpQDf2H+?}=w;j4~1YbHXo z)4yU5h%{{W92BnBdiay;fAFDn0t?xVbR078-15fD_QHoF1Jt&EpM^yqI-oMv(we(D zy!m8=3?38tKX)oq7sS6pFj!{nP6x*Q4k>%n;*XD1o6i#kT z>$vHQf=+$?U)}XhL`JwH&&d*#s+YGFs!GRN=)bTSaATKY)_(F4c z6 z4IXp#apf9OWmAr0Osl9s(W4BWf*3*9OHvgfN4fy(h8gZucZ&X|GrrO{L6AUAiz1GSciO|M3@n|lDx*l6}7%8Fp`Ev|fGjqi<8hRX`pk5s0q{+u@R zk+9gRha9PyEW%N!T)Q>l3p&lK{!=}@q|xWNGYqO-42Eq?mAw%+gO-cLQ`wQn~La&0Yiw1)x*U~hOhe!dH8`o+Me>=;j8{^Kj~=$@=?hJ^F|SZLBQ zj!K|#(sfH78@sJG%lyF~(kRM2<$(4in`utz|BE5zEtQ7)L3qlbN*l9)vzB`B*t*ly zfVV9&K2;fphj#IaGh!?Nf7tiRE6jNl)ByL3sGH#+tpAjt#A0Qr_sB$emg&%nxjRj^ z3l&{ip1QDGDvqt-&G*u2B_{C?KuF2 zMB*B+Z@(7~FNaT&4$?g4rBmR!d5OX3@Q{2^FXcGaLraf!|2-XZXNTkd67($7T8wvdVq~4;L@+wCAlRu&%Vx8NsV3k6dN7%y{H9*7z|qaWyN5<)LSNCNAu1w zh^R{WE?dt!{d8%t93Ts|b-WFC6D`~_u-Ff%&LK~uoh(scwXKXFm2+3C0+J)V?u`Pr zk1Rls4(LRqh|jfl0n}NB`}OrI?QB12mOgM8kUlXMu`jrCOk7JP+i|>yXsl(~4lLd~ z>vv>fwp+S%wF`X-J{Qt+mSV;~>urmMyg%a{?tJr8tO|n>rcrN3HBMw>;O&%XF zN!<+!b?Y~iJ;(5bR&cLaBGcQXK#f$9M=7qarHC}7=p<#5pZvMYmd!@0hZQDDQAgnr zh+5vV-QcG?Mm<&A%i{RXTx94I=+PX9;_{;SRv8UWIytEitB;x679R5oz!&FQ5*_1- zI6gr?q52t8FIRbWdA)GmweyH?A}B;6sO{!>ef|3Sn)nxIV8{*qZcy`02k}YUQ#^lW z$D5<;>-Fn(dcEL}HVcGC6@_`&%4!lxkF8u0AuQrE(C z$wkQyC-z4D#j2%VCXHGMy7g$AaVBvC{_wFY(rio}GLb7G7T!(3)iwoW)aQQwxnAE? z41>8ET@Hz|!Y)^3JRkH%y!C#0j;DX1d9Pl=zLa*{tCyl`b?P1ZVR7j&Kz`Osz=A}X z-}u;#7&<-)cXYosJQ!z&Yb8Q`>SgSvi*AW&$!aAs&f>if%6$`=nVIpiULR87EJdNn z#eA#a;N0o5xB^MhL#wq*Ndbu&#&widS40>mpoeB(_N(!b{F$?Ty*dRztYiJ}gjG6j zZLc!r7<(+8JX#_sJU%I&AUmT+9bQ_OXZXEg_XT&5XM6!034 z^j`9p2Z|<}@?`+^Q%2d6b7w;!O?sD-QasOoH}NPr>cD|7zVgzkqA*kH?s`GY#jdsR z#d}{Y>GOw8Ny>dNd2M+*R9C5y89x(8O0`?jb<%Y}SElRaYH#zZMB6gKGIzV}9&_$a zUT}`@Zyhn2dAd(KCwU>V*=@gU=r_JxMXw4xn$XD${;MnXGBQc~q^$=3XyLlAt4sVt zu=Hh6>kaCt=wkJNe(Am6;Q=py`@WoPk;yq5y>-mx*ir$0YWm-(dEmnBUrjjJy&+QU1Yn@?-OS<3c~v5=x!r=4GOKs zHb$ecId)LD#wIm*OKDZ$yO~RdfUx9*r1N2#FX7e<JU-kckga)nHf%kFx#r|Z5j#A7ExR=hc8IK#@N~uf`q@yp7|h^H z#}JmjfDc($sPmP>5Gc6Y>C<&^SU;)VJ@n#O!qK~fx>qfUF=r1es_BtGk@=im^*kZ7 zTrIkDJ^KymVPa@IBKD$gcP@-wN*NQnFKjHqKOv9O`4YW~HwWTYv%xj0Ow?5n;BMO8 zH!kG^P-1UW8Zz_ApgV06Ln&BVLG^%?!ilX>5NA7o2pwDS~c(2@XI{40G8 zpG>2ld(u8%+_%T_L<3&YJ@a}iI1<`o@;rAkJJl1n&E_$Lz7m7rS;=b?#5aO|S@HF= zO#lZ=3L2{^0;Nr9eGFl9s}9#Bm*Iv-xQdhTaA}H z8KGAGUKpB|T+S1C8GZen?ZjO#F2RJ-x(H2hn*}S zb{Z2rIxFRH3X-o`NqBqXQ`y24^kp(cH_(r@o$cgi;Oa?#G?R4@8Q-W~G*ZuBeE%7d zX)J;JVVP#Mi9ys8gRwWhlWITmw%AbGgYj&i+1Jx6=YXGA*ob*!8d%fI2Tvzx+3^G% zYt4^G3;t+Iba+wK*i0q}kwz4Qm1J|E{p`Jc*!uMYFl7)^!Gmua2F0H*UqT5?3C?AI zDn&^_=JXpx$C4HHE)XLpBNl1-y&Wt~+1CPwN)6lQ45I?$I=uli*HkO zbS7S%n)<$#fdQqjb(juWyt*1Y$9R#nec;-cSu3W|ElNhNSh06#teEQp0j|+Ri5DID zLgD=xXlB(1grZy-<8>zQJu^=&7@2v6YZ$26C)liXCl@r*ep%~OKn7Tvf(Nv<=Xaj^ zy|}1L(`ZPr6{WCCDjx_Ir?`7({Qyyl&h=T68WV}U!eV>RF*1_pCzjp>BJ7nUO8^EC#@No&z}Lv( zAwZeo`YMe-jXv=E;7>~S-UEb_&hcOolnO@pMxXSh2ggXUWH#CKPn%-47Y>3{lYy0R z>!D}ssxQ0TD#Hu)xIB^c3d@`S^cjdrLqWZ>t-IuGe$2SolXkClirSKZ?hG>8I!awW zF8417ffZ%ZXwW3++ntm<tN~UZo;B=*|8n7dDnz`OSxNEJ;fI~$ zPvU!0cW@U!k@gI%zkDA?*S!9CrwLol4JPnFT8HL)03HF47Z(eads(~$EE4n}Ye7?b zg?K?aqJ+#7H-HDHIVn;Er|&I%Y+gLB6ZfZ(ncd1b5fv6~O|)#e->)B$Hgz>5^wD&0 zT7&#^6tT`HIjcK6slAJnEg)8sDj1zu37GD(tl0W*I)xU(&xctEy64o|6izzB>mOf% z^HgvYWdrB(W?#!;@El*M;X};C)8+z*@p}#sI=kIFsb`N7ms&qcEDu=&nb#Q=`hB1k zOaqN0r%3R1a<31jdW$Wq8ZwZ#bX;2aVk)chiApldb~?JYOY~Z;z2v^$_p8C3slT$p zApxDfo1-oD3!l8>uprSY*0@*&F?PZvE=?vzSsv7oBWI6h-gs7uSh9`5ddBgn4Z(*d z6Nn_eHZGm72!&E$6KgV2uNJWC3zpPPOB}b8#gW^FSL+Tf09d~||oU|9SV zXd{xUKnPaai~n$%4$Um)Py1%I2NpnB^V{RN6@?yaLUU|%pFx#im!dVL|^#QSH*l$0KRl+_|Cer4@0 z1*;lHwI18aJ9u&%y!LhQLS;mng0%=S+muVE*l&3u2pMTI;B=IGk$=jnHo!I#ygic#~hUBXf+AK zh}0@MC^qFV+FGw0e3d{7@7)h|`!OGs#0SkXfRB!vF%(pwVM+{a2Aft&d@f#mL<=js z#f0?(9K?_{b~<#6ChT)NXsZ?tq`lOc+%%50o zIx z{!8(zvDrlJ+8Xc9q92yIxgkkt7t5uL+ytdu$m5F$Gv|6MrzmAe(d836hFBqZbuXqx~K4Slbq z4-@5%ONBU@BsIz2vUgit>JB|iH4lkWI1MTar_#k+-(DtbMrK5Gz zPcDCb`-96G<(4gX*>AOLXErVIs z-z>daMZXx)9{C-78L&vH25gfh!V$<-_lVkc=eU|>+tq25TceD0xIb<;?Vkx^G2nrd z)oq=dn5C!kH+gc@UAvoo9)2W1F5P^n9P?+PV^$D$I->K-E?O4H^N68V9lmLF&R%ii zW+K=kUVK^d{BV_G<3b4Lrgo+dAfY*yNA(QriQn>&H#E4rIn@_;^G=Jaf8M?HUhJEk z9LV4`lS%v_)^a0FF@-+0Njw?hb2`jv;PTuxo%yZ%oiA6VlN6lG*QxDXq*UHI-Efg0 zbXRUKB28z1dQ*6QI3zYmGs6Gn|M_8QZ+W%l@%fGF#o^)E**Jke9H|@=On5VUveVYu zvqS&cM4|%XV`$mD>|!N6NH?YIYq@p5rgCp7L*Vo5{etMDG6A_W_l9ap?&6;#0{a9V ziI%~w0qb?AFELeX2aErx_-jy$z^#Y3b?fLRrQr$3+41Iy(aWJtUqf|E?uiWTJh_mY zE497!5s0}O$XUhm)T_zh=DfmbaR4sTTJvEocrOz0_r8k$n(#m4?`{+ra4a*54QEkQ zmZEFFHeKv5O;@`CvrPED`1v6G_THAN;{t~2`w!~+R;w*TZmMoDK0Q)njlbP`BLx)JEcepOR{xV4Fp~R;P=5W5 z^~bWZ%Q?3Joo7p}AAH@esL|$k8aX*8!;+A}dasFELmYPV z%s7CDdXogvH26=&@kwExtok|1S7Yl;_H7rpg*f->-PM%m_7|@Hk5-~(`~$m*Jy@3P zY%fw;KP|8tt>9VaznKl=v+jxu&&xeg+o40T&sb>Zyd*G5OCgP>Wbu~F!VTWW9XW0g zDnc}GCAda6vMffT8(J2UwvPQM%glYKTy#9tT(2e~_0e|KN&BNmlnF;#E9uVmogpN~ z@(inwAb!7Q1BJG-Sn`j)UI)F;r?>LOfDivZNeHJe*i&*d7YXn5i3Dfo ziMY4nS$S35u~5vZUh!(1I8EC1FrqRRMA#+EkZf0Omom?~(6*%~47b_{_|S+sP;JX7 z{hcEW5R|mdclNIk3NNl310{s_hyS+7(EcIBbXrDiY-3B5J8k*m&ksd}p#zMPpG2|!f>#ib@)v#;O_X?>sRqT zaGXLU?_%Vn!BhG2LIZiOVfvJHZ^Kc(d#c$gRn}axYz2{@Im^lM9OD#nsSNa6BlN^Y z!vEm3;2DTBbR@2*y?F{{qN-$y-%mT({>AR{KF|a9fbPY=-fL1NJz%zuhJ$D_cPCQU z@9B?kv9T-x4hg_@oTbCImp!?h2nVAD#9>yz_bq3$_ABy$>ty=yP|$T}{6A?fw!v_gpT z{9zNpOI5a}374FthR|K0mLZW3chu(Qxtr~2EwS|XQ<8zC0|G+s7(}C!&Cqlv|Mth{ z1S4{ddg^$M-!fd4O^+GJviXKw5~ba{`{ngTqEZW-0hd?dJ4Zo8eCQtg37~KYYK#Rt zVeIL!)g$Bq9#D{qBwv$_JYW1gnR1r= zQUQ3)8&EgQ9rr)w=;}ootFk)1|HCdTP!MCWE6e|0n1V0eL;0#rlc2Kb{3Ca1!OJ<3 z#dDhN2}Gvh*0bkHe12U9j0&}SuDC>A5~k_KmKI8z&U}#Ec z-(Lz~Gz_3F5yq*bqU4cJcEJ+}#h-=(U6%LY86?qR11kR+^~l<7VXgoP8Fo^-ypgz_ z15*qyeC(bwnlEmA7>Me2i6hM&Ch9U>nYmM&ICLSsD0;+sSHvvslMo^JR?x5n2pZrT z3qdR#ZQi=v%jar_L^SX?2Cm1|Xlb@Qq_+;$c?-2DsfR5#`_?k^%zdKcA)pKDfE&pV zFAyL*x3hrd*W-)Sc$_e(o+8RIF%U>h5Q3wej*MnhoNIM%q9;a_LbWFMp&n;ah=joK zVJKtyIdwI93bor<0eKS@YMRgu!h&HF3$ThsnMkFY(J^#J-Vmk5XafQPMb{56ot|)<>Nj75aK){eI}^yBcaK*d7id);WozEyhql zkw|X+0S?lQE2ZIv)$_xfN>inOMlJ`F%kXQKcIW{1UVtw!WL7h|_F~F@8>rbSP^bL(yY4DjBc(R?^A2 zxOa~$CMFQQPPVvcfwSBo_@FxJU_qr_jlRKh%cnZa8|<6w<@D$5n0AowhHyhAIvsxc zC|4!me3?^OXICdaNkSz~74nelF6t@z^xt3xj_lP`T2KE{MgmcTLp5=fx~3FjazghY zn`GY9lQ9zFOZL%hivou!F6LpGJo%L#?gvO7RGCdL$pG?Hf08#o=?)_V<8B&y!F8>?0ol@~RPgPU!O#_meRvcSXE)^*^D4ixyy_uP%zV zdB^SlE&Fk-?{d?3Js5}RL%=2ii06y{co~WWCdRW`B<=Y`7!PF=Tu$59|B@OTkkSA9 zz1i88-UH!dbu?5YJz3c()8W0^wog#L{(a%A1R^Br+yIthv92k0lxnjgai?FA;R{nk z{})H8@VZAgv9cJr@ zd%~$G9iLQa`<9Ag_7=rjWIg)~djSmEL{e!w_N+F+&rPS$_tJ9U;dC8;W4d?HNdWc+ zX6eYXwA_+1ryam*n_LbLpGLf(43nGAjFYT6208)eG9z|RrI@a|91K|2qot^}@3MV2 z0DR7IdWbk^ge-a!n8uUA1X*qeB=RPAA!#rr{vs{@wWQLCRcI(a=K^@~*JK=#~vjkKNvTulatYbG?qC zh8MT0b~p~&15W38%_McF4{zbME|&ifRp%W~_51&S$vC!SWY2SK*)pOyI1VB^BQmr1 z2q}B!;8@w&Te694S=l=jvZWN23jMC5-rvvd_ivmWuk&(U*X#Ls+#e57)OSVwjb5J{ z3Hq)?kHS31H09%pkh-#zd2srHjGqxS7%Af=U_4m;436HL!l+j0y1+96L&kiMsC=kg z5qL&-H*F!{sgb4|+7maQVkC0PJSXGYjWYACmaBF5k$hai44Gwd?BR0 zZyz1^2&pb?Eb-Bsh7-ry^a9(wSR!_yjY)S%0ATG{bP&!+%HbMQm2Fk}#j_1eykS*^ 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�Yd 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

p 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 literal 0 HcmV?d00001 diff --git a/src/components/protocol_handler/docs/assets/invalid_cert.png b/src/components/protocol_handler/docs/assets/invalid_cert.png new file mode 100644 index 0000000000000000000000000000000000000000..e208e27a52b0768a6b757631c3a03b03957c07d1 GIT binary patch literal 57118 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 YaiU@Ub%&ke<#LVtbke90lR4k~e~Pgz`~Uy| literal 0 HcmV?d00001 diff --git a/src/components/protocol_handler/docs/assets/invalid_time.png b/src/components/protocol_handler/docs/assets/invalid_time.png new file mode 100644 index 0000000000000000000000000000000000000000..c9c88a5ed348f084a4d2d11b235d037e41e20410 GIT binary patch literal 52580 zcmeFacU08bwk=%Uw%WDMpB|6p3{wWseCBY&Y^Q-9}L8@ph}$1UEI5B>gW zwcE_2vy;kW=jYUF#A_&D|Ks75gR>v&$}^~bcTbAl+H5RlefDILBjbL{=+w=(?)K;w z4c)sdd6)Mm9LKkxb4iBp?|*+l{_D1@VCvr=FD;zS`qQiTY|e4{`;(N?8KQ!Je|S!O z=YQg@`!0xbpPirN)E4H;J7da)425;L|)vVk;X=4ZTGmB^Q*GXUa(DM`J^@h#HMK-RD&yR{%_(@qm zstdT+GMlw%#*~+NA)?jPP5w^3%j8ur4P3wJdBLyv=wTkuNrpx`#+x{D6w2L8e#O0I zOPS&KWBlmN9+IZ{cQ)cQp7%a$txL6ZaJ6*bs572M_uFjj*)eqGL;W15z&?CfSa-*@ zf$JXzf9>)LbZ2LJ86E#}#+1MB+D4t~%0)969>*K=CsE$3Nis9CsK++lYweg^vb0@(+Q+`oMJqJH>rgrcCU_^K*{s*S1dA6^$uU-KbIC*}0rYuB$= zJlfBne5z!JobzD0o_&4T*yvEWi)UMGyjQSKvRRdB$-~|I&*}_pG|1LnwQ7}VRczqT z=g+0vv^^9YYgKgm?4va|JN9yS-kV!O$!9+780cv8c)^V+8i z`&ycA@4PZ=_i4sV5A(Vdi8rhxT4Tv!_)|LPOMbFZp6BX-3u^Zq?w5%&tLU?2Y}-Qx z$9u0h4b|JLogLesl~t}q4_G52qD7<83i9=xyOP_n{nYmFx6JIj>@HfHW^Fv2^r+!7 z{|;;xsd$>i=WObcfz+l2NOBUlISZ4KUBv~_1LZ{dBpjQFyF%zf9`ZP|_2 z!jqEJUtZx+dD9jCF}-xGZ=Y{7#V}h!C}qH=CS0nIFUh&lyGBxa?0)mL^|9~H{WQt& zepRZafgTQGZCYS%bfW5)y!p}B`{uBIT52t|h*d1zv0;%>e}i*R7$?0WilNfKcjw2= zo}cEh0xLd=QY9s|Ix1tz(rr7EPS=Qe2*_#Y`rT%HxGQ0HC)a(^t#`%y{Kb`WdB=LM zP|IIjnx1U<>bH9PM%VVrm;hRTh+vov?d}6nuVb?FR_}9TA9J6Vs!^45b>0d05*}Lb zq>YE4Y>U#2Dc#8<7y9tw@lvow#d?1(u5q4n(aT z8hi7YK|gTPd;{*IzW#lG3A0Dk@jkCPE#`>nX=!P1i;9>Yv6BsH&9hl*>jS+exv?wn zRacgs2x8`pDrF39yz3fL)+1Fa#}snbeV)!Mh^!>$t0u}FVsKrDos0|peM&n#!^Y)H z*3Z0JywzK=z+UrK9%p1~i;&9wa(l+8-dNLA>Yg{|;+0=M=i>w~@W}JpHk5=YCOZw7 zESb(NA1Di_?J5gb@!HyRN5`T>qDnX9 z-o3@e*(Lj5@l9M!nrRrziXz(RKd&zR)@YJ?=4$U_L)mj!SJ`);2+zeDWNn?#!U;!n zI4(06Z#|ghG_beLHm~$|?(;&AVk@@$3U>4FhS`a_UTkmiGfmsZIvC?-!;Nv7U#=;5 zE{>eFM0yRCYA|WajCZ&}%V|s%`p7Nej83s+^Eyp7o84ZYkt*Qa8Q;r}U*NM)-(mZO zsXUrUiWMp5Iy09@i@ThmJ)gWVLMu*R+VRWr_oML+eTD<=70Mg6lMbd@)Z1{!h7>uv zt&{HKLPsik3B1kEFZ0pTkHp8ci_qEEh0{LGO+HFoXR(iX{A z;a&=YM?~D=Y4r*k8a_qxqo+T&v_yr5?xK%%7_6XeDaqT^z_QEVn7Ye#)hKpNeUo{O z>%HcBuk9D6M5+YIm#BnZ^5B;=efMDd+rmPP(ZMbWlhTz-q|UDF9((=f%~kEr4(ImB z@ZW#^rN1paNa3D<)63yfWf7$Wnuku|vIb6vyq$+*;HAT_I3vZz38@Qv#&fiF274Ms zjNEC1i9t2l0!scs0@C)~(RViLw7*>+S3WY(5z_FwuD-JK{YkN6Yoil;3wY$N1amd` zoR-LadA&kEju=Q#5Ak-#dOh0m-x-@X&Ghn zkH$Fk%-oqe^xnES5_fXlnl-2TJ08;ts4l}#_U_$V9;Fr6o9ZgTtd3lC4H8k^$OT#gH z?h?z5$}5>y1i0LhIIgO%u-@%kw?e$Vz5NUrX2yDZnB&UP*CX{8US(5mINoz(=XnWg zU758++^PSRhNk9Q-gyH$pY6P+b?O%tRdpI0PQ+L*H8*zA*;PzIX`4NGZK+U@%R>Y1 zNY&f7Z?6q^)d<~p*uf*)d#*B8FAD3R{l0VeAr`anrDbQR8hz^V)_1|$sTP4-%xgmx z1sqp?Ol|M5tS+WZu4@cWCY^# z$SVND)UhDT4o;hbJB*qdTfrm#ZMvs|VpGi0cdZh$>f+4TGZ7W&P+ zcSWp0c1w_1dBh>Ut!EwpD~IW2*j;MOsbXx*@UqSvz4_XjKjGNRDJP7LJ4QObaMI++%Dn)1rG)bHY{bitTQ>XMMoI z*l2(+)qiIu`-(tDZg$a*xgKnfEIFAWp-O(PWTT5(F7HPD%<92`4SMP7xxDpOc}r@a z9J@dpDGPdxRN>*twzEi#FSZsFTgANc;!x|P=+aWvWQ%(3otI~n40hEGAWODg7s+Q(KG>szb#=+w*0Gtng&O zeV^hfJuO2y>YJs^6&3dmGdep*S2@=m${bjI(#@A+$SJ@gl0wsQ_adq^>ixJ_4Xr>{rTBz}<2;+LF3xz=(R^1p z@24CWvje9)BHxF!E91U$8Oh%!e0l9RZ?7m!)l5XVV1zT8-z}F^yWXk7QZy zVX|grjP^K~9eF59MIiRov%5P!n9492>aHhPsUk$t%dIgzAwzhjHTTFuHO9A?KZmum zabE_OL9a6_JxFoyAlVth`US-~msj>JQe5Xrc82K}KLakkg4d|OENEQ3yV#RoQkdg& zD#&&4uDj?6j;^ukGnV|NOPA7zKVCP|x2uZP6U#l-{XWgAr6gQM&||Tb*vBL+M>Q!a zsaha|P&NJ?2M&13kF&o(|4`=5uGvLxlEZ2nPFiT- zawwPAmD88^p=_?>41U!i$6I{k*KUubo*1(7w5O6YedS`oU^4@H>FcCyS`X&TinMIZ z=G$`maL(tbs3;$7H>~p`4PL1YPRc;7NWnEVH9&)LBm(a)IOJ`S(UsyR8Pe#&@~BO< z6l_>j?dTyXK2?UL!n9rBeX78+v#TbJI=~Hir(>BF_VJ_PKzF^4f$M-zS4Ue}xR-*L zz!IywqDHym(#*V!!sGW_j)z*4m~ENOek7dPyW{ic&$}}%tgWp>#y4CJ9C#Rj7OiRS|~lc#3yvl3We6eI!oV`9!q4lWQruS=G%DaVX0~r-CS>;F^GjtQ>H0eHL+LDlFJ;eHWG?@FnA!9CEQ_^S*n-nntEBlpA* zYnIHYrOd>loc-&r=$~+Z)v%J6kGtQkw_Ua%V<^a0bf9B7L1bR@MCqL2KGV9CnC$Tp zGo^6P`9-pS%0e9vJ9f&Ziie0yEU1^yLH3krCWqV4y zMRgEuB+^~<5O-8&+;h?d#>``Rxa-6UWZ1N$b<_Hf6jpFe%N$PhN_Z!IDD zd%;HS&?-Vx3oHq1is`oQY2s19y@N*f#T zV@aR=>59p*JXFrXTwe3~bO{&j(vRJp}R+kbIzk&lm$cPL_i6rj)?#`Zg}k&auCj+JKi z@ZVx*zU&^CY0$Q-(9nv+q805?4w82jH!Y9oWhg5v+rC-lyGzfa`pL2M?(~k8f3fi5 zjwG(;)VQ>&l)0d;e*5N437wNizbIn-7c0+X4lBsvs*-zeWdC@ejJ<+~gF#LG z4b*_UTwO;wY?f`UNqAciotr_{?`A*cnT%Yc!sp$b&8wJoSyU9g?<~iuN6F~b5b=Fr8ZdYt(Q#qwkedTia3&Zl269&^l(zTrHxwJ{hBo4 z46a#yp+wPj(Z-lD%{@Ew)FPeqDzakJtXm%A#d8=XcMIap_DIX#Z#%nqTS02&ZNWRM z(p7Fn8_cWHwe~>$vQo)7$klGxY~Rkg>48tObD<@S84

3Gvq}n}Zr-!^7B3u=&5){!`;FbCne4#Qqr>44urRc#oAAm9hbk+w0?*!|8H(r1C zW*2g7EcUqM-jqeLUAmmv2yBd?gPT@H$_6Y;@N1WgsZRY7K!NX$-tY+x529%wIdbH~ zro;3@QYgMQay9e*15@$RU_kfqVcr4ztpKS4_|JPcc51zyPPvv{fxpE1RiXw7G;*hb zj-rrtcn4VV<0*TM1X>Oc8G-k~0R&$WxRzc&B1*NPc8psl9_C9I6m;p`UT)$%)U9D> zm-1-e-MLmHsNQZPVLZPuH3}v7oMOuj0|w1A3!fK#yY(|;HljjT>uJcc{qjjkr>ZQ& zz9)ifBYLvHFGBK*U8;mk>XD%O7O6%0*Vx`!-$7Cxy*kY^H`gV@EUJFs3BdCqGr}@$ zq(=WHH^t+70QeI&db7AgsiZEYLVh)t#F%6{S^64UdSQ)Y-S!{K+QEu^b~-tf?ljoB zXdvJQYA>~N|CUO=mREi~m9(hr5v&atvNn*a*U$d-RDHVb2i7eqJD<|#Khb>Z-DT1G z^NM9z?g@#BF9qetKk(4qwo*%qtvd_yx?Qg)e_t6R?QtirFBI{tjSW*9Z5rW5*9Po=#AUycwoNUU2!r2vZwE6QB zyB5!@&bp^j;47B83=sXxSAb6Pv~5SF3651e?QGbi{Q)Ej?BbZmO&7^LNb06+*U=>7 zVgWs5G}E$2`-d-$G6O8z!Bc2}6xm|g5UmlVNkH?R>#xB+5X3xDyK2RjgLD)(uN60M z$dq!qt8{BMn6CA4nX1zlYeC~n_=o-h_;Lv(JcW{h?i_ID1>(A0H|4fg z>R5VgtuHdm43?_COJDuUMP?{GSaLi#Zodn_gt=a^nu^>iB*dr9v&`Q=J%n3l?7;sx zV`oxE%&V`M-(e%O?uZEA_vBS%yOJd_ioBK4@d57*%gmIGIUK*^3XfoAdqtG(NLzT` z*ptWc9eWdq_99d%l0l#oDMjxZ$*py&^Gx+JY2CW}8ZCrhc`WXMGL~&i`T`OCXi|3C zR_QtQy;>+?lsm(=t5yRmid{^fWl$7Df}DZr$k?60=1BGI*mi@eB$G1iOa6ufSjGFV z|Q6v07V0nll4|xFyq%^1g)?n)*DaAa` zCDRRxy3=nI{KGPTXIxD%LAfI-z7EKAiGyT0;5}yabB6Erg{;lVe_G~(=};%MlTHQq zxU|UNUS}W%2KRoJA8wii8d06#DSWrOzJ4rOcGK+}vt5zTG*I67pawv01c|bNv*Y$d z$_vXzZBzzkvjqQLz9#0EO!<21tUCDNWkZ}o7B688@ldYgoKIF?HYqi%T zh7&mhMLhyU2Wa#Uta`+&{&zchB6U(N2seq9`C_{EIzw6};TBg1j!54CVcd~acHow% z0(g1*3#k=;d1=9ZB7q}~TwmR@SFz@!wk>@ite1WYxDkIGYmCT89h1Lq?b<_FyubbS z8^vJr~Dk3S!%)f4sK7JWP2Z@FuBh(wY8dN#N}w>TZm)J!S*7UjK{L43bwJ zP~-)de^bN2p74}lu=#66L{zkNtu9r@83?jc8J(xi`Yblrw4}vnE&z(^xKz>1+hZIy zJnH38b#osQcFO7mfy?^MVBc|cC7X+7=MBAF7ismkbsV>Aa10D%Uu8h9013r*nXdbG z=B-t2ZfJdUmOy^*{(OUR)g>}^GkU6aHdglottjdic}NsRi83OGbnF1d*y-17^=_@+ zueyEv_TiUFxdIuFUN)}{EB?k}JFOcs>C>MV9CtZT-qoqx(St23)Zo(Dka~HL!24yd z8p)CkRWmSfF552&uI+$nLuQ&ZBqBO@h^}RBZjSQBi`(o)jZG|)RtE6p6FcrU{>7KE zORmAL^3w4hYKNgI^zEhAVPZ_L#Zsz`>>_(USuTQv1`7X)rJ~G9@sL?fqYbY1eYAQTeI)T? z_IAs4cYkO7BsrTE6Cd;P+C0H`FI*v_zt)X(XD{`>tnl3naP^7vzGv|}Pwovb-s(XA zxWQ1q>5tS#nhv0+2AGru8xA)O+8jOaC+NX@`4LgGkPVxCns4*S4{w8vt-gQ12Pu?C zdl&|&o9A$EHSEuEdB!K&$X6#F-FrS$azcgzu!^?fx?lJz_6kF*j>9$*w|KvG36=J~ ztL@p(qEtT78T&8!d8r$XCFHHoTZ;;~iQ*lTgZW zSt5Sq6!Q6wH|8(%cFN9Epb7y^QpF;}R4y()Wz{&q-B)QO8=@yg{v zWbb&+5j^T$WGF8-SyV7GcjS`Ij)JMtbI2u|G!9q6xq{sVSE~B{=XL+ju1kvHI25e` zfCo|7GhR*#L4~vSIvd=r?b!IHOqs7v0tIQ0cjMJ>{EA1nDy-%SPni>Ul=vegy({eXM>Od9(M`M!i#?u?pD!uDz|(hgU9^F_&0_c$ro5bf zq4``ju|d#zDBDg(^23P{$74uqpYxx!WawW|q)(l-_#LDc-WiSVJ+z^Wbg;U5K~pc3 z+$PQraSQiFn-x&k*trVa-AWuM-+UsflGqLXw}Lo11C9>ICd?-d;?1Dv)d7GzSiLX5 z`cUXzD6Wa_cg9s<#?TbX(!|c%gb;`X@nuv0z%%#YFlxe43@^b;1Mmk5r4mPpFPlxCS&5^?QM~NIGw&zNNKX_B zuHei5-6_irRvSHzjs1FoL9jtKIfILRV=k8+#Ek?$Q`lufiLHq@x^lA6|1+-kaCwNA z{A0+o2;vmVjTC}03hzm&fvr00ylz|R#G!rnH-#cPeg7T*HMvZ#*!Q1p{w*0@UgrNluB-=F=LtQ2`0xd8NN>cY=?j4&3np%kJFn;t zv&v|ziJKD@C2_iX6Bf&}@LVs!I0&iV7EX#~V=VN7ipt7#x%o>?CU(pB)$pJ7$UT@A zDC;;;c@ZiHA?z_wD#2ivXY#{S11jMS?>zg{bt(H(-=BqLr*-+%?n5tC9SwF8@pAX| z1riS9lNahfAVMXl2g+D$9(CL*#PaW}^~`i^V#1Gu5M7ex5pR^YZvA@Y=3I}mYxCD9 z9e*=-rl7no+%N%>BEcQfG|p4a=)-daz&1W{7xkC6HO*-o9qOq9xDh{DzP19qulw9dEc>tZd)3@a`y$0!C*-zW9l^zt@FN+K>45gMj$D&5wHO z-O@lu=3QyK&co%7pe;1&4L8I^V!K2wiWG{+aPKEPensV8gb#Zd5g(Cnw9-5INtfWrK?zu-lj;EiF7f?YmgT7etvz_aODKk}%9XmGM2-%rbc*NF0$O+K0 z*;9A~qCx89aoD?zXpr1(8XQ~N-UtP$pEwa#n`9EgZ}D_Hw3bQ{THo{--89wRyLY!Y zWMy~?QU%6qX7X=YBO{}O^UH#AE`_?Kt-nmA>Zw&TpQ}Mv4hK@XZis?MDg2(`wuHNC zla-O5Z>%It0hU=63a1c@Z3oCdJKs5pLd?tp^6ZE@h*O zHtI<1?k8>?aj~(Qc6N4K6NH>_>@JZX;%XQ~ScX~5FV*&A&NO0+!$+OE!1~Gm=O5<5 zgVMPi5Hp*Y1LYna%dX~f9zJ~NmcIdKoXgu)lPKg;`{5-qQ-Swe-&Ss!SH&~#Z3C8{ zVC-V~(dhM}bX18mX-4N)+P1#iKGfiBd7)*}{_{Uv!fTc=PSUYV=lHVWxxyz`#^_9( zx&b#`EBf#;INF1QqGMd-vRqxtD;@Up(sX8u`JG2xDd_ zyJt4&!Dl>1RcuxeR~MVk zOUk#lRvUT>>|Oa%lMeigvy)~jmjVbw2?*o2%shl$UiR_Tbz5)=ml+SUV{JUx{E`*~ z9mZyKOOuU39%9c3GdN$|mKZG`vIP?dmq{r!tA0d}He9GfEk%JLhP2(gF9B_mW55dB zkL`VPWfs@~TriLshla*3E!2nn6XfzmsoZg!+K=&==`}w(xK?8EgFA~zq=c^V_MU4F zMX5cZjgJ+k)|Ux06dagv>>NCHEErcw81AOfLqi(g0#2>V2)l=>kx$g{qGp`_lKCv2 zCDNh)NM|_QM=f7&;`f*47{ zYefxnevLVjm`fmDWNd8ZlVdL@U=$yfmWlLM{}o2nX1iv<+^V6Y^9@G-O-)z{#1H4Y64v~4UMpEOPdHrRmbfD*UQB3 z6iTTk%6!;bGwkE))PC|-NS^cuG%Rr#>Qci$Jifcx7(Tx%U^M=!C@`IhqTnj~hu|Ea z<;F&R{)4(8xb`R11z;t9fX@$hokK|?D)^()Ai@rqHOPMNRI^rs^Is^8X)m)WW zhVz3j^{?s=a(*(R40t6L_j!nl<>D$=qoDb#LI#H_ZuN1OhPrx=Y+Oo;CL(|uD6Xv^ z=dpfTY53vAB`iqmiOOV!f;(|jVx>0ux3`-jj}q9~8wta0R6;^2ey31EV-T^To<2RC zoSbZ-GI(z^piv7ZQlyShi+wndh)jI&u=!%7+g#k zBE?1S*jEo0I#Sf*vIhO_dK%0}x8!;*iGrR(M?Xru@GJlRCUugI{sB+VLgT0s9-rP{QqN|;q{ z2=16Qc287+m{g_XqNDf0GGoaYvwKlxHb0O5x?kfaL)yoGafVV%d!TiA#}2{ugBmKZ z*D>C39FVahN=t-P4v=rl#)cZ>Kn3oVo*&mi-#-RXYKgqa?Ha_t2hN3uM4Tku z9$%f=OXhTR@Qa_i@!Rz2U&}_M1aS}+#BA?`P6P>(VCbFq{}(@V~_R`}_CW=3Hl^spBB21Q_E^C^D@HUx03bSgYpTOCs|| znCJh4O?iqDZHz5|qu0`RJh7`Fb+dhj*R6VXpl#(5K53f>lyBk0_IOiKV4@+#${GGv z4d{AFr%INS${A4DD_t(bn&%Y<#qN%UdNwz~RA=_mXT-Cf8vp#`_5U}rYvqRDS*uK* z|1lXIHkDA0MAk|(huX>%VF7a=X8+mFdzo>PL93>Hc_ReDA2!%Ji;RuSchFgdlBSK> zStpC{Z&ZT&&=&P0A5i)Gw)j^q_u*;L6~R_3&qo!9)(Fl+;gOy{-{;i84c2jAs92cMZ&wo3}yt=|OlJ zCeXJb(%PZMq@RbC@TKK_(E`$BgiltTnMNI(mmnreVr|1*NIY&{JSznJ9#hs|I?>7=6)pzK8gi*)L={HG~f8< z#B_gGG?FjEDDQ78BQYu&1Tn-*a*xnt#+T`3%N@hMfL|3W%q?v(N_s+~;6g;fPJ%zf zP_kQhb-%~214guHwgsA~V6V2CSYa{~D{QOP4ziXG9lCj+He%w6yZSf|jumh^bHcN@ z)`n>NAa^(MLvAE1Gw_t6+s#=jOM|%$RBg4 zTsSv&|I%>WFnc9D1C7(UX@6kbwI}2YPYtrQgI#!|DmtVhsi+Tl0Q#FGDd(tkl%kZwAdReTL-QXf;`aj2LAGVTuEy=6JG z?ruh4-rAe&uJ>tb#Nef!ayk;ZM9-z~l@spVy!5PH%m%2MSOU9UWiJ2o2@0}E?*mM4 zr@nl8vwu7QeNpsrmq5E(labLzZY;Afz^tt_Y)%UgpZFf*`;I4vEo-WhztJDnL8!_> z=S+}A)NzNLHt-ekOISl)bwWn&%%Z@k30oa}saNQ%tZ~chT3T9?(#*QRug84J1+G-^ zZnui4T$ez&wx`wWKeP^#v5!T$u%NH-Cp!WA@3(^@0&ZYYEUmyd6pW)UF()8lEPvsG z$`KUbBC8r$7}pC42`%1jnKht^-mgvVcAdE##LzV$AxWPW=rdceO>QhOe|(;a10Ima zz9qilB=sB)0>T<_#BdaBEn;!Rx<=SV7gSDtSZT+?QaofiPeVx?=%d z9)6L1*pZcRtn#tU%G3rVM&a@fzC2^mLvRZwaPOs$k942}47g}Gp6kI+{7f*N9DrB3 z91k^)9ErqM)P?fmvr=xLT#Z~^(Bw97gvaP-X~UW4q-v08X-rO7hUJWPMYths%)J4U zmX+WZ%2O>H-SS>^cS)S=CWRn!F05FmN3H(WW#7w3>ZhfdU(~;Q0o2uhAJ^%*yHXRk z6x^@KI*?Gr#&BQGdEM+^i4laDazLoek>^61hkGoEm}-zS(HE<{cLP%dOvzVblgTDo z?~lpT#g9Itpty_tyPEJ&IN-4#_xV)8Q=s|?M@_5~U%s40q7_13XhXNArjpWCVoQO~ z_r;4H#E&#V>x=Qo_1_?`2KFLUI5;h(b!5NQ=e;T7pnWGCffzO;J%lZQmJpN<%U`6` z*O_&`7uxS1`o|wXXF-om5gf9S{NJk)FB?p`AT$BxJlJigUR<0ejeHA^r^#=iqsj~h z#A#!wB7Ue)QXK*5Qtk-rJw^*9c(Z3+Z4^%ee%wV#&(!0nDD!{weykl05N%i?;jr^( z$Srv$8tf;?XZH{c$Pd3(@SGkZGCJm}RL~RV$tJ@Ten4~L89RyJSuy|a^UyO99Rb$l zuV@HT8pjz>VZl2Bci^#2yfgAa>G9}@GAzousq|6FK!73(5nCvvKM-S$H}TpjJ``o3 z)sG11pd4gD+x>;AJM8aDv0F7FF)DQ6UK6+hhu?lAN>|TEA-XH)J;{BKf%lsyO6Fzc=k|1G|HfP0`U-QH0Z zC-m`eDz73+yT84H^6v*@{IUALy$Bc}iF_FHe}TFDpDOsj*NpI|CHUVh8B-{-4>B`# zbNzY|$S**7INODw`=%uUbqdhgn(oDao|_PGT>sC*5p*olc9YVzT#=63T#3Y;I>g{fzoR7Pn7j?j6pQ%pK={UhXI3GkeBHg|%Wi z{C~LL3{HKqwCHlwt|iNtv>uL|=6N#ups~|v#rY{u?KKCd9Qx(-(qEn^8_qs#2WQ+ok#VLs9PUu;b04JfBZnO4rUVD3H-dmWLp)l~jr*TIc0mo79$bK3Gq40_$ zYq0))15e4I9-~NaEnJ_ju37a)l$1WU3%Ifr=NXh~V9@pnc;$7A;(~tEw6;z}i3(rA z$)Ppdf)H^S$epPDa`60Cc!hl6Z8l7yL2nYDOA?#yR;v~;>~b$( zo`Tjjbe!k7#1 zypE5bUjpg`2qF`xvf7yr@wIhz7l!D)&!-Y^uQ)XK6DLou!@@ubYxp|-X60c}SJfvf zgPhtUEsS+xEe>P9w@5u%bZ>23RTS|mY~HMfLPZ(`d$rUN7~w&G1-rY?!0-;4;VYAF z3MV$+8lVqlG`3x#a)NPL28ifKESl9Lk&%%o0*+K0F}fopo;V;sIz8 zTKmOpUR&nSr%X~Z0lMr}QKjBdE$E=o)VUMG9HI!=Gi;)k7Tr8IJz%tQ)V z4&#)P8~dD~sNl8@HFH=zg7O=T+_#*rUfLF*@;p2=^i)HpBlOeoO#L_lTVYR`B4|xU z4vqA;k)nIBvnB-8PAh6co`%MHz99N|8X^4ZX`@}3wGc|EK4LJEGFp0=f%e@yOzVt# zf^!J<24vrg_AU529s|4cC3K^z!2*ZDqT=1V2YCX{`|ye+AdzS;oc8P2u2oWz?YoHE zidhU|_2^$c)}az8twB1_@y-m+y7Mrsn!t699)%OHyYQf5zhr$V@Q&SR?Jnsa&EgJF zO|}@tK-%nX<~5ffcT1qG`pjguQ^%XBN$6Rd|NHN!(Abpj!aiHgYBee7>FSG?4LX%2 z_%lP1@bTq1G;%|#Kt($(VU3Omxc5uj4>fpfF_fQ6TxEe^=qQw%aJ#L9q6PhJ>7DE- zKl+Ckll7jS*-pod1LCv>dL2V=v+qiKTSNgcC(nQlghr?+q<__mk z#X&@oegf|eSzGi1?W0;SF+qbqTG#l;sO(sOnON@Yj)5tbW)>EhFo4kfo6G?fBbud` z@n`m~=CP%&EN3!T<4R}Z(dU2Y=W$MDPL**EjFAYjB;J6zF+p;;Q)QP?kE^x!wLA)t8Pl>Cis+MaKjrka8aOP9R1116#(>sd^M=Ie zq+ae!MbvmQu&NDhO+?*<@97aNJ)lrXDGI%OdN=E9sSm+U#XHHoZp$hmp$_y2d6##Y zt+1svIG@#@{@ZUm25Zo#|JC<#A$4+*d6QLRWtm@NK=Tn-`4R`}FP>uv3(JlNLCo%7 z$5d>VTVp#et>dVh1ZQ+BR!!%GszF#kg)8B7Hct%iDWoYXlZh#=p zCm}4*1Wy6Ebw=*G!oI3%YCE^U`WdIcu`OUJq@$sAD^~1OQd08YV(vc+n_B5kmD}&E zNt?&pROqE3moE6Kq^8?7WmGb{!1SO43p>F(6tyd&C*cJ;?R%THD~nS7JM2%w8G#qT zKQJ?GjQF{F8N|dGhF*d7pT_sZd6csqd-5G)Vq(zbi5mX5hRTwXWr!k{4T}deo%mSJ z*0NE>LVP_}o^@oR1L%enSqC{}L4?IN8q~}E%M}qToX9mluOiI=!!GSS7!8M2vZ;@@ zw)Tq@OZr}2Z_>>TON%1uEdyb{9w*w`EjAh$pPu4V-B1yp=PGZYZb(z1-fg@ayz|Os zy=+%#6r}DRsA7z3pj_(^_frmJY*B4#$r5Ri5HQNFXqo3Rv{Oa?E;lh~Y@bD{%y9k2qlk3T6ap9}sGYJfKUaWLM3{5c&5r;yKyHBHuWUK^J z*49Ghrj27XkTN!T8TgI2_dRv!L+E*4q;I_5 z>-xWl>YdlvC{8Po!6eYXrc?^R3fY}>q2X9b&kOqhLjgH#2Ro0X)mxBY0uX?y5q^7> zm0yl4T82u5S_HJee3L>^sqOYVw zCW@=fFD}-?LM9b8PFm4Xd)KX7Mzo{Tca4F>w)0t6N51~;T-LWYbOeE#DKsxxk zsO;>9ZtkhcrXTzxha&3@n`RjnTf;)fy0E)vQ}2=s9;>x zdf)sL6BinM74-a00bJ9i7QhimGnMFDRQzcK*={1>!0ogx^V;vMIFDh>r}+^^C7~&* z$Z(vLd0JWv7xZB|!;jDe@P(UJqbK{kTO)d2e}v6&sXta=+}uV*4&~px3coPdtDWhOc$}I|IcB+3s0BHn)?daQ$`ntx*zuWHp zL({=*{qb*$9@I!RvL;q^h=Pka~9f5LcrN(o9|W{5%L_B=tZv1fki+sU^_froDV^K1<;myGkHDl|>7Z9d5dSGcF~3 zkd6)+vS!LGxC^f2+(bWEH;t{T;@ z;3L3jjKC-D?BZfbv#Gi^*b@WfpY4S`^dCxqf7&IbegYv0390~86+|$?%|VI$OHaoJ zre*b$?VyCzpf=lLhFhy7gYAL4w5~1SsYBO^9KvZdxt{NJz_q&6m5KqLX}ZF$Xc1qQ zH~nJnGa)}`r@LdMpVPkH))$~Mw4h)gDT~2BblT}FnVvpfj+PB_jo{Qb>-+f1)Y6it zLC_7vfEJOwPM&-OH>eHlvrp2ZW0T?0!jLG_)q|X2uHHg4^(nUk0FE*=X)uqdMD%3G`00MQa!7~gI21gbC zmr{%o*vZsMw~2&;|ENiDM!z_-5giz0G837b2W9aTqzDu=xRb1PlWY)`E`K^e&e?8H0UaZ41~6vP1ReF{#*#8~w z2*OK^s&oFAVKOffM}m2l_d;Vubm-;|E*SZH8=muoVswaHzp;md=INb;6@pm0gPF|7 zqK|~=7i=ilkS12=2t$zdq)FsZP6rZZpC{`K-{CsPh zg{+u@W1l(SAl)#HK+&ezKr$1ojA{8AITVH7JB-E~x#RXQ$AR{^k;i~oi$cIdvf)N~ zsvq~C35zSg)ZEYEU>%;qct&{f-$8e_K^%NCCKE8kDyE|T(2tY+H0bF$3qqy}dSQI~ z_kRkUpi$00qhWUn#0{W5b>;D(Zf1`;IFyrZ0jzt72&lc+pN5M`drtwkJt~fj5Ju=& zhwO{{L`p|&X(yZakiyaP0qXi<=fbDUcP-tbJ>K7mi_;DFbx$(F!ghnwi4zkOBSj!!c^fj` z^HE$607CFvpU{-%RNoq0hqYfE@5Al2 zr+@(iiv$85lBs@ACd(5%MgQv+UZ=1vgnHRxsbWZbhWb4Qp@hsHseps;LaP0i9+>>F&WSysv~+ID_3U16;~onCeYAnp$$#gOLgOB2+dKpy9rP~N1V zlRUj_7rk6&Y|(X}<^h{QbQB;qN`1Q3rD@Q(r=_g@>kUMn|5ngUg4&l8olpSC5H zmzNU{-lM#yTR@4~HBJk}&a5aOpPU9V8)*o$8Z17%Y4ZC7?2%S<&pa+i)S-REx3 zF)*UyJ`+b!XJ3J)5zW~-1F3=-MVrRXQ-5tULCyVVawfB`+NH}e{%mGLLH5@y3O;GQ z1H-3EvXq@9P41elXT$x*Q(rX}*8;CeIqUy*(%Cee?DlMkfY0@7*8HkJi;waU&Pw9D z5|vXh7UcrBjD*uigccd?Fr+nQBnvuznlpwaT}}#Ogh+^7Q-;uZqKR4*wK|5DEF;q_ zy`%G7+5#L*-AhnB*S2MXF+y=Wvku^F-r0MwYnh=T@{3az;XH|%1;pDQtMk21iHFAlXW0a&RJ8C&WQ&_9}YL;;5sG)dOo2R;LjG;&x}Y({Njjj#gJZEwQhh~1Fln(v9?E!!ikv-32jZEj)a{q)hNsslnw0@1GE z&QSqP^1X8L_Xlk>F7sQjtHQVX>P@Vlh!VK<(}!_Gef6D`2rUlkRKbHU3@kz`^6~Rg z5#6T`$P^1~n=EueV(jwDfep;RQzz{<`bPW0>(GJ!Qdq9rE<*xz0HV7oCaqx*%uKf6 zC%wY;N@!8l0v1U~NFWonP;QXzLUKgO!JwYBkWI(iQ13DUxB zyK%!gEb2(>3Nm1F(V|80Ha`V8g%_wM3McT-q|o%Mg_=dzE1C!F247uYh>lccw13_% zAM2>oD@YYnw1)z)ShFZjqXk|5CF7{F(M#|bd|#>k99Hv$wg|!owb8j>$zb<3Uj`=( z>&1vI`s12>m39FaXg1lAb&^~Qn2hbbCN2E~eh&bDZ0RvfJt+r=lHm$p%vIvXJwPJa zxz}!NQqq3a?yfFi;l~G*4m75A@RSpuv8{mTH0bE6hr6#YS8)At`8#(bbJFlQB8Se^ zkslxE1bGl^NDGB)~`Br1kEc?0d zc?&D@>C@_ovKZZL*ysSp`2Voz6c!d@2!OhdPC$JKh3p~xb#8UCC>3!Qx>}d`cQeXx zH{qoy=YCn>2BL+|ELfDG_zk#_DG`MIA`59w-`A*rZtH}`fzJXq?h^Qx3bqOT6MfKx zY5cKhOTzIq9Yhkw_Cg&`ak~bbS5Z|}CpYCN|G$o^e}eKPt`h$~p#Hg?1hfkY5tV!C zIy5II!>E8SISumk^Vu}KV%s0!&mi+&0wF?ZK`@SsjLK_kO~1+D6G|1hrT;xT=D)ng z$Cdm66ZGHs)&E06d9;cCE6xP-9Ns=@z` zCt@*`&kWffbLLY(Rcq@TAtI$Wd&;D9(ozY7@}gtl?dP+vj+;|j5Bx7tuIFyKEEFX^ zOmzq^gvUm2GHEY>t_sBz`c-#@e-5WLmUvMS%HamNd>TSzVrDKvbTX9PreehMR`fdp zGyYjWLZUf$D@U4%UYR4gyfB`x>&ynpM@R<@9F^1eC9KQxz~Tn%q-{eJ+y5UVbFz$A zR*ItdBD6u0w6ye#?yor17Zd6hXKtMRC`&(%wCI4SAo>Ux;bmT3Kc*9Sqw;)0|B6qb zV)6=cm-0b%hGm23cCf6Ab~=!Wx)>vX9A44Z=OpI*4EdD^JYeuAbK^q*lh8+_sjcl# z<`>|(sI07d0s*i1Yq#vy(xb-H2?vfaBn-?0c97ueK{;d&MxmEW19h+EHf(%qEc6Gp~D`9 z0=O%+vHQy~)Ih=!{D0+rcU)9wx9-HQNyIJ|zydZDGZIDGU`r4iR!|X8h@#RgAkwi! zMG@3Q!6;xy1sn`bx&^WE>zFiCjjj0`u@a>9@2%KYm&4>+8#gbM4%G2bS;p_3N$B>uc%z za$s-K^XYsq@?}a;EcE(b>LvMpt1hQks1UJMtke0J#588>?I=Kk&JrV$uA$>?m?9{0 z1F|M`FPosbn6~$o1*`wMXnRu zF{ZL}CL9R(*t&ZhX7zO*wSA}ia&i5~v4qB;Cm>VII=rc$*UA-%Y_wDyTSA~0!T^@K zu;tu(mPyLhb6&(xnu1a!TnDBysnC#+a`FXX$=F*Jel8h!5|mq*o_>S8tEgQGbHzn~ zUj4PShPHpOA+SY!4#cqaZ@<8L4!wYa=StkC$yYk}nkI*>-c#38*{Ypl`R!l4Vxw{V z+m=S{=+cjIV?^c%WxSA7I>fa-&0Q!ZB}FBe0fxJsb3}4oYKfOj^V`F}XT1A@<;zaW zZ9}7MO457WqxrCFOG~l+g4r;}0IQtrYo_tJ#sJC?toDpMN&7mMMc zyAU+w(C-UPDG&kgjnss7VY?IQQOBq%0@ToC=ttf{QQ5SRw~}0Nkb;l@l?#b|vAJ1s zr$zuRtXxuJ)vI@u!VRSu+-64w+Fsu*#>=Tbuwdrauz_#T)!b$094!PwW*(&8mu0woNrUEX+*Zb2VIQYZ-X07?!jP#VMRAhsB~ zmW$`lUxxz=cJ}qaXk#cv6RFg@u^#anH=sqMpWX<)bJG57GPgN=!1QOB;(Yjzpbzt zvH|3`ckU38iPqz0r=5P$Y&;1lMHz$1*bG=oa->@e#O^`%v+1)8(3bS)r2USn;Fp01 zP)pv$FK?Ic`r;1jG2Q&~Bx!NUj-MyLK6!d2C|P`v9uQ#60kEp5tr;f~`n3-BIn=<5 zHWtE4O6d?{5;?54{SZJ<>k0h6dIt{tiirqc#6Z|b8q(IlL6a8aTD>T#?`GF5EOg)m z0??y|w2!yTMfV)HK7f z*;|b8^@-%J0x&1ujm~#z9jF)mr&&=H5Mf247ZER1D5&FH63B6KEw% zCg*+%ugblkIvZ)=HxIP!e(+IR<#!%3ZNn0mHm9~Iu_H^;_@n*Tn>xFfD-YvRj4Iw#jQ-YZ1D=Afh z-DrVI9OoB2uF|NxVxaM)69$JA+J|GN^zRjG)?`DzbrW4KY${7h&)oo<=ZY5IEJn`+ z>wGeD5*CXT?{o-&D1C&+np~=tP)h{yaMJ9E|CiCdHe;in_ji??<4iR*-`vz-~izN&dO*Qz!8=Mwi^hvS5V0o zZ}nk(w1g|^k%=t5q(`Fyx3X%*m&{ar>;cL;zi46XzSl<;0CE%h|MKUVrU70%5`$G*@w8L8f6<`= zbBdz)t#oDJRk0=6W&S72Q%@=9p2Xvzi;x5%54Ak4DZIdaXQ>V2KRR5GSU`{^D}Q4h@t?450v}8xh7nSe zv;^#C9$Gz`ba9{%zyhdJs64bTlnMi`TH*~HJ$m$90Yx4ji1tY~Kox~zrP5EMea~+) zvYVAV?{w9NI}JPu^jQ^D-I#hOx&@zT6#$#bt=n2-O4B=@=bbol;#>hSr2TL1!@!t$ z?Z-0eb{HFhN(uG$2{S-8a2Q_zL)b$z_q$3_kxYeZxm*RrJvl%Z2s)tn3T)A7Q$5sf zpfevRaD{P0&EsQ#II$I*jK0CHI7M0mwA^doHL7-ZoG!AByJKro!oeN>&_pI^h}R(y z8@eT}+~ z^zp2eXolD}6tgOd?5YB3ic7AYKHiSBNSOdEk9C+P>xS_JSCl9IlQT12OJG9h2}DEn9!SepNo- zy!3F)Wyj~IM?;o_3R<^LRNN-IW`Y+0NzIO~s_5Q53;+%d3(Hp@l4{azZ0W3bJ(i8- zFg5BND?QZSpAx}2Qb|FBfH`R2ZGBf9qlf1p60^6+UqeSPnnWTUW$*n3)tH6GZ9W{@ zDBr7#qI9A7-hesF-`ujXiMv>~5TU9x7?B(SEK##Dlvmn_6nM8Txwgi3c{;){?xQON zT3Lzi4eEf5bCZ|0SY39M57s*?)Zqmmhz*oxD+TLr+&E*-oLBE_C0amB;e_o`kXb(w zhIE=bh4EUmJ(F&e&IK0>TLKIw=y6F!0|SONKtzg|RY8( z*_4h88kYieAyv=z1K4)Re}9p9qx=H}7~)WzCO$Mj=h?ao`7_o?wqGvZFaCtPe$cS4 zTiq|YTMIya}q0 z+qbKl6Jr?WX{lry{j@{r_D^r7BKxiKb%b#3X_61(^IF};c8 zdlvQPVrA#v{KwADUInyfP?*0vkECJv$-BtH)vH(I^b8Hn>e9`NolD*QW@K?f8xB^< zRmL(#tnCuLFQdk9c{#9xKtTw9;P$WlT552a#Hx2j_w5ne6!BScr<$@CeY1nHn;WQU z#yYaeGd{CUeRu&iFqI8Q`r{9Pf+dU43L&;0LTxk=25KT zvOl|LK6F`-N5WxbqWorH74rGea6ISYzj{Lj>pU4Jq99TFELXa5M{DQ=tiiyxkV6DhtLY(F2n z73eI2>_>^eSf>uzJpJu=)yIPQV!qkM2e63vi{d{>k?!&j9%sfAA{f zo%aH$V155z(WT>I>5ahoKL8{B&Aa}S5cWu9n=;-pFh8&5qgmkF?NmVNG1+|Nn{l~Sw==iPg^9%Dr`$dFVXl+ zMzprRzP_?3D*V8~gP;Mz6sm)P)f3CLY84HEqA}#8=0T-8`6??2V?Qh4SX#GSpp5eE zth9Q5tvPXz+RiN*=hRZJSjNJcK+4MNtw`tI0`8+c-I#K<2xM2+@Vt0&=H$sws!WXC z;4yTpQHALa=A-2oNbro2Wea4=Na~F0mv%T#By{S~AEAd5nsM#in=EWNd)(G--1sxV zlKCjnFd}?2=or(38iC#m_dgBxU6h1W$^5H3pf_i=symCKV=8V?*u#ljbiNHNZ(XEwQdf>)1FlH3S_)XtpMUv< z=84&7$Gm?j@6*l#MZgkNtV;Gcb0z}~28B;k$49@CXykB9LyAeN_8pcJfb3tNQjE}o z7y(~y*xCWcvDN#!3CHKOyE}xXF{PngEU_613TuX*d^Vkz`24wTbwSKTv_ z-2nd{`(-j(c+74I1Q!((<_+~d=36TGWmG_0D&==2u54DOxS}{RoWFynOMQ03$JTgh z0E*K;l(*BVq#4Ka=#e9Ds@6Pu7W@D<0}>db(43E9;&QUG6op10XO5%y8b9qvW=Tkd zn2&G9&M{L??mL^p{U>w$o)&pPMyS0PLTtM35Ud7xc}Y3~H!*0XvFAV*5Y!;s;hD$9 zn3-v-ysqIQpgJ}M*KP15I>uII1ivU4(!!fSeLOQN2-oAT{7nOsYa(H;9xWrorj&U! zT1e`KQ{Y#6t}-(>;`PzYIJ{bZAq&wdzDd7w4|3EO%M{>Rj*^lJ)W9TYgW%B7cXhF% zF}^wmN_3xstqBfVq%w!1+R@zxYnZ^gGSjhzzL~xlGLH`U2e*2mto>ai^-(zmB0M+f z`m6TP+ltIMfb58ks;677gFcdi8Y{dyGB;@Ba>(JcVvx5Vq6559zK=z8z&?PyK_iV= zQ}h=ai$J}V?pqjb zO&=ESE+m=ejhi=-OE(Hl=w3*TDRHFX&6&9a)U`E@ot7*)I!)Urfc!S#!Lz7}CcYk1&OLHuxL1zYI=k*G$E) z@JFN1WHM0}qbDAqqc$=R;2}rPBgkUahr8g;85dQWAfwuA$-F zlh0lYE$VQO@wfm{NHdL+fl-1i{xR8(h{4J6wkfUB?TyZd>g@XL-@-MCtT9)Px_pdWIip6HSfPy zi^fi3jbI_EYsE4jO5GB)X*@5SO1(WHo=v|uFJ+T;~GbgDO{PvJxKz0EHh#( zR2{y0g0;?I^t}3Q+=MuR1W~>SiL(vVfJX*d#u$=%fZSLKlF(T%qllJUXMCq9B|v$d zU*!a;CyfIm+{R8?QB}3TWP!l%H?quVb+ot(FL|D_9LLvaZ`d%-*n#z`cFa39sk1`d ziT8O5_|JUq@lGudbVZH%36A5MFV!~ze_4-Cnsl@VF?KI1tX{s}clcGwT;4!?GrYID zh?hr4EnMphVK`;!qCAijCOA|W-Iaj^YkD%mKW%@sv#GPRz32kLR!hH*wTW%OVIBQD zp9MfM_o3yPp{$(8A3a!Pz{+k&S+@ zNotL?20KH4hiIGxxOHNq2qM@qOAQszTPu~AF~)8_hu^p^kl7F^8CLS<4bqR~w4gXA z^LNhl2)zUc8yCo){kg)U-X>7)MB05et%HC_(E9*~|%xj&)mK+w4lHeey zeW!0z1nHS9XVW0@@}?At?A$ffQw>5vsEYkn0UgR~G-KOwvMr0;NB1Xy<{3rD#uZhA zt~>4OT7SA--&L6YTzh!b+&RU$xwv4IYlwT=JiA7_E_^fsevuP|O#h3r@T+7V9DFd` z-C>?at}SJd!kgAyq>1e(TBOGg3QDcrS*56`=*YTUE3%5#LpqgiGHw5OHhmBj%dSQY zQ=Ub#L{lz2OC^H)eXF0h(JH_ZjndW0ScD=+Ej)^wS&x#$)?)6A8N2zvzV9-Mag~o= z4i2nVvM9uBggH&TljV8M)o=4Yi?bB=L$#{N5qu0o?>Z= zU%nAL2uY$ik=u<$z$+b_Y}%UlD^DB>MH)A_=Cu5SI)^1ObB-8^Fy#2{zJ(1)JV#B6 z-4mnqE-|_7hmj4t`ijTsWHp-f%vG9;S$-HU1p832=^ z!rDM~5Bz2Z%noQ==qs>Rs24n%YM12Y3>wB1$APy>7=~~y1MbSID)=(ZQ^ydc}c9MMm^$N;FcdQklTNLZ*u}0MaUdy+=JlfGh2C>(;Fk2M!@FfB@q( zXfVsHh1TKQjh&2)ZcwmsJ2ER$L2`vc%t+AZ8ovz`o@o*VASLPbzH&-v1?5S(Ku~p8 zAf&mjjX8U5vIY!GBSwrM6A6rx&4tC#p%z7M!U?kB&MF#aM&&Nj>6Rn!VyK-D&9A?F z`7+7XmLjo&e9feY#RH0g^|}>6Yz@lDU<64UX^v2huyI<`z>KQBgP@Vs!AU{JVz4$C zZMB-@XPli)5CO3%?HU+2`iu;CAEAkmWs?K@9*9Kxp9nzrMR7W&;UPiX36fIkc9~Ub z14i<-F|P*Q$VNERd-CRyCdSV>ZU%q7{w~VkMy6 z3qf)gnmbx;bO}jMi{4OZHo+_z;Y-;+&)k6E4phgo#2Je@`z;mZqTg5?Bq`AJDhjuxg;{M%>N*%vl=1HBnOjrw zsZ=QlbLij+wfich1T`f+xin0#!4bKAv=^N*Y`gJn9es;SyZD?0L>=F(kkAIlm)x{z zl^`a6wHwth2;3gZhWIK|sr;XQ`l&>CJWjPTJbD&6c3pn!f~gt9OQIyP+oRs5CM3&v zk_(>dy?8F9BDIseY7I~fZ(6%{Q6_ZuzoZ$2aJ)U8=` z0fP)HdDN&`D7Evq(JUE%&97V+F@5h6pzeaQlH@#?Ra41it=jJhHOJaR-Mq6y{==rhR_vlNPyE!3|;y!z#>%WBN1@Sm@$_W z=Ahh@au?E05wiPy*4!WQLW{D&po7!~D;fwD98~hZb|5@onz#JXVc;OiGG+uF zN!hkbLtg%j`1ymzO#J+z$9zg+G4#x*C^+rk&>3@LyvYxj)fOAS2<*R)~CxcZ{ryIIOtoCV#J&nY-uYX@2b%g2q}9`8WS z`#zKlgDAxZb;Hzjtfk{GK|LP(yO$UQl)SeV0k0%Lj0E@g(i!r-*LGwvTR|)6!_@(z zegkA0_Nwh0h&i4$>sPz47=v6fP7yw-Ef8>BZfUUt$cVqX4BE79TL6-6@V|Rp7x-+~ z$0DWAlxNqji2Ks+ucp2db4%U-EdP8ks}&?|k5PjygJ4n&ypd6BNIbhEZY0 z)Tz(#WK5E^Ypf&*y7+CvQuRDOelxvIQne!Q1E0pN3=f442O-|5U%FAj&w93h^9}jz z0l;$o53YrO`m0CPco~A)Fm^N1f>27^>HSDLam+k~=1~yS;I0wO86Ur_5yLBp%ZKI# z&$}S-6%$}dd%32@kO~$o0yh8wwZ@pkd*6Z#zVR0lyYdEb3aVJeQEv}US>Ns*&gZQN z4*S8gY50oQhouWfp5`~3?`@B~0055$VN#mt+BRlj$_tUP};wg8~DK zcn>TdERUk|&Lf|wIoY#ipcUSIP-c!Nj(9gSqHwtL(Y0KCsy$khMLfDElBlR|lG_DbXUS zf)eCUT?plt$~#VAYA7hIL6~D2aLWeF*sP*LRuC&t2UM)P!@kfm<1dg@e&DP6$9*Ms zqluVYWMbnXgczm%_^&C4U;j8Zvok{=GNW}+=sq=%>WWI+wy;nqecLy#)2%33AL)h2 z!)VBR5Ehngq71~vB&r+J-SujH7p4n66%5QP@Sqxa6s37_i%Y@x%<6(oe8d_X5 z%@ws_B~tXv1y@6@r3+5K4dhCu&EsJV&Q>IcLWsj^RYU7f0t5RdGfpIiygU!)4wOE8 ztq6^f;;6ElQ{#RT?JCa;_QT-?BZQ@GwG9qyDAj*@_PWkhSgoET<4||x>Kc>H+!@Qo zFxykl>w(=`fG<4Z!bBaj6G#v={q9XAA6M$Ca6x6dwf8CCkKdhWnGsgF6IX8VK%16BU;skhqk^ zF}9CA12m-Sv}#Cuj&r*%*1ulxE({}VDXMiUJ6OPRYEpcjkWlH2)KIh{lZSJv7 z6A=`bAc?YgKp|V>x|*eEin+aD3v4X-##fe3B?k)tr$c)+jct9zJycOKl3ep$*?Nr- zd-N;R{HAq|ynIGCx||b#iP-_z`Lu^e4yEb^YYX^6Fko>aVQnLv6rEQjw1CH0v5O9# zD8YKS1&+1>sNjQ`rmZN*?9ElNDUh6SjbFxeUbtY}%Gb{7mb-Vag$^FI>eD94$KimH zJI{#_uJVR$xRUth$o@+pG`pIijjJxB@V@-DG~Gl13saNn#h@bV(N^E zFR8}|j~s<<0nae1+86Reuz>YZqfyOEZl^>ko5PMHT5Fv@qJ@9f?2~UY{qumxzT?EJUu-;R`E6|nU3B@Rx#ji%}j;mP| z11J?8kF7|s^1Zw80!^bpqu=`OU^k-ezoiF6J2RA@cG=4ilQhwP9?n)$Qj!Ob56Nb& zRkAa#Ez)Yz1Gx+PTaE25bQu@gI))cZ^({IQ0(yX^9ivmB7-Zb+ijMZUjxyIT;r_|O zSl??by!E6i^S)7)ZM%lo$ZNP(1UPe2>v2yy+LtLJ{rqG=mF!~vw(4o#W z=e8RH0s;^_vj@?Ul;KRuB(}DDm`y8|3trg`037|=DqXhks<%;Kwbd=fqlLyV!PJ?| zJ*!tY#`|UuUpT7l&P}EU0AO^z+2F{o;n=7|2TtN&-EI4wN7zB+Nr9m7U|oY4%h#*p zT`;E-h&hEdhoWUCf`*XC>2_q@Bd!1%UeYmRI&A#Nm&cUDkRfsp_&Ce($JAneyS{^T z-#t}oKFSBbN0m(?+UPK(7R92U=MDb#39DA$J6O({El&^uP8AF-a|mk%}M2*kpWHRFv%U*F~kE-W@=laU7c>9$7n!C&@ z=z({4uSr!4l!+?k)HpxG>ev8ROIcVpGw#8IH3^a^#SUjv&V^%3LmJzuQJ$kBnBJ&l zSsVb870dN-yQQIhVovte*9&F5U4=Eqc9^gur|;mneEITJWHsd@U%cR<}Wm@Fimgo$& z%`R3(1@@#)Y)J!pVPE#Vdu+BR76am%8YsOQy*?ta>+L(5EIbtk93MXQ``;v|o_uy4 z+BUJMli=&?Tl#pP=^0AzS5p~rUPYR3Y-H34)5C%aA|$&?el%3!jtbv7g0UN5eYu?| zNBs-Yfl1E>9y9~Kor=`#=&->&p-6${QH{GvW9r6ZU{_fgXwg}6a?j;M`nN`(G+Gm$ z&6cMi4Qz~rBO~0!);y=>e&3o>h+2v5z%71zUK2MHn%u_ff*k%qK>F7bJ&!uK@B8w* z8<-J3VdnvnKt_G^}hBmaj_oRB$RP#*72VJ%Qs0lLpEGsejFhvP^>jr(wxv=YCm1b`1H&5)rVv|%9d5p@MAlUck%2Cl_?Xy&;u!r;0Q_0yUR(^0 z;c!4Q9FgV*#^iWhiX6{hy1%%vAjF+&B??F`w=FmmFXjCZ!sC`7)p&o;BxIfbz$B#j zc%&q>nfN;DAO+@L*{n%5>~-~H`NxDdvRZ(PTPRa_s7&8sd&J!^J&3aUZBrfa*iq|$^nps?YEis;c&XXZ)`Lvl`~;Gx8yNrb^#W0%HbFQRH4 zT&e!SSMy0auim<+_K-6L?*l^zkaT@ZoA;L$M!D{1&R`z%McI2u^Z*-Z;G1qX?#NPW z3!tobLW^bm(zkJ86z10YB%Qd5FZR$7v#%Ya2CLU zu2WVNoW3p=QPm3&Jzy7BKlb`D^{^`zkvJMwzrU=MiXGQcx*&rFLHR$3d^xfdRNsA6 zxAsNS$$aVi%0*jaAGA@P_(*NF>u7+mbnIhdL&nZM7L)9R5m;qq?rm2FHAThhVJcGE zdR=3u87Wud%#SMPsM|FR67FnLooBqVCh28(+i{1WK48_L;vg!H1=1pp$#opuj$LRA zr1tAj*hVW{uZVS&buIYQ^yIDgc`eV(_WqbH9f1xaQB@uUIdRZZJ{1Z!Va@M^7h zLh(K?;c$COKYq(W^hH&efVTlZnq!UwbrawwfQ~4Y-&@`YW*WYCYTrF`lxLphz2LII zo6w%q5CIgGg;lTQj~rLz(ag>SNw$A{KmQmn%6NfC;C@I*re!iQjAe%e6O>3#%c%z4 zWp1Funm<2_pKxYvLfZrJt*LlZwFC7kve!zt% zScD}!-igTz1|4NzGnUYFKcHx0q&W@aOTnrpQ(Li7R~Kbyg1D`K=qJeObRgb9_)hN@JOMM6Z}#nd6P!N`&a{7d~oB& zjp$faM{JG;W#3VdM)_#Iwl6CXk2thUdBJB@&xN`PafC-9vZCOgu|1A1lv*S9O?V;r za2BpeNASdToa)$17o)^sbtoKlEMCg=)6-+iqlddqXjqM2AJh_30=bV;aDSDqCP$7}3)TvS za|T8Lj^#vRcSYHQTtXDnLuHnJQ>eRfA>#cuH%T~L`J?Pd4Am7W^P=K3+rtVhGH3&> zLLLOQp^+2okpT%M$G4DCKpe7|dVVB9g&-wSD;*LUe8~!aAyd?2`LT{sz;dl9`4qtf zw55_B{~l&UW3^?IQ3`dC_A2w*Lt0R$Wzt*_0!{KUv4J>C)bzA)^xflPQ1yIS@g{4? z=LAw8o5sTB>0s^xQEfp?QgQvHbUIkQ2AJjUV;XH_<$Ztnr?#-m$Pv^7Q?!Be?_`SD zwayYBi>SzmW9`+*y*S9-?km{NYeQD$9p~0?=M3;neNqatt4_CWNFhy%NmMsagwje- zXbI*MnE867KT~`gLdmMQnBW7fn!4LYNhzVy@Z^$#tu3#|xO;Ig^O3fCCq6!YsFc4f z8O=~cCQPu*q$C&=3YaA9NF69=^b8!%Pm(3aj`hP+O9Ay1R6^qc{jpzF7KF16AhcmS z9%>SB43nw6ZE3286N~HBfl)yq;PKFqh25tSR}2a6G?AI(nBt@EPi8DI{nb9lfRM%4 zUX@aoc~aR)WJ&OBOh4tYLQeJuAX%3oM-7pzAvC-P3M$N`Tni!2HOP!>Ltk|%uRxj; zo(C7CHlm zab>*P;UFA)l#fZRF)J7hR@^2i1d(7uNyH#7h4F1PTghSriti=vdyA zbDg<501yUBHM;h48Nke3f3NQ*yb!X#*Y}_vx{|SJ*%;pLzefN}c zN)}fsFB+9rf2lP`_UU187oO3P4NW!R{R-E009~@bBADER=Cg~Zc^pd3gW#PeETvtq#GIiRM$IKA=wcWYL-= zFBvpvXrrgFreJtx_s;++#D~JdZi)z$cA)gY=Ikz-So|NXRAGHv=CJHrkdOaXdhH*m z(LweuI!;;vR0Tx*GOiU6{fr1B;yc zou)YSPJC|ejEe78PW(^()&Evn^22gsxLDx9`S{O&%$~Ze#Lx-=>SBVE?0I+Z{)Q)F zk}UiH@co-KO1kXCObavt_$y<|MwB(g?{_YYkIza#7YRQP;jPd?b&?nm?*h0KlNb$^ zSu0Vrh}lrY=O}8;Zua$$BzV_a*!;*?1XavN47tEz z24Tg0^aV6e9hN7U*dv0}?r2!X3h#90ZiQb#yI_kQ#A#Hz;~I!Y0hu(}7hsf61AN@y z%6gR4Mh`HCo)~Va@0Rb{jrI1qwiZjSi#VSRMLqn+K(hf=(>O&k9N?88Npm&zK}p6f zC397f!$c82m~pLmtMy$C(;5F6oZjFUU(LbO{+YD;lc(cHRh|SQm%vW>b6R*jUXYrB zUfXwN`%P*5&8Gi;GeLN0yv0E?ES<6^ej<&l3|dt6>X49lyl%sEx<$^|vUfQ>xGi2LOMZ z1*IW)Q%WO5$g)~E2cBaz#igC4R3F^_&m@!L^Pp3s@TE<%FSO>^CFuw!meSlJ91?E` z1&aL?oO6d09h(V~xEvIIC*V5A(d1QjH3cqUnXs*)fdF<-pzkf`{`^YGT%8PMPWjJ7iul*n{!M!y!56Nw6>H4?0-x(1~ABnIOBVw!nrJFjAQ zvIkVGDkpK0oj!XuODwQFs?HWAf2#Z*GpGlJ%g2X1Ru;yeHE1$*pm?SUbjEHpDU-%Q z07Tt8!FZ#-ezkQRhD+f(EhWT2PTwtsMB4d0L?__!#JrIUw>lFaAeyp6I$_4NxHRRT zg8`_uPHd&1cHld7R5;YfGC-v%OZx(4j-%s;h>u-ufKat-ti{qV^KPBlp^8Tv zRQLrN?oNpm*!6tOwW~y(p#33I@jrTrw`NBz%=BF*gPS6Dx0|uqpjQj)q7i~=` zragjqf3uRr3gT>drDtk^s#<&H3x_#sTL4l z*klIKkq|z+=WR3w6J%_4X6IAftpu%JwEH}R@l}b|vc((!P8F&K8P%}s;84^(zlCPd zh5ae&r`;sn!G|p#@s%BydS_U8ZXES$Fq-)@FFliYu_kXT_*9r?zyPtrL){_LzpD;I z+2^nZw)^zwE1Njps=5f3ASxEfLqn3GD820Lgql3;FMGb0R@;oN14HyOVe``V-EvHs zeNsXu8xuW9Sb#`iU?KOwM9cGh7w%s|`~vKQka!?vDdW1aDLj533%>1NR>ur~9fi&3 zI?7gTA)?vyt=_Bu9A|Oa;lB^wH=HwKMgBayq&?>kEkX9mY z2Rik!7xBLt3@bg@oKVfI+pyuM?skC4GN?7gQb7DDj1~$KO95e>*n{yB=(aXvJmFSY zpu~+=m&ucGXlU+e>=2Aj)B(lHnP%B7u|0I^| zI!e4$#Uq^To8GzR{^(^X@kc-5C(TEVm$O)=_iz-GE8Qca+AV$@JDgvAr1#h6=H)#6 z|A`+Fpvdf?gcb-Go-WJ^_YhydkBe-0qE!7^=DY-hyr1!vrj|eme!D(g7+W2cw2JJW%Y0NimRAm`vqZ_pMP=Bkd+UU( zr}6q0jqd%i{trL_9~a;MmksuR;0pJ)tp11p>W>SD5jpNJj^Te{St)=L1AQNYqjUky z^F&B8PFR<7zhOeIzP>k3<4aH==^_UUe?7Gp6g!ZaE-1wxq4Ka6KuHb1$+aXLXh~j7 zV;Wi_wjBLSMDT35xd;nlFd_qc3u0*QsLs27cFE#Vi_+#Vk6dJwCOK;UwY8G7-KQ;B zd~Vp@MLTvMQORESEMT1aE}QpG#aA~xX&gI`$sgx^Sz_5d1Q+BdJK&$!=kbsDBs)wR zspy+_S-416QHF8tRr2(aiZZhlWy)V95Bz`oTf{-s490e&c!4+RjuT(v$Ykv>I^SmgT!MIB%H=<5+&J zpwuqrdlLp@Rd#E;LRDiV^0vxHH7hF0+|Sy($vx57YQVWnSfkE7pQ6(Dcf;f|K0@nm zC{9YQJ|rKUH(RBzWafbgkO?zY`ZBivis6*PmX=u>8X9Rc>r8gBHtu4j{&ZR52P2-M zilWS^AAkghTo&S=OLy}6s^fM}+r_%6$Um}t7mKmz%4O|oaksvIIAd-rBbVNw)^}@` KJy^2+=>Gzq#V3vc literal 0 HcmV?d00001 diff --git a/src/components/protocol_handler/docs/assets/ptu_failed.png b/src/components/protocol_handler/docs/assets/ptu_failed.png new file mode 100644 index 0000000000000000000000000000000000000000..f9f5a6d144cbd978e1be5cffec25284fd4cc66c1 GIT binary patch literal 34454 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 literal 0 HcmV?d00001 From f3ce96ae1246c65dbf4e4ae536e5503107365c0e Mon Sep 17 00:00:00 2001 From: sniukalov Date: Thu, 30 May 2019 09:46:44 +0300 Subject: [PATCH 05/19] Added sending error on PTU retries exceed allowed count --- .../application_manager_impl.h | 3 +- .../application_manager/message_helper.h | 11 ++ .../policies/policy_handler.h | 5 +- .../policies/ptu_retry_handler.h | 66 ++++++++++++ .../hmi/on_system_request_notification.cc | 15 +++ .../src/application_manager_impl.cc | 5 + .../src/message_helper/message_helper.cc | 35 +++++-- .../src/policies/policy_handler.cc | 31 +++++- .../policies/policy_handler_interface.h | 7 +- .../policy_external/policy/policy_listener.h | 4 + .../policy_external/policy/policy_manager.h | 7 +- .../policy_regular/policy/policy_listener.h | 6 +- .../policy_regular/policy/policy_manager.h | 9 +- .../security_manager_listener.h | 2 +- .../policies/mock_policy_handler_interface.h | 1 + .../policy/mock_policy_listener.h | 2 + .../policy/mock_policy_manager.h | 7 +- .../include/policy/policy_manager_impl.h | 33 +++++- .../include/policy/policy_types.h | 2 + .../include/policy/ptu_retry_handler.h | 57 +++++++++++ .../src/policy_manager_impl.cc | 94 +++++++++++++++--- .../policy/policy_external/src/status.cc | 4 +- .../src/update_status_manager.cc | 9 ++ .../test/update_status_manager_test.cc | 32 ++++++ .../include/policy/policy_manager_impl.h | 6 +- .../include/policy/policy_types.h | 4 + .../policy_regular/src/policy_manager_impl.cc | 29 ++++-- .../policy/policy_regular/src/status.cc | 4 +- .../assets/PTU_for_EXTERNAL_PROPRIETARY.png | Bin 92488 -> 95754 bytes .../protocol_handler/handshake_handler.h | 2 +- .../protocol_handler/src/handshake_handler.cc | 4 +- .../src/security_manager_impl.cc | 18 +++- 32 files changed, 462 insertions(+), 52 deletions(-) create mode 100644 src/components/application_manager/include/application_manager/policies/ptu_retry_handler.h create mode 100644 src/components/policy/policy_external/include/policy/ptu_retry_handler.h diff --git a/src/components/application_manager/include/application_manager/application_manager_impl.h b/src/components/application_manager/include/application_manager/application_manager_impl.h index 7071610acba..3be9f56a3f4 100644 --- a/src/components/application_manager/include/application_manager/application_manager_impl.h +++ b/src/components/application_manager/include/application_manager/application_manager_impl.h @@ -585,8 +585,7 @@ class ApplicationManagerImpl utils::Optional service_update_reason) FINAL; - void OnPTUFailed() FINAL {} - + bool OnPTUFailed() FINAL; /* * @brief Starts audio pass thru thread * diff --git a/src/components/application_manager/include/application_manager/message_helper.h b/src/components/application_manager/include/application_manager/message_helper.h index 7b390d7adfc..480694e18de 100644 --- a/src/components/application_manager/include/application_manager/message_helper.h +++ b/src/components/application_manager/include/application_manager/message_helper.h @@ -89,6 +89,17 @@ class MessageHelper { static smart_objects::SmartObjectSPtr CreateHMINotification( hmi_apis::FunctionID::eType function_id); + /** + * @brief CreateOnSystemRequestNotificationToMobile creates mobile + * OnSystemRequestNotification + * @param policy_data pt snapshot data + * @param connection_key connection key of application + * @return OnSystemRequest notification smart object + */ + static smart_objects::SmartObjectSPtr + CreateOnSystemRequestNotificationToMobile( + const std::vector& policy_data, const uint32_t connection_key); + /** * @brief ServiceStatusUpdateNotificationBuilder small utility class used for * more flexible construction of OnServiceUpdateNotification diff --git a/src/components/application_manager/include/application_manager/policies/policy_handler.h b/src/components/application_manager/include/application_manager/policies/policy_handler.h index 39026b34208..d2dcc109f2b 100644 --- a/src/components/application_manager/include/application_manager/policies/policy_handler.h +++ b/src/components/application_manager/include/application_manager/policies/policy_handler.h @@ -103,8 +103,11 @@ class PolicyHandler : public PolicyHandlerInterface, void OnSnapshotCreated(const BinaryMessage& pt_string, const std::vector& retry_delay_seconds, uint32_t timeout_exchange) OVERRIDE; + + PTURetryHandler& ptu_retry_handler() const OVERRIDE; #else // EXTERNAL_PROPRIETARY_MODE - void OnSnapshotCreated(const BinaryMessage& pt_string) OVERRIDE; + void OnSnapshotCreated(const BinaryMessage& pt_string, + const PTUIterationType iteration_type) OVERRIDE; #endif // EXTERNAL_PROPRIETARY_MODE virtual bool GetPriority(const std::string& policy_app_id, std::string* priority) const OVERRIDE; diff --git a/src/components/application_manager/include/application_manager/policies/ptu_retry_handler.h b/src/components/application_manager/include/application_manager/policies/ptu_retry_handler.h new file mode 100644 index 00000000000..8d52641daf4 --- /dev/null +++ b/src/components/application_manager/include/application_manager/policies/ptu_retry_handler.h @@ -0,0 +1,66 @@ +/* + Copyright (c) 2019, Ford Motor Company + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following + disclaimer in the documentation and/or other materials provided with the + distribution. + + Neither the name of the Ford Motor Company nor the names of its contributors + may be used to endorse or promote products derived from this software + without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE. + */ +#ifndef SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_POLICIES_PTU_RETRY_HANDLER_H_ +#define SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_POLICIES_PTU_RETRY_HANDLER_H_ + +namespace policy { + +class PTURetryHandler { + public: + /** + * @brief Check whether allowed retry sequence count is exceeded + * @return bool value - true is allowed count is exceeded, otherwise - false + */ + virtual bool IsAllowedRetryCountExceeded() const = 0; + + /** + * @brief Begins new retry sequence + */ + virtual void BeginRetrySequence() = 0; + /** + * @brief Start timer waiting for OnSystemRequest from HMI. + */ + virtual void StartWaitingPTURetry() = 0; + + /** + * @brief Stop timer waiting for git OnSystemRequest from HMI. + */ + virtual void StopWaitingPTURetry() = 0; + + /** + * @brief Handle retry sequence failure + */ + virtual void RetrySequenceFailed() = 0; +}; +} // namespace policy + +#endif // SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_POLICIES_PTU_RETRY_HANDLER_H_ diff --git a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/hmi/on_system_request_notification.cc b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/hmi/on_system_request_notification.cc index a9670681b2d..6d95febe712 100644 --- a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/hmi/on_system_request_notification.cc +++ b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/hmi/on_system_request_notification.cc @@ -37,6 +37,10 @@ #include "sdl_rpc_plugin/commands/hmi/on_system_request_notification.h" #include "utils/macro.h" +#ifdef EXTERNAL_PROPRIETARY_MODE +#include "policy/ptu_retry_handler.h" +#endif // EXTERNAL_PROPRIETARY_MODE + using policy::PolicyHandlerInterface; namespace sdl_rpc_plugin { @@ -116,6 +120,17 @@ void OnSystemRequestNotification::Run() { "Sending request with application id " << app->policy_app_id()); params[strings::connection_key] = app->app_id(); + +#ifdef EXTERNAL_PROPRIETARY_MODE + using namespace rpc::policy_table_interface_base; + const auto request_type = + static_cast( + (*message_)[strings::msg_params][strings::request_type].asUInt()); + + if (RequestType::RT_PROPRIETARY == request_type) { + policy_handler_.ptu_retry_handler().OnSystemRequestReceived(); + } +#endif SendNotificationToMobile(message_); } diff --git a/src/components/application_manager/src/application_manager_impl.cc b/src/components/application_manager/src/application_manager_impl.cc index 6f5c5a82e34..1b8fd0187ed 100644 --- a/src/components/application_manager/src/application_manager_impl.cc +++ b/src/components/application_manager/src/application_manager_impl.cc @@ -2167,6 +2167,11 @@ bool ApplicationManagerImpl::OnHandshakeDone( return false; } +bool ApplicationManagerImpl::OnPTUFailed() { + LOG4CXX_AUTO_TRACE(logger_); + return false; +} + bool ApplicationManagerImpl::OnGetSystemTimeFailed() { LOG4CXX_AUTO_TRACE(logger_); return false; diff --git a/src/components/application_manager/src/message_helper/message_helper.cc b/src/components/application_manager/src/message_helper/message_helper.cc index c90711b675b..050e6726973 100644 --- a/src/components/application_manager/src/message_helper/message_helper.cc +++ b/src/components/application_manager/src/message_helper/message_helper.cc @@ -2465,31 +2465,54 @@ bool MessageHelper::SendUnsubscribedWayPoints(ApplicationManager& app_mngr) { return app_mngr.GetRPCService().ManageHMICommand(result); } +smart_objects::SmartObjectSPtr +MessageHelper::CreateOnSystemRequestNotificationToMobile( + const std::vector& policy_data, const uint32_t app_id) { + auto notification = + CreateNotification(mobile_apis::FunctionID::OnSystemRequestID, app_id); + + (*notification)[strings::params][strings::binary_data] = + smart_objects::SmartObject(policy_data); + +#if defined(PROPRIETARY_MODE) || defined(EXTERNAL_PROPRIETARY_MODE) + (*notification)[strings::msg_params][strings::request_type] = + mobile_apis::RequestType::PROPRIETARY; +#else + (*notification)[strings::msg_params][strings::request_type] = + mobile_apis::RequestType::HTTP; +#endif // PROPRIETARY || EXTERNAL_PROPRIETARY_MODE + + return notification; +} + void MessageHelper::SendPolicySnapshotNotification( uint32_t connection_key, const std::vector& policy_data, const std::string& url, ApplicationManager& app_mngr) { - smart_objects::SmartObject content(smart_objects::SmartType_Map); + auto notification = + CreateOnSystemRequestNotificationToMobile(policy_data, connection_key); if (!url.empty()) { - content[strings::msg_params][strings::url] = + (*notification)[strings::msg_params][strings::url] = url; // Doesn't work with mobile_notification::syncp_url ("URL") } else { LOG4CXX_WARN(logger_, "No service URLs"); } - content[strings::params][strings::binary_data] = + (*notification)[strings::params][strings::binary_data] = smart_objects::SmartObject(policy_data); #if defined(PROPRIETARY_MODE) || defined(EXTERNAL_PROPRIETARY_MODE) - content[strings::msg_params][strings::request_type] = + (*notification)[strings::msg_params][strings::request_type] = mobile_apis::RequestType::PROPRIETARY; #else - content[strings::msg_params][strings::request_type] = + (*notification)[strings::msg_params][strings::request_type] = mobile_apis::RequestType::HTTP; #endif // PROPRIETARY || EXTERNAL_PROPRIETARY_MODE - SendSystemRequestNotification(connection_key, content, app_mngr); + PrintSmartObject(*notification); + app_mngr.GetRPCService().ManageMobileCommand(notification, + commands::Command::SOURCE_SDL); } void MessageHelper::SendSystemRequestNotification( diff --git a/src/components/application_manager/src/policies/policy_handler.cc b/src/components/application_manager/src/policies/policy_handler.cc index 7085d7a86c9..b5f0371555b 100644 --- a/src/components/application_manager/src/policies/policy_handler.cc +++ b/src/components/application_manager/src/policies/policy_handler.cc @@ -58,6 +58,9 @@ #include "policy/policy_manager.h" #include "utils/helpers.h" +#ifdef EXTERNAL_PROPRIETARY_MODE +#include "policy/ptu_retry_handler.h" +#endif // EXTERNAL_PROPRIETARY_MODE namespace policy { @@ -443,6 +446,11 @@ uint32_t PolicyHandler::GetAppIdForSending() const { } #ifdef EXTERNAL_PROPRIETARY_MODE +PTURetryHandler& PolicyHandler::ptu_retry_handler() const { + LOG4CXX_AUTO_TRACE(logger_); + return *policy_manager_; +} + void PolicyHandler::OnAppPermissionConsent( const uint32_t connection_key, const PermissionConsent& permissions, @@ -1502,7 +1510,8 @@ void PolicyHandler::OnSnapshotCreated( } } #else // EXTERNAL_PROPRIETARY_MODE -void PolicyHandler::OnSnapshotCreated(const BinaryMessage& pt_string) { +void PolicyHandler::OnSnapshotCreated(const BinaryMessage& pt_string, + const PTUIterationType iteration_type) { LOG4CXX_AUTO_TRACE(logger_); POLICY_LIB_CHECK_VOID(); #ifdef PROPRIETARY_MODE @@ -1511,10 +1520,20 @@ void PolicyHandler::OnSnapshotCreated(const BinaryMessage& pt_string) { LOG4CXX_ERROR(logger_, "Snapshot processing skipped."); return; } - MessageHelper::SendPolicyUpdate(policy_snapshot_full_path, - TimeoutExchangeSec(), - policy_manager_->RetrySequenceDelaysSeconds(), - application_manager_); + + if (PTUIterationType::RetryIteration == iteration_type) { + auto on_system_request_notification = + MessageHelper::CreateOnSystemRequestNotificationToMobile( + pt_string, GetAppIdForSending()); + application_manager_.GetRPCService().ManageMobileCommand( + on_system_request_notification, commands::Command::SOURCE_SDL); + } else { + MessageHelper::SendPolicyUpdate( + policy_snapshot_full_path, + TimeoutExchangeSec(), + policy_manager_->RetrySequenceDelaysSeconds(), + application_manager_); + } #else // PROPRIETARY_MODE LOG4CXX_ERROR(logger_, "HTTP policy"); EndpointUrls urls; @@ -1634,6 +1653,7 @@ uint32_t PolicyHandler::TimeoutExchangeMSec() const { } void PolicyHandler::OnExceededTimeout() { + LOG4CXX_AUTO_TRACE(logger_); POLICY_LIB_CHECK_VOID(); std::for_each(listeners_.begin(), @@ -1831,6 +1851,7 @@ void PolicyHandler::ProcessCertDecryptFailed() { std::bind2nd(std::mem_fn(&PolicyHandlerObserver::OnCertDecryptFinished), false)); } + #else // EXTERNAL_PROPRIETARY_MODE void PolicyHandler::OnCertificateUpdated(const std::string& certificate_data) { LOG4CXX_AUTO_TRACE(logger_); diff --git a/src/components/include/application_manager/policies/policy_handler_interface.h b/src/components/include/application_manager/policies/policy_handler_interface.h index 8e450edd495..ae18779c035 100644 --- a/src/components/include/application_manager/policies/policy_handler_interface.h +++ b/src/components/include/application_manager/policies/policy_handler_interface.h @@ -59,6 +59,8 @@ typedef std::shared_ptr StatusNotifier; typedef std::shared_ptr PolicyEncryptionFlagGetterInterfaceSPtr; +class PTURetryHandler; + class PolicyHandlerInterface { public: virtual ~PolicyHandlerInterface() {} @@ -87,8 +89,11 @@ class PolicyHandlerInterface { virtual void OnSnapshotCreated(const BinaryMessage& pt_string, const std::vector& retry_delay_seconds, uint32_t timeout_exchange) = 0; + + virtual PTURetryHandler& ptu_retry_handler() const = 0; #else // EXTERNAL_PROPRIETARY_MODE - virtual void OnSnapshotCreated(const BinaryMessage& pt_string) = 0; + virtual void OnSnapshotCreated(const BinaryMessage& pt_string, + const PTUIterationType iteration_type) = 0; #endif // EXTERNAL_PROPRIETARY_MODE virtual bool GetPriority(const std::string& policy_app_id, diff --git a/src/components/include/policy/policy_external/policy/policy_listener.h b/src/components/include/policy/policy_external/policy/policy_listener.h index 8203f5c9b64..8220d05584a 100644 --- a/src/components/include/policy/policy_external/policy/policy_listener.h +++ b/src/components/include/policy/policy_external/policy/policy_listener.h @@ -42,6 +42,8 @@ namespace policy { namespace custom_str = utils::custom_string; +class PTURetryHandler; + class PolicyListener { public: virtual ~PolicyListener() {} @@ -187,6 +189,8 @@ class PolicyListener { * LockScreenDismissal */ virtual void OnLockScreenDismissalStateChanged() = 0; + + virtual PTURetryHandler& ptu_retry_handler() const = 0; }; } // namespace policy #endif // SRC_COMPONENTS_INCLUDE_POLICY_POLICY_EXTERNAL_POLICY_POLICY_LISTENER_H_ diff --git a/src/components/include/policy/policy_external/policy/policy_manager.h b/src/components/include/policy/policy_external/policy/policy_manager.h index 1242c7a460e..da1a99fcdee 100644 --- a/src/components/include/policy/policy_external/policy/policy_manager.h +++ b/src/components/include/policy/policy_external/policy/policy_manager.h @@ -44,6 +44,7 @@ #include "policy/policy_listener.h" #include "policy/policy_table/types.h" #include "policy/policy_types.h" +#include "policy/ptu_retry_handler.h" #include "policy/usage_statistics/statistics_manager.h" namespace policy { @@ -51,7 +52,8 @@ class PolicySettings; typedef std::shared_ptr StatusNotifier; class PolicyManager : public usage_statistics::StatisticsManager, - public PolicyEncryptionFlagGetterInterface { + public PolicyEncryptionFlagGetterInterface, + public PTURetryHandler { public: /** * @brief The NotificationMode enum defines whether application will be @@ -206,8 +208,9 @@ class PolicyManager : public usage_statistics::StatisticsManager, /** * @brief Resets retry sequence + * @param reset_type - reset retry count with sending OnStatusUpdate or not */ - virtual void ResetRetrySequence() = 0; + virtual void ResetRetrySequence(const ResetRetryCountType reset_type) = 0; /** * @brief Gets timeout to wait before next retry updating PT diff --git a/src/components/include/policy/policy_regular/policy/policy_listener.h b/src/components/include/policy/policy_regular/policy/policy_listener.h index 3e23df9710e..bbe220060e4 100644 --- a/src/components/include/policy/policy_regular/policy/policy_listener.h +++ b/src/components/include/policy/policy_regular/policy/policy_listener.h @@ -79,11 +79,13 @@ class PolicyListener { * * @param pt_string the snapshot * - * @param retry_seconds retry sequence timeouts. + * @param iteration_type flag indicating whether PTU was caused by retry + * sequence. * * @param timeout_exceed timeout. */ - virtual void OnSnapshotCreated(const BinaryMessage& pt_string) = 0; + virtual void OnSnapshotCreated(const BinaryMessage& pt_string, + const PTUIterationType iteration_type) = 0; /** * @brief Make appropriate changes for related applications permissions and diff --git a/src/components/include/policy/policy_regular/policy/policy_manager.h b/src/components/include/policy/policy_regular/policy/policy_manager.h index 65f4cb69ffc..27ae18eca80 100644 --- a/src/components/include/policy/policy_regular/policy/policy_manager.h +++ b/src/components/include/policy/policy_regular/policy/policy_manager.h @@ -117,7 +117,7 @@ class PolicyManager : public usage_statistics::StatisticsManager, /** * @brief PTU is needed, for this PTS has to be formed and sent. */ - virtual bool RequestPTUpdate() = 0; + virtual bool RequestPTUpdate(const PTUIterationType iteration_type) = 0; /** * @brief Check if specified RPC for specified application @@ -201,6 +201,13 @@ class PolicyManager : public usage_statistics::StatisticsManager, */ virtual std::string ForcePTExchangeAtUserRequest() = 0; + /** + * @brief Resets retry sequence + * @param send_event - if true corresponding event is sent to + * UpdateStatusManager + */ + virtual void ResetRetrySequence(const ResetRetryCountType reset_type) = 0; + /** * @brief Gets timeout to wait before next retry updating PT * If timeout is less or equal to zero then the retry sequence is not need. diff --git a/src/components/include/security_manager/security_manager_listener.h b/src/components/include/security_manager/security_manager_listener.h index f7148d31654..0648ed0a11f 100644 --- a/src/components/include/security_manager/security_manager_listener.h +++ b/src/components/include/security_manager/security_manager_listener.h @@ -59,7 +59,7 @@ class SecurityManagerListener { */ virtual void OnCertificateUpdateRequired() = 0; - virtual void OnPTUFailed() = 0; + virtual bool OnPTUFailed() = 0; #ifdef EXTERNAL_PROPRIETARY_MODE /** diff --git a/src/components/include/test/application_manager/policies/mock_policy_handler_interface.h b/src/components/include/test/application_manager/policies/mock_policy_handler_interface.h index f5b6f28825a..c292272d4c2 100644 --- a/src/components/include/test/application_manager/policies/mock_policy_handler_interface.h +++ b/src/components/include/test/application_manager/policies/mock_policy_handler_interface.h @@ -261,6 +261,7 @@ class MockPolicyHandlerInterface : public policy::PolicyHandlerInterface { #ifdef EXTERNAL_PROPRIETARY_MODE MOCK_CONST_METHOD0(GetMetaInfo, const policy::MetaInfo()); + MOCK_METHOD0(IncrementRetryIndex, void()); #endif // EXTERNAL_PROPRIETARY_MODE MOCK_METHOD1(Increment, void(usage_statistics::GlobalCounterId type)); diff --git a/src/components/include/test/policy/policy_external/policy/mock_policy_listener.h b/src/components/include/test/policy/policy_external/policy/mock_policy_listener.h index f65138e4898..0faa6d6dea1 100644 --- a/src/components/include/test/policy/policy_external/policy/mock_policy_listener.h +++ b/src/components/include/test/policy/policy_external/policy/mock_policy_listener.h @@ -113,6 +113,8 @@ class MockPolicyListener : public ::policy::PolicyListener { const std::string& hmi_level)); MOCK_METHOD0(OnLockScreenDismissalStateChanged, void()); MOCK_METHOD1(OnCertDecryptFinished, void(bool)); + MOCK_METHOD0(IncrementRetryIndex, void()); + MOCK_CONST_METHOD0(IsAllowedPTURetriesExceeded, bool()); }; } // namespace policy_test diff --git a/src/components/include/test/policy/policy_external/policy/mock_policy_manager.h b/src/components/include/test/policy/policy_external/policy/mock_policy_manager.h index 7c716430444..82edd959d21 100644 --- a/src/components/include/test/policy/policy_external/policy/mock_policy_manager.h +++ b/src/components/include/test/policy/policy_external/policy/mock_policy_manager.h @@ -102,7 +102,7 @@ class MockPolicyManager : public PolicyManager { MOCK_METHOD0(IncrementIgnitionCycles, void()); MOCK_METHOD0(ForcePTExchange, std::string()); MOCK_METHOD0(ForcePTExchangeAtUserRequest, std::string()); - MOCK_METHOD0(ResetRetrySequence, void()); + MOCK_METHOD1(ResetRetrySequence, void(const bool send_event)); MOCK_METHOD0(NextRetryTimeout, int()); MOCK_METHOD0(TimeoutExchangeMSec, uint32_t()); MOCK_METHOD0(RetrySequenceDelaysSeconds, const std::vector()); @@ -291,6 +291,11 @@ class MockPolicyManager : public PolicyManager { RequestType::State(const std::string& policy_app_id)); MOCK_CONST_METHOD1(GetAppRequestSubTypesState, RequestSubType::State(const std::string& policy_app_id)); + MOCK_METHOD0(IncrementPTURetryIndex, void()); + MOCK_CONST_METHOD0(IsAllowedPTURetryCountExceeded, bool()); + MOCK_CONST_METHOD0(IsAllowedRetryCountExceeded, bool()); + MOCK_METHOD0(OnSystemRequestReceived, void()); + MOCK_METHOD0(RetrySequenceFailed, void()); }; } // namespace policy_manager_test } // namespace components diff --git a/src/components/policy/policy_external/include/policy/policy_manager_impl.h b/src/components/policy/policy_external/include/policy/policy_manager_impl.h index cb06a65e411..ed4d2f7a016 100644 --- a/src/components/policy/policy_external/include/policy/policy_manager_impl.h +++ b/src/components/policy/policy_external/include/policy/policy_manager_impl.h @@ -44,6 +44,7 @@ #include "policy/update_status_manager.h" #include "policy/usage_statistics/statistics_manager.h" #include "utils/lock.h" +#include "utils/timer.h" namespace policy_table = rpc::policy_table_interface_base; @@ -220,8 +221,10 @@ class PolicyManagerImpl : public PolicyManager { /** * @brief Resets retry sequence + * @param send_event - if true corresponding event is sent to + * UpdateStatusManager */ - void ResetRetrySequence() OVERRIDE; + void ResetRetrySequence(const ResetRetryCountType reset_type) OVERRIDE; /** * @brief Gets timeout to wait before next retry updating PT @@ -885,8 +888,25 @@ class PolicyManagerImpl : public PolicyManager { void Add(const std::string& app_id, usage_statistics::AppStopwatchId type, int32_t timespan_seconds) OVERRIDE; + // Interface StatisticsManager (end) + /** + * @brief Check whether allowed retry sequence count is exceeded + * @return bool value - true is allowed count is exceeded, otherwise - false + */ + bool IsAllowedRetryCountExceeded() const OVERRIDE; + + /** + * @brief Finish PTU retry requence + */ + void RetrySequenceFailed() OVERRIDE; + + /** + * @brief Begins new retry sequence + */ + void OnSystemRequestReceived() OVERRIDE; + protected: /** * @brief Parse policy table content and convert to PT object @@ -897,6 +917,11 @@ class PolicyManagerImpl : public PolicyManager { const BinaryMessage& pt_content); private: + /** + * @brief Increments PTU retry index for external flow + */ + void IncrementRetryIndex(); + /** * @brief Checks if PT update should be started and schedules it if needed */ @@ -1303,6 +1328,12 @@ class PolicyManagerImpl : public PolicyManager { * @brief Flag for notifying that invalid PTU should be triggered */ bool trigger_ptu_; + + /** + * @brief Flag that indicates whether a PTU sequence (including retries) is in + * progress + */ + bool is_ptu_in_progress_; }; } // namespace policy diff --git a/src/components/policy/policy_external/include/policy/policy_types.h b/src/components/policy/policy_external/include/policy/policy_types.h index fcf6c33c1bc..fe63ae34792 100644 --- a/src/components/policy/policy_external/include/policy/policy_types.h +++ b/src/components/policy/policy_external/include/policy/policy_types.h @@ -122,6 +122,8 @@ typedef std::vector StringArray; enum PermitResult { kRpcAllowed = 0, kRpcDisallowed, kRpcUserDisallowed }; +enum class ResetRetryCountType { kResetWithStatusUpdate = 0, kResetInternally }; + /** * @struct Stores result of check: * if HMI Level was allowed for RPC to work in diff --git a/src/components/policy/policy_external/include/policy/ptu_retry_handler.h b/src/components/policy/policy_external/include/policy/ptu_retry_handler.h new file mode 100644 index 00000000000..79623124e3d --- /dev/null +++ b/src/components/policy/policy_external/include/policy/ptu_retry_handler.h @@ -0,0 +1,57 @@ +/* + Copyright (c) 2019, Ford Motor Company + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following + disclaimer in the documentation and/or other materials provided with the + distribution. + + Neither the name of the Ford Motor Company nor the names of its contributors + may be used to endorse or promote products derived from this software + without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE. + */ +#ifndef SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_POLICIES_PTU_RETRY_HANDLER_H_ +#define SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_POLICIES_PTU_RETRY_HANDLER_H_ + +namespace policy { + +class PTURetryHandler { + public: + /** + * @brief Check whether allowed retry sequence count is exceeded + * @return bool value - true is allowed count is exceeded, otherwise - false + */ + virtual bool IsAllowedRetryCountExceeded() const = 0; + + /** + * @brief Begins new retry sequence + */ + virtual void OnSystemRequestReceived() = 0; + + /** + * @brief Handle OnSystemRequest from HMI timeout + */ + virtual void RetrySequenceFailed() = 0; +}; +} // namespace policy + +#endif // SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_POLICIES_PTU_RETRY_HANDLER_H_ diff --git a/src/components/policy/policy_external/src/policy_manager_impl.cc b/src/components/policy/policy_external/src/policy_manager_impl.cc index 255f6050a63..1b8c7a8c876 100644 --- a/src/components/policy/policy_external/src/policy_manager_impl.cc +++ b/src/components/policy/policy_external/src/policy_manager_impl.cc @@ -52,6 +52,8 @@ #include "policy/access_remote.h" #include "policy/access_remote_impl.h" +#include "policy/ptu_retry_handler.h" +#include "utils/timer_task_impl.h" __attribute__((visibility("default"))) policy::PolicyManager* CreateManager() { return new policy::PolicyManagerImpl(); @@ -220,7 +222,8 @@ PolicyManagerImpl::PolicyManagerImpl() , retry_sequence_timeout_(60) , retry_sequence_index_(0) , ignition_check(true) - , retry_sequence_url_(0, 0, "") {} + , retry_sequence_url_(0, 0, "") + , is_ptu_in_progress_(false) {} PolicyManagerImpl::PolicyManagerImpl(bool in_memory) : PolicyManager() @@ -234,7 +237,8 @@ PolicyManagerImpl::PolicyManagerImpl(bool in_memory) , retry_sequence_url_(0, 0, "") , wrong_ptu_update_received_(false) , send_on_update_sent_out_(false) - , trigger_ptu_(false) {} + , trigger_ptu_(false) + , is_ptu_in_progress_(false) {} void PolicyManagerImpl::set_listener(PolicyListener* listener) { listener_ = listener; @@ -832,6 +836,9 @@ void PolicyManagerImpl::CheckPermissions(const PTString& device_id, LOG4CXX_INFO(logger_, "CheckPermissions for " << app_id << " and rpc " << rpc << " for " << hmi_level << " level."); + + const std::string device_id = GetCurrentDeviceId(app_id); + Permissions rpc_permissions; // Check, if there are calculated permission present in cache @@ -1003,6 +1010,7 @@ policy_table::Strings PolicyManagerImpl::GetGroupsNames( void PolicyManagerImpl::SendNotificationOnPermissionsUpdated( const std::string& device_id, const std::string& application_id) { LOG4CXX_AUTO_TRACE(logger_); + const std::string device_id = GetCurrentDeviceId(application_id); if (device_id.empty()) { LOG4CXX_WARN(logger_, "Couldn't find device info for application id " @@ -1108,7 +1116,7 @@ bool PolicyManagerImpl::ReactOnUserDevConsentForApp( } if (permissions.requestTypeChanged || (!permissions.priority.empty())) { - auto device_id = GetCurrentDeviceId(device_handle, app_id); + const auto& device_id = GetCurrentDeviceId(device_handle, app_id); listener_->SendOnAppPermissionsChanged(permissions, device_id, app_id); } return result; @@ -1287,6 +1295,36 @@ void PolicyManagerImpl::SetUserConsentForApp( updated_app_group_permissons); } +bool PolicyManagerImpl::IsAllowedRetryCountExceeded() const { + LOG4CXX_AUTO_TRACE(logger_); + return retry_sequence_index_ > retry_sequence_seconds_.size(); +} + +void PolicyManagerImpl::IncrementRetryIndex() { + LOG4CXX_AUTO_TRACE(logger_); + + ++retry_sequence_index_; + LOG4CXX_DEBUG(logger_, + "current retry_sequence_index_ is: " << retry_sequence_index_); +} + +void PolicyManagerImpl::RetrySequenceFailed() { + LOG4CXX_AUTO_TRACE(logger_); + + listener_->OnPTUFinished(false); + ResetRetrySequence(ResetRetryCountType::kResetWithStatusUpdate); +} + +void PolicyManagerImpl::OnSystemRequestReceived() { + LOG4CXX_AUTO_TRACE(logger_); + + if (is_ptu_in_progress_) { + IncrementRetryIndex(); + } else { + is_ptu_in_progress_ = true; + } +} + bool PolicyManagerImpl::GetDefaultHmi(const std::string& device_id, const std::string& policy_app_id, std::string* default_hmi) const { @@ -1395,11 +1433,13 @@ void PolicyManagerImpl::GetPermissionsForApp( } bool allowed_by_default = false; - if (cache_->IsDefaultPolicy(policy_app_id)) { + const auto device_consent = GetUserConsentForDevice(device_id); + if ((policy::kDeviceAllowed == device_consent) && + cache_->IsDefaultPolicy(policy_app_id)) { app_id_to_check = kDefaultId; allowed_by_default = true; } else if (cache_->IsPredataPolicy(policy_app_id) || - policy::kDeviceDisallowed == GetUserConsentForDevice(device_id)) { + policy::kDeviceAllowed != device_consent) { app_id_to_check = kPreDataConsentId; allowed_by_default = true; } @@ -1592,7 +1632,7 @@ void PolicyManagerImpl::UpdateAppConsentWithExternalConsent( void PolicyManagerImpl::NotifySystem( const std::string& device_id, - const AppPoliciesValueType& app_policy) const { + const PolicyManagerImpl::AppPoliciesValueType& app_policy) const { listener()->OnPendingPermissionChange(device_id, app_policy.first); } @@ -1767,12 +1807,14 @@ void PolicyManagerImpl::KmsChanged(int kilometers) { const boost::optional PolicyManagerImpl::LockScreenDismissalEnabledState() const { + LOG4CXX_AUTO_TRACE(logger_); return cache_->LockScreenDismissalEnabledState(); } const boost::optional PolicyManagerImpl::LockScreenDismissalWarningMessage( const std::string& language) const { + LOG4CXX_AUTO_TRACE(logger_); return cache_->LockScreenDismissalWarningMessage(language); } @@ -1801,10 +1843,11 @@ int PolicyManagerImpl::NextRetryTimeout() { sync_primitives::AutoLock auto_lock(retry_sequence_lock_); LOG4CXX_DEBUG(logger_, "Index: " << retry_sequence_index_); int next = 0; + if (!retry_sequence_seconds_.empty() && retry_sequence_index_ < retry_sequence_seconds_.size()) { - next = retry_sequence_seconds_[retry_sequence_index_]; - ++retry_sequence_index_; + next = retry_sequence_seconds_[retry_sequence_index_] * + date_time::MILLISECONDS_IN_SECOND; } return next; } @@ -1816,10 +1859,15 @@ void PolicyManagerImpl::RefreshRetrySequence() { cache_->SecondsBetweenRetries(retry_sequence_seconds_); } -void PolicyManagerImpl::ResetRetrySequence() { +void PolicyManagerImpl::ResetRetrySequence( + const ResetRetryCountType reset_type) { + LOG4CXX_AUTO_TRACE(logger_); sync_primitives::AutoLock auto_lock(retry_sequence_lock_); retry_sequence_index_ = 0; - update_status_manager_.OnResetRetrySequence(); + is_ptu_in_progress_ = false; + if (ResetRetryCountType::kResetWithStatusUpdate == reset_type) { + update_status_manager_.OnResetRetrySequence(); + } } uint32_t PolicyManagerImpl::TimeoutExchangeMSec() { @@ -1832,6 +1880,8 @@ const std::vector PolicyManagerImpl::RetrySequenceDelaysSeconds() { } void PolicyManagerImpl::OnExceededTimeout() { + LOG4CXX_AUTO_TRACE(logger_); + update_status_manager_.OnUpdateTimeoutOccurs(); } @@ -1885,7 +1935,7 @@ bool PolicyManagerImpl::IsApplicationRevoked(const std::string& app_id) const { bool PolicyManagerImpl::IsConsentNeeded(const std::string& device_id, const std::string& app_id) { LOG4CXX_AUTO_TRACE(logger_); - int count = cache_->CountUnconsentedGroups(app_id, device_id); + const int count = cache_->CountUnconsentedGroups(app_id, device_id); LOG4CXX_DEBUG(logger_, "There are: " << count << " unconsented groups."); return count != 0; } @@ -2029,7 +2079,10 @@ StatusNotifier PolicyManagerImpl::AddApplication( const std::string& application_id, const rpc::policy_table_interface_base::AppHmiTypes& hmi_types) { LOG4CXX_AUTO_TRACE(logger_); - DeviceConsent device_consent = GetUserConsentForDevice(device_id); + auto device_consent = GetUserConsentForDevice(device_id); + LOG4CXX_DEBUG(logger_, + "check_device_id: " << device_id << " check_device_consent: " + << device_consent); sync_primitives::AutoLock lock(apps_registration_lock_); if (IsNewApplication(application_id)) { LOG4CXX_DEBUG(logger_, "Adding new application"); @@ -2067,6 +2120,7 @@ void PolicyManagerImpl::ProcessExternalConsentStatusForApp( CalculateGroupsConsentFromExternalConsent( groups_by_status, allowed_groups, disallowed_groups); + LOG4CXX_DEBUG(logger_, "check device_id: " << device_id); UpdateAppConsentWithExternalConsent(device_id, application_id, allowed_groups, @@ -2106,8 +2160,16 @@ void PolicyManagerImpl::PromoteExistedApplication( DeviceConsent device_consent) { // If device consent changed to allowed during application being // disconnected, app permissions should be changed also + LOG4CXX_DEBUG(logger_, + "kDeviceAllowed == device_consent: " + << (kDeviceAllowed == device_consent) + << " device_consent: " << device_consent); if (kDeviceAllowed == device_consent && cache_->IsPredataPolicy(application_id)) { + LOG4CXX_INFO(logger_, + "Setting " + << policy::kDefaultId + << " permissions for application id: " << application_id); cache_->SetDefaultPolicy(application_id); } ProcessExternalConsentStatusForApp( @@ -2173,6 +2235,11 @@ uint32_t PolicyManagerImpl::HeartBeatTimeout(const std::string& app_id) const { } void PolicyManagerImpl::SaveUpdateStatusRequired(bool is_update_needed) { + LOG4CXX_AUTO_TRACE(logger_); + + if (!is_update_needed) { + ResetRetrySequence(ResetRetryCountType::kResetInternally); + } cache_->SaveUpdateRequired(is_update_needed); } @@ -2196,8 +2263,7 @@ void PolicyManagerImpl::SetDefaultHmiTypes( const std::string& application_id, const std::vector& hmi_types) { LOG4CXX_INFO(logger_, "SetDefaultHmiTypes"); - const std::string device_id = - GetCurrentDeviceId(device_handle, application_id); + const auto device_id = GetCurrentDeviceId(device_handle, application_id); ApplicationOnDevice who = {device_id, application_id}; access_remote_->SetDefaultHmiTypes(who, hmi_types); } diff --git a/src/components/policy/policy_external/src/status.cc b/src/components/policy/policy_external/src/status.cc index c2ee4e4bbcb..3d1cae3eba2 100644 --- a/src/components/policy/policy_external/src/status.cc +++ b/src/components/policy/policy_external/src/status.cc @@ -99,9 +99,11 @@ void policy::UpdatingStatus::ProcessEvent(policy::UpdateStatusManager* manager, break; case kScheduleUpdate: case kScheduleManualUpdate: - case kOnResetRetrySequence: manager->SetPostponedStatus(std::make_shared()); break; + case kOnResetRetrySequence: + manager->SetNextStatus(std::make_shared()); + break; default: break; } diff --git a/src/components/policy/policy_external/src/update_status_manager.cc b/src/components/policy/policy_external/src/update_status_manager.cc index b352b5ea39e..050908f3a02 100644 --- a/src/components/policy/policy_external/src/update_status_manager.cc +++ b/src/components/policy/policy_external/src/update_status_manager.cc @@ -32,6 +32,7 @@ #include "policy/update_status_manager.h" #include "policy/policy_listener.h" +#include "policy/ptu_retry_handler.h" #include "utils/logger.h" namespace policy { @@ -87,6 +88,14 @@ void UpdateStatusManager::OnUpdateSentOut(uint32_t update_timeout) { void UpdateStatusManager::OnUpdateTimeoutOccurs() { LOG4CXX_AUTO_TRACE(logger_); + + auto& ptu_retry_handler = listener_->ptu_retry_handler(); + + if (ptu_retry_handler.IsAllowedRetryCountExceeded()) { + ptu_retry_handler.RetrySequenceFailed(); + return; + } + ProcessEvent(kOnUpdateTimeout); DCHECK(update_status_thread_delegate_); update_status_thread_delegate_->updateTimeOut(0); // Stop Timer diff --git a/src/components/policy/policy_external/test/update_status_manager_test.cc b/src/components/policy/policy_external/test/update_status_manager_test.cc index f5192471cca..0577e6741d0 100644 --- a/src/components/policy/policy_external/test/update_status_manager_test.cc +++ b/src/components/policy/policy_external/test/update_status_manager_test.cc @@ -121,6 +121,8 @@ TEST_F(UpdateStatusManagerTest, WaitAsync waiter(count, timeout); EXPECT_CALL(listener_, OnUpdateStatusChanged(_)) .WillRepeatedly(NotifyAsync(&waiter)); + EXPECT_CALL(listener_, IsAllowedPTURetriesExceeded()) + .WillRepeatedly(Return(false)); manager_->ScheduleUpdate(); manager_->OnUpdateSentOut(k_timeout_); status_ = manager_->GetLastUpdateStatus(); @@ -131,6 +133,36 @@ TEST_F(UpdateStatusManagerTest, EXPECT_EQ(StatusUpdateRequired, status_); } +TEST_F( + UpdateStatusManagerTest, + OnUpdateSentOut_WaitForTimeoutExpired_ExpectStatusUpdateNeeded_RetryExceeded) { + sync_primitives::Lock lock; + sync_primitives::AutoLock auto_lock(lock); + const uint32_t count = 3u; + const uint32_t timeout = 2u * k_timeout_; + WaitAsync waiter(count, timeout); + EXPECT_CALL(listener_, OnUpdateStatusChanged(_)) + .WillRepeatedly(NotifyAsync(&waiter)); + manager_->ScheduleUpdate(); + manager_->OnUpdateSentOut(k_timeout_); + status_ = manager_->GetLastUpdateStatus(); + { + ::testing::InSequence s; + EXPECT_CALL(listener_, IsAllowedPTURetriesExceeded()) + .WillRepeatedly(Return(false)); + EXPECT_CALL(listener_, IsAllowedPTURetriesExceeded()) + .WillRepeatedly(Return(false)); + EXPECT_CALL(listener_, IsAllowedPTURetriesExceeded()) + .WillRepeatedly(Return(true)); + EXPECT_CALL(listener_, OnPTUFinished(false)); + } + EXPECT_EQ(StatusUpdatePending, status_); + EXPECT_TRUE(waiter.Wait(auto_lock)); + status_ = manager_->GetLastUpdateStatus(); + // Check + EXPECT_EQ(StatusUpdateRequired, status_); +} + TEST_F(UpdateStatusManagerTest, OnUpdateTimeOutOccurs_ExpectStatusUpdateNeeded) { // Arrange diff --git a/src/components/policy/policy_regular/include/policy/policy_manager_impl.h b/src/components/policy/policy_regular/include/policy/policy_manager_impl.h index c14fb0e1422..7acca8bdee5 100644 --- a/src/components/policy/policy_regular/include/policy/policy_manager_impl.h +++ b/src/components/policy/policy_regular/include/policy/policy_manager_impl.h @@ -183,7 +183,7 @@ class PolicyManagerImpl : public PolicyManager { /** * @brief PTU is needed, for this PTS has to be formed and sent. */ - bool RequestPTUpdate() OVERRIDE; + bool RequestPTUpdate(const PTUIterationType iteration_type) OVERRIDE; /** * @brief Check if specified RPC for specified application @@ -247,8 +247,10 @@ class PolicyManagerImpl : public PolicyManager { /** * @brief Resets retry sequence + * @param send_event - if true corresponding event is sent to + * UpdateStatusManager */ - void ResetRetrySequence(); + void ResetRetrySequence(const ResetRetryCountType reset_type) OVERRIDE; /** * @brief Gets timeout to wait before next retry updating PT diff --git a/src/components/policy/policy_regular/include/policy/policy_types.h b/src/components/policy/policy_regular/include/policy/policy_types.h index 2794615cb47..08ff9b42857 100644 --- a/src/components/policy/policy_regular/include/policy/policy_types.h +++ b/src/components/policy/policy_regular/include/policy/policy_types.h @@ -78,6 +78,10 @@ enum PolicyTableStatus { StatusUnknown }; +enum class PTUIterationType { DefaultIteration = 0, RetryIteration }; + +enum class ResetRetryCountType { kResetWithStatusUpdate = 0, kResetInternally }; + typedef rpc::Optional EncryptionRequired; // Code generator uses String class name, so this typedef was renamed to PTSring diff --git a/src/components/policy/policy_regular/src/policy_manager_impl.cc b/src/components/policy/policy_regular/src/policy_manager_impl.cc index 6871a5c4164..5b9856193ec 100644 --- a/src/components/policy/policy_regular/src/policy_manager_impl.cc +++ b/src/components/policy/policy_regular/src/policy_manager_impl.cc @@ -316,6 +316,7 @@ bool PolicyManagerImpl::LoadPT(const std::string& file, FilterPolicyTable(pt_update->policy_table); if (!IsPTValid(pt_update, policy_table::PT_UPDATE)) { wrong_ptu_update_received_ = true; + ResetRetrySequence(ResetRetryCountType::kResetInternally); update_status_manager_.OnWrongUpdateReceived(); return false; } @@ -519,7 +520,7 @@ void PolicyManagerImpl::GetUpdateUrls(const uint32_t service_type, cache_->GetUpdateUrls(service_type, out_end_points); } -bool PolicyManagerImpl::RequestPTUpdate() { +bool PolicyManagerImpl::RequestPTUpdate(const PTUIterationType iteration_type) { LOG4CXX_AUTO_TRACE(logger_); std::shared_ptr policy_table_snapshot = cache_->GenerateSnapshot(); @@ -538,7 +539,7 @@ bool PolicyManagerImpl::RequestPTUpdate() { BinaryMessage update(message_string.begin(), message_string.end()); - listener_->OnSnapshotCreated(update); + listener_->OnSnapshotCreated(update, iteration_type); return true; } @@ -580,7 +581,8 @@ void PolicyManagerImpl::StartPTExchange() { } if (update_status_manager_.IsUpdateRequired()) { - if (RequestPTUpdate() && !timer_retry_sequence_.is_running()) { + if (RequestPTUpdate(PTUIterationType::DefaultIteration) && + !timer_retry_sequence_.is_running()) { // Start retry sequency const uint32_t timeout_msec = NextRetryTimeout(); @@ -1192,6 +1194,7 @@ std::string PolicyManagerImpl::GetPolicyTableStatus() const { } uint32_t PolicyManagerImpl::NextRetryTimeout() { + LOG4CXX_AUTO_TRACE(logger_); sync_primitives::AutoLock auto_lock(retry_sequence_lock_); LOG4CXX_DEBUG(logger_, "Index: " << retry_sequence_index_); uint32_t next = 0u; @@ -1224,10 +1227,14 @@ void PolicyManagerImpl::RefreshRetrySequence() { cache_->SecondsBetweenRetries(retry_sequence_seconds_); } -void PolicyManagerImpl::ResetRetrySequence() { +void PolicyManagerImpl::ResetRetrySequence( + const ResetRetryCountType reset_type) { + LOG4CXX_AUTO_TRACE(logger_); sync_primitives::AutoLock auto_lock(retry_sequence_lock_); retry_sequence_index_ = 0; - update_status_manager_.OnResetRetrySequence(); + if (ResetRetryCountType::kResetWithStatusUpdate == reset_type) { + update_status_manager_.OnResetRetrySequence(); + } } uint32_t PolicyManagerImpl::TimeoutExchangeMSec() { @@ -1496,6 +1503,11 @@ uint32_t PolicyManagerImpl::HeartBeatTimeout(const std::string& app_id) const { } void PolicyManagerImpl::SaveUpdateStatusRequired(bool is_update_needed) { + LOG4CXX_AUTO_TRACE(logger_); + + if (!is_update_needed) { + ResetRetrySequence(ResetRetryCountType::kResetInternally); + } cache_->SaveUpdateRequired(is_update_needed); } @@ -1513,6 +1525,11 @@ void PolicyManagerImpl::StartRetrySequence() { if (is_exceeded_retries_count) { LOG4CXX_WARN(logger_, "Exceeded allowed PTU retry count"); listener_->OnPTUTimeOut(); + ResetRetrySequence(ResetRetryCountType::kResetWithStatusUpdate); + if (timer_retry_sequence_.is_running()) { + timer_retry_sequence_.Stop(); + } + return; } update_status_manager_.OnUpdateTimeoutOccurs(); @@ -1526,7 +1543,7 @@ void PolicyManagerImpl::StartRetrySequence() { return; } - RequestPTUpdate(); + RequestPTUpdate(PTUIterationType::RetryIteration); timer_retry_sequence_.Start(timeout_msec, timer::kPeriodic); } diff --git a/src/components/policy/policy_regular/src/status.cc b/src/components/policy/policy_regular/src/status.cc index 00a6a95af34..114ecb9f97b 100644 --- a/src/components/policy/policy_regular/src/status.cc +++ b/src/components/policy/policy_regular/src/status.cc @@ -101,9 +101,11 @@ void policy::UpdatingStatus::ProcessEvent( manager->SetPostponedStatus(std::make_shared()); break; case kScheduleUpdate: - case kOnResetRetrySequence: manager->SetPostponedStatus(std::make_shared()); break; + case kOnResetRetrySequence: + manager->SetNextStatus(std::make_shared()); + break; default: break; } diff --git a/src/components/protocol_handler/docs/assets/PTU_for_EXTERNAL_PROPRIETARY.png b/src/components/protocol_handler/docs/assets/PTU_for_EXTERNAL_PROPRIETARY.png index 19173570aa873497d88709b9a9a38aec6d18df48..5962a1f08b55b84fb901e26b8d3bae129f134e57 100644 GIT binary patch delta 24237 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 delta 21081 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 diff --git a/src/components/protocol_handler/include/protocol_handler/handshake_handler.h b/src/components/protocol_handler/include/protocol_handler/handshake_handler.h index 2c7f7de67ec..5be513049d9 100644 --- a/src/components/protocol_handler/include/protocol_handler/handshake_handler.h +++ b/src/components/protocol_handler/include/protocol_handler/handshake_handler.h @@ -90,7 +90,7 @@ class HandshakeHandler : public security_manager::SecurityManagerListener { */ void OnCertificateUpdateRequired() OVERRIDE; - void OnPTUFailed() OVERRIDE; + bool OnPTUFailed() OVERRIDE; #ifdef EXTERNAL_PROPRIETARY_MODE /** diff --git a/src/components/protocol_handler/src/handshake_handler.cc b/src/components/protocol_handler/src/handshake_handler.cc index 2109e637a45..405715fe1be 100644 --- a/src/components/protocol_handler/src/handshake_handler.cc +++ b/src/components/protocol_handler/src/handshake_handler.cc @@ -103,11 +103,13 @@ bool HandshakeHandler::OnGetSystemTimeFailed() { return true; } -void HandshakeHandler::OnPTUFailed() { +bool HandshakeHandler::OnPTUFailed() { LOG4CXX_AUTO_TRACE(logger_); if (payload_) { ProcessFailedHandshake(*payload_, ServiceStatus::PTU_FAILED); } + + return true; } bool HandshakeHandler::OnHandshakeDone( diff --git a/src/components/security_manager/src/security_manager_impl.cc b/src/components/security_manager/src/security_manager_impl.cc index 488b4745be0..41e2b07a030 100644 --- a/src/components/security_manager/src/security_manager_impl.cc +++ b/src/components/security_manager/src/security_manager_impl.cc @@ -415,9 +415,21 @@ void SecurityManagerImpl::ProcessFailedPTU() { LOG4CXX_DEBUG(logger_, "listeners arrays IS EMPTY!"); return; } - std::for_each(listeners_.begin(), - listeners_.end(), - std::mem_fun(&SecurityManagerListener::OnPTUFailed)); + + std::list listeners_to_remove; + for (auto listener : listeners_) { + if (listener->OnPTUFailed()) { + listeners_to_remove.push_back(listener); + } + } + + for (auto& listener : listeners_to_remove) { + auto it = std::find(listeners_.begin(), listeners_.end(), listener); + DCHECK(it != listeners_.end()); + LOG4CXX_DEBUG(logger_, "Destroying listener: " << *it); + delete (*it); + listeners_.erase(it); + } } #ifdef EXTERNAL_PROPRIETARY_MODE From 387839d70d7867c671fae9233687c610a7c4acfc Mon Sep 17 00:00:00 2001 From: sniukalov Date: Thu, 30 May 2019 09:51:31 +0300 Subject: [PATCH 06/19] Fix OnServiceUpdate for unsecure force protected service --- .../protocol_handler/src/protocol_handler_impl.cc | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/src/components/protocol_handler/src/protocol_handler_impl.cc b/src/components/protocol_handler/src/protocol_handler_impl.cc index 70148a1d735..c2423b2fb63 100644 --- a/src/components/protocol_handler/src/protocol_handler_impl.cc +++ b/src/components/protocol_handler/src/protocol_handler_impl.cc @@ -1654,15 +1654,25 @@ RESULT_CODE ProtocolHandlerImpl::HandleControlMessageStartSession( const uint32_t connection_key = session_observer_.KeyFromPair( packet->connection_id(), packet->session_id()); + const auto& force_protected = get_settings().force_protected_service(); + + const bool is_force_protected = + (helpers::in_range(force_protected, service_type)); + + const bool can_start_unprotected = is_force_protected && protection; + service_status_update_handler_->OnServiceUpdate( connection_key, service_type, ServiceStatus::SERVICE_RECEIVED); if ((ServiceType::kMobileNav == service_type && !is_video_allowed) || - (ServiceType::kAudio == service_type && !is_audio_allowed)) { + (ServiceType::kAudio == service_type && !is_audio_allowed) || + (is_force_protected && !can_start_unprotected)) { LOG4CXX_DEBUG(logger_, "Rejecting StartService for service:" << service_type << ", over transport: " << transport << ", disallowed by settings."); + service_status_update_handler_->OnServiceUpdate( + connection_key, service_type, ServiceStatus::SERVICE_START_FAILED); SendStartSessionNAck( connection_id, session_id, protocol_version, service_type); return RESULT_OK; From 28edbe341ea2ddef904e87070160e5e64bcf9666 Mon Sep 17 00:00:00 2001 From: sniukalov Date: Thu, 30 May 2019 09:52:35 +0300 Subject: [PATCH 07/19] Fix UTs --- .../application_manager/mock_message_helper.h | 4 ++ .../test/mock_message_helper.cc | 7 +++ .../test/policy_event_observer_test.cc | 4 ++ .../test/policy_handler_test.cc | 6 ++- .../policies/mock_policy_handler_interface.h | 5 +- .../policy/mock_policy_listener.h | 2 +- .../policy/mock_policy_manager.h | 3 +- .../policy/mock_ptu_retry_handler.h} | 38 ++++----------- .../policy/mock_policy_listener.h | 4 +- .../policy/mock_policy_manager.h | 6 ++- .../mock_security_manager_listener.h | 2 +- .../policy/policy_manager_impl_test_base.h | 3 ++ .../test/policy_manager_impl_test.cc | 48 ++----------------- .../test/policy_manager_impl_test_base.cc | 4 ++ .../test/update_status_manager_test.cc | 22 ++++++--- .../test/policy_manager_impl_test.cc | 2 +- .../test/protocol_handler_tm_test.cc | 2 +- 17 files changed, 74 insertions(+), 88 deletions(-) rename src/components/{application_manager/include/application_manager/policies/ptu_retry_handler.h => include/test/policy/policy_external/policy/mock_ptu_retry_handler.h} (61%) diff --git a/src/components/application_manager/test/include/application_manager/mock_message_helper.h b/src/components/application_manager/test/include/application_manager/mock_message_helper.h index d78946efd35..5e4ddffa95b 100644 --- a/src/components/application_manager/test/include/application_manager/mock_message_helper.h +++ b/src/components/application_manager/test/include/application_manager/mock_message_helper.h @@ -141,6 +141,10 @@ class MockMessageHelper { MOCK_METHOD2(SendDecryptCertificateToHMI, void(const std::string& file_name, ApplicationManager& app_mngr)); + MOCK_METHOD2( + CreateOnSystemRequestNotificationToMobile, + smart_objects::SmartObjectSPtr(const std::vector& policy_data, + const uint32_t connection_key)); #ifdef EXTERNAL_PROPRIETARY_MODE MOCK_METHOD4( SendGetListOfPermissionsResponse, diff --git a/src/components/application_manager/test/mock_message_helper.cc b/src/components/application_manager/test/mock_message_helper.cc index d33e98cb6f5..a3f864cfd4f 100755 --- a/src/components/application_manager/test/mock_message_helper.cc +++ b/src/components/application_manager/test/mock_message_helper.cc @@ -635,6 +635,13 @@ MessageHelper::ServiceStatusUpdateNotificationBuilder::notification() const { return MockMessageHelper::on_service_update_builder_mock()->notification(); } +smart_objects::SmartObjectSPtr +MessageHelper::CreateOnSystemRequestNotificationToMobile( + const std::vector& policy_data, const uint32_t connection_key) { + return MockMessageHelper::message_helper_mock() + ->CreateOnSystemRequestNotificationToMobile(policy_data, connection_key); +} + smart_objects::SmartObject MessageHelper::CreateAppServiceCapabilities( std::vector& all_services) { return MockMessageHelper::message_helper_mock()->CreateAppServiceCapabilities( diff --git a/src/components/application_manager/test/policy_event_observer_test.cc b/src/components/application_manager/test/policy_event_observer_test.cc index a74b12071cd..a425dfe44f2 100644 --- a/src/components/application_manager/test/policy_event_observer_test.cc +++ b/src/components/application_manager/test/policy_event_observer_test.cc @@ -38,6 +38,10 @@ #include "policy/policy_types.h" #include "smart_objects/smart_object.h" +#ifdef EXTERNAL_PROPRIETARY_MODE +#include "policy/ptu_retry_handler.h" +#endif + namespace test { namespace components { namespace policy_test { diff --git a/src/components/application_manager/test/policy_handler_test.cc b/src/components/application_manager/test/policy_handler_test.cc index 94567e893d8..b7cdf9a4d21 100644 --- a/src/components/application_manager/test/policy_handler_test.cc +++ b/src/components/application_manager/test/policy_handler_test.cc @@ -1785,7 +1785,8 @@ TEST_F(PolicyHandlerTest, OnSnapshotCreated_UrlNotAdded) { .WillRepeatedly(SetArgReferee<1>(test_data)); policy_handler_.OnSnapshotCreated(msg, retry_delay_seconds, timeout_exchange); #else // EXTERNAL_PROPRIETARY_MODE - policy_handler_.OnSnapshotCreated(msg); + policy_handler_.OnSnapshotCreated(msg, + policy::PTUIterationType::DefaultIteration); #endif // EXTERNAL_PROPRIETARY_MODE } @@ -1863,7 +1864,8 @@ TEST_F(PolicyHandlerTest, DISABLED_OnSnapshotCreated_UrlAdded) { #endif // PROPRIETARY_MODE EXPECT_CALL(*mock_policy_manager_, OnUpdateStarted()); - policy_handler_.OnSnapshotCreated(msg); + policy_handler_.OnSnapshotCreated(msg, + policy::PTUIterationType::DefaultIteration); } #endif // EXTERNAL_PROPRIETARY_MODE diff --git a/src/components/include/test/application_manager/policies/mock_policy_handler_interface.h b/src/components/include/test/application_manager/policies/mock_policy_handler_interface.h index c292272d4c2..defdad38f71 100644 --- a/src/components/include/test/application_manager/policies/mock_policy_handler_interface.h +++ b/src/components/include/test/application_manager/policies/mock_policy_handler_interface.h @@ -76,7 +76,9 @@ class MockPolicyHandlerInterface : public policy::PolicyHandlerInterface { const std::vector& retry_delay_seconds, uint32_t timeout_exchange)); #else // EXTERNAL_PROPRIETARY_MODE - MOCK_METHOD1(OnSnapshotCreated, void(const policy::BinaryMessage& pt_string)); + MOCK_METHOD2(OnSnapshotCreated, + void(const policy::BinaryMessage& pt_string, + const policy::PTUIterationType iteration_type)); #endif // EXTERNAL_PROPRIETARY_MODE MOCK_CONST_METHOD2(GetPriority, @@ -262,6 +264,7 @@ class MockPolicyHandlerInterface : public policy::PolicyHandlerInterface { #ifdef EXTERNAL_PROPRIETARY_MODE MOCK_CONST_METHOD0(GetMetaInfo, const policy::MetaInfo()); MOCK_METHOD0(IncrementRetryIndex, void()); + MOCK_CONST_METHOD0(ptu_retry_handler, policy::PTURetryHandler&()); #endif // EXTERNAL_PROPRIETARY_MODE MOCK_METHOD1(Increment, void(usage_statistics::GlobalCounterId type)); diff --git a/src/components/include/test/policy/policy_external/policy/mock_policy_listener.h b/src/components/include/test/policy/policy_external/policy/mock_policy_listener.h index 0faa6d6dea1..2eb5b3300b9 100644 --- a/src/components/include/test/policy/policy_external/policy/mock_policy_listener.h +++ b/src/components/include/test/policy/policy_external/policy/mock_policy_listener.h @@ -114,7 +114,7 @@ class MockPolicyListener : public ::policy::PolicyListener { MOCK_METHOD0(OnLockScreenDismissalStateChanged, void()); MOCK_METHOD1(OnCertDecryptFinished, void(bool)); MOCK_METHOD0(IncrementRetryIndex, void()); - MOCK_CONST_METHOD0(IsAllowedPTURetriesExceeded, bool()); + MOCK_CONST_METHOD0(ptu_retry_handler, policy::PTURetryHandler&()); }; } // namespace policy_test diff --git a/src/components/include/test/policy/policy_external/policy/mock_policy_manager.h b/src/components/include/test/policy/policy_external/policy/mock_policy_manager.h index 82edd959d21..cfe58447573 100644 --- a/src/components/include/test/policy/policy_external/policy/mock_policy_manager.h +++ b/src/components/include/test/policy/policy_external/policy/mock_policy_manager.h @@ -102,7 +102,8 @@ class MockPolicyManager : public PolicyManager { MOCK_METHOD0(IncrementIgnitionCycles, void()); MOCK_METHOD0(ForcePTExchange, std::string()); MOCK_METHOD0(ForcePTExchangeAtUserRequest, std::string()); - MOCK_METHOD1(ResetRetrySequence, void(const bool send_event)); + MOCK_METHOD1(ResetRetrySequence, + void(const policy::ResetRetryCountType send_event)); MOCK_METHOD0(NextRetryTimeout, int()); MOCK_METHOD0(TimeoutExchangeMSec, uint32_t()); MOCK_METHOD0(RetrySequenceDelaysSeconds, const std::vector()); diff --git a/src/components/application_manager/include/application_manager/policies/ptu_retry_handler.h b/src/components/include/test/policy/policy_external/policy/mock_ptu_retry_handler.h similarity index 61% rename from src/components/application_manager/include/application_manager/policies/ptu_retry_handler.h rename to src/components/include/test/policy/policy_external/policy/mock_ptu_retry_handler.h index 8d52641daf4..d76c791b853 100644 --- a/src/components/application_manager/include/application_manager/policies/ptu_retry_handler.h +++ b/src/components/include/test/policy/policy_external/policy/mock_ptu_retry_handler.h @@ -29,38 +29,20 @@ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_POLICIES_PTU_RETRY_HANDLER_H_ -#define SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_POLICIES_PTU_RETRY_HANDLER_H_ -namespace policy { - -class PTURetryHandler { - public: - /** - * @brief Check whether allowed retry sequence count is exceeded - * @return bool value - true is allowed count is exceeded, otherwise - false - */ - virtual bool IsAllowedRetryCountExceeded() const = 0; +#ifndef SRC_COMPONENTS_POLICY_POLICY_EXTERNAL_INCLUDE_POLICY_MOCK_PTU_RETRY_HANDLER_H_ +#define SRC_COMPONENTS_POLICY_POLICY_EXTERNAL_INCLUDE_POLICY_MOCK_PTU_RETRY_HANDLER_H_ - /** - * @brief Begins new retry sequence - */ - virtual void BeginRetrySequence() = 0; - /** - * @brief Start timer waiting for OnSystemRequest from HMI. - */ - virtual void StartWaitingPTURetry() = 0; +#include "policy/ptu_retry_handler.h" - /** - * @brief Stop timer waiting for git OnSystemRequest from HMI. - */ - virtual void StopWaitingPTURetry() = 0; +namespace policy { - /** - * @brief Handle retry sequence failure - */ - virtual void RetrySequenceFailed() = 0; +class MockPTURetryHandler : public PTURetryHandler { + public: + MOCK_CONST_METHOD0(IsAllowedRetryCountExceeded, bool()); + MOCK_METHOD0(OnSystemRequestReceived, void()); + MOCK_METHOD0(RetrySequenceFailed, void()); }; } // namespace policy -#endif // SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_POLICIES_PTU_RETRY_HANDLER_H_ +#endif // SRC_COMPONENTS_POLICY_POLICY_EXTERNAL_INCLUDE_POLICY_MOCK_PTU_RETRY_HANDLER_H_ \ No newline at end of file diff --git a/src/components/include/test/policy/policy_regular/policy/mock_policy_listener.h b/src/components/include/test/policy/policy_regular/policy/mock_policy_listener.h index cb5feb31268..48c549e91bb 100644 --- a/src/components/include/test/policy/policy_regular/policy/mock_policy_listener.h +++ b/src/components/include/test/policy/policy_regular/policy/mock_policy_listener.h @@ -77,7 +77,9 @@ class MockPolicyListener : public ::policy::PolicyListener { MOCK_METHOD1(OnUpdateHMIAppType, void(std::map)); MOCK_METHOD1(GetAvailableApps, void(std::queue&)); - MOCK_METHOD1(OnSnapshotCreated, void(const policy::BinaryMessage& pt_string)); + MOCK_METHOD2(OnSnapshotCreated, + void(const policy::BinaryMessage& pt_string, + const policy::PTUIterationType iteration_type)); MOCK_METHOD0(CanUpdate, bool()); MOCK_METHOD1(OnCertificateUpdated, void(const std::string&)); MOCK_METHOD2(OnAuthTokenUpdated, diff --git a/src/components/include/test/policy/policy_regular/policy/mock_policy_manager.h b/src/components/include/test/policy/policy_regular/policy/mock_policy_manager.h index 4ddd8cb3095..d23674c060d 100644 --- a/src/components/include/test/policy/policy_regular/policy/mock_policy_manager.h +++ b/src/components/include/test/policy/policy_regular/policy/mock_policy_manager.h @@ -85,7 +85,8 @@ class MockPolicyManager : public PolicyManager { MOCK_METHOD2(GetUpdateUrls, void(const std::string& service_type, EndpointUrls& out_end_points)); - MOCK_METHOD0(RequestPTUpdate, bool()); + MOCK_METHOD1(RequestPTUpdate, + bool(const policy::PTUIterationType iteration_type)); MOCK_METHOD5(CheckPermissions, void(const PTString& app_id, const PTString& hmi_level, @@ -102,7 +103,8 @@ class MockPolicyManager : public PolicyManager { MOCK_METHOD0(IncrementIgnitionCycles, void()); MOCK_METHOD0(ForcePTExchange, std::string()); MOCK_METHOD0(ForcePTExchangeAtUserRequest, std::string()); - MOCK_METHOD0(ResetRetrySequence, void()); + MOCK_METHOD1(ResetRetrySequence, + void(const policy::ResetRetryCountType send_event)); MOCK_METHOD0(NextRetryTimeout, uint32_t()); MOCK_METHOD0(TimeoutExchangeMSec, uint32_t()); MOCK_METHOD0(RetrySequenceDelaysSeconds, const std::vector()); diff --git a/src/components/include/test/security_manager/mock_security_manager_listener.h b/src/components/include/test/security_manager/mock_security_manager_listener.h index 1673a270876..81790d18301 100644 --- a/src/components/include/test/security_manager/mock_security_manager_listener.h +++ b/src/components/include/test/security_manager/mock_security_manager_listener.h @@ -50,7 +50,7 @@ class MockSecurityManagerListener MOCK_METHOD0(OnCertificateUpdateRequired, void()); MOCK_CONST_METHOD1(GetPolicyCertificateData, bool(std::string& data)); MOCK_METHOD0(OnGetSystemTimeFailed, bool()); - MOCK_METHOD0(OnPTUFailed, void()); + MOCK_METHOD0(OnPTUFailed, bool()); #ifdef EXTERNAL_PROPRIETARY_MODE MOCK_METHOD0(OnCertDecryptFailed, bool()); #endif diff --git a/src/components/policy/policy_external/test/include/policy/policy_manager_impl_test_base.h b/src/components/policy/policy_external/test/include/policy/policy_manager_impl_test_base.h index 65972e0a829..2ab6caf15d0 100644 --- a/src/components/policy/policy_external/test/include/policy/policy_manager_impl_test_base.h +++ b/src/components/policy/policy_external/test/include/policy/policy_manager_impl_test_base.h @@ -42,6 +42,7 @@ #include "policy/mock_cache_manager.h" #include "policy/mock_policy_listener.h" #include "policy/mock_policy_settings.h" +#include "policy/mock_ptu_retry_handler.h" #include "policy/mock_update_status_manager.h" namespace test { @@ -115,6 +116,7 @@ class PolicyManagerImplTest : public ::testing::Test { MockCacheManagerInterface* cache_manager_; MockUpdateStatusManager update_manager_; NiceMock listener_; + NiceMock ptu_retry_handler_; void SetUp() OVERRIDE; @@ -140,6 +142,7 @@ class PolicyManagerImplTest2 : public ::testing::Test { PolicyManagerImpl* policy_manager_; NiceMock listener_; + NiceMock ptu_retry_handler_; ::policy::StringArray hmi_level_; ::policy::StringArray pt_request_types_; size_t ptu_request_types_size_; diff --git a/src/components/policy/policy_external/test/policy_manager_impl_test.cc b/src/components/policy/policy_external/test/policy_manager_impl_test.cc index b809c83d75c..1a7500c954e 100644 --- a/src/components/policy/policy_external/test/policy_manager_impl_test.cc +++ b/src/components/policy/policy_external/test/policy_manager_impl_test.cc @@ -37,6 +37,7 @@ #include "json/reader.h" #include "policy/policy_manager_impl_test_base.h" +#include "utils/date_time.h" using ::testing::_; using ::testing::AtLeast; @@ -47,30 +48,6 @@ namespace test { namespace components { namespace policy_test { -TEST_F( - PolicyManagerImplTest, - RefreshRetrySequence_SetSecondsBetweenRetries_ExpectRetryTimeoutSequenceWithSameSeconds) { - // Arrange - std::vector seconds; - seconds.push_back(50); - seconds.push_back(100); - seconds.push_back(200); - - // Assert - EXPECT_CALL(*cache_manager_, TimeoutResponse()).WillOnce(Return(60)); - EXPECT_CALL(*cache_manager_, SecondsBetweenRetries(_)) - .WillOnce(DoAll(SetArgReferee<0>(seconds), Return(true))); - - // Act - policy_manager_->RefreshRetrySequence(); - - // Assert - EXPECT_EQ(50, policy_manager_->NextRetryTimeout()); - EXPECT_EQ(100, policy_manager_->NextRetryTimeout()); - EXPECT_EQ(200, policy_manager_->NextRetryTimeout()); - EXPECT_EQ(0, policy_manager_->NextRetryTimeout()); -} - TEST_F(PolicyManagerImplTest, GetNotificationsNumber) { std::string priority = "EMERGENCY"; uint32_t notif_number = 100; @@ -199,31 +176,14 @@ TEST_F(PolicyManagerImplTest2, OnSystemReady) { TEST_F(PolicyManagerImplTest2, ResetRetrySequence) { // Arrange CreateLocalPT(preloaded_pt_filename_); - policy_manager_->ResetRetrySequence(); + policy_manager_->ResetRetrySequence( + policy::ResetRetryCountType::kResetWithStatusUpdate); EXPECT_EQ("UPDATE_NEEDED", policy_manager_->GetPolicyTableStatus()); policy_manager_->SetSendOnUpdateFlags(false, false); policy_manager_->OnUpdateStarted(); EXPECT_EQ("UPDATING", policy_manager_->GetPolicyTableStatus()); } -TEST_F(PolicyManagerImplTest2, NextRetryTimeout_ExpectTimeoutsFromPT) { - // Arrange - std::ifstream ifile(preloaded_pt_filename_); - Json::Reader reader; - Json::Value root(Json::objectValue); - if (ifile.is_open() && reader.parse(ifile, root, true)) { - Json::Value seconds_between_retries = Json::Value(Json::arrayValue); - seconds_between_retries = - root["policy_table"]["module_config"]["seconds_between_retries"]; - uint32_t size = seconds_between_retries.size(); - CreateLocalPT(preloaded_pt_filename_); - for (uint32_t i = 0; i < size; ++i) { - EXPECT_EQ(seconds_between_retries[i], - policy_manager_->NextRetryTimeout()); - } - } -} - TEST_F(PolicyManagerImplTest2, TimeOutExchange) { // Arrange CreateLocalPT(preloaded_pt_filename_); @@ -319,6 +279,8 @@ TEST_F(PolicyManagerImplTest2, OnExceededTimeout_GetPolicyTableStatus_ExpectUpdateNeeded) { // Arrange CreateLocalPT(preloaded_pt_filename_); + ON_CALL(ptu_retry_handler_, IsAllowedRetryCountExceeded()) + .WillByDefault(Return(false)); policy_manager_->ForcePTExchange(); policy_manager_->OnExceededTimeout(); // Check diff --git a/src/components/policy/policy_external/test/policy_manager_impl_test_base.cc b/src/components/policy/policy_external/test/policy_manager_impl_test_base.cc index 8a62772992b..be7f25dabbd 100644 --- a/src/components/policy/policy_external/test/policy_manager_impl_test_base.cc +++ b/src/components/policy/policy_external/test/policy_manager_impl_test_base.cc @@ -218,6 +218,8 @@ void PolicyManagerImplTest::SetUp() { ON_CALL(*cache_manager_, GetKnownLinksFromPT()) .WillByDefault(Return(std::map())); ON_CALL(listener_, GetRegisteredLinks(_)).WillByDefault(Return()); + ON_CALL(listener_, ptu_retry_handler()) + .WillByDefault(ReturnRef(ptu_retry_handler_)); } void PolicyManagerImplTest::TearDown() { @@ -253,6 +255,8 @@ PolicyManagerImplTest2::PolicyManagerImplTest2() void PolicyManagerImplTest2::SetUp() { ON_CALL(listener_, GetRegisteredLinks(_)).WillByDefault(Return()); + ON_CALL(listener_, ptu_retry_handler()) + .WillByDefault(ReturnRef(ptu_retry_handler_)); file_system::CreateDirectory(app_storage_folder_); diff --git a/src/components/policy/policy_external/test/update_status_manager_test.cc b/src/components/policy/policy_external/test/update_status_manager_test.cc index 0577e6741d0..9f684567504 100644 --- a/src/components/policy/policy_external/test/update_status_manager_test.cc +++ b/src/components/policy/policy_external/test/update_status_manager_test.cc @@ -33,6 +33,7 @@ #include "policy/update_status_manager.h" #include "gtest/gtest.h" #include "policy/mock_policy_listener.h" +#include "policy/mock_ptu_retry_handler.h" #include "policy/policy_manager_impl.h" #include "utils/conditional_variable.h" @@ -52,6 +53,7 @@ class UpdateStatusManagerTest : public ::testing::Test { PolicyTableStatus status_; const uint32_t k_timeout_; NiceMock listener_; + NiceMock mock_ptu_retry_handler_; const std::string up_to_date_status_; const std::string update_needed_status_; const std::string updating_status_; @@ -61,6 +63,7 @@ class UpdateStatusManagerTest : public ::testing::Test { : manager_(std::make_shared()) , k_timeout_(1000) , listener_() + , mock_ptu_retry_handler_() , up_to_date_status_("UP_TO_DATE") , update_needed_status_("UPDATE_NEEDED") , updating_status_("UPDATING") {} @@ -68,6 +71,8 @@ class UpdateStatusManagerTest : public ::testing::Test { void SetUp() OVERRIDE { manager_->set_listener(&listener_); ON_CALL(listener_, OnUpdateStatusChanged(_)).WillByDefault(Return()); + ON_CALL(listener_, ptu_retry_handler()) + .WillByDefault(ReturnRef(mock_ptu_retry_handler_)); } void TearDown() OVERRIDE {} @@ -111,6 +116,11 @@ ACTION_P(NotifyAsync, waiter) { waiter->Notify(); } +ACTION_P2(RetryFailed, manager, listener) { + manager->OnResetRetrySequence(); + listener->OnPTUFinished(false); +} + TEST_F(UpdateStatusManagerTest, OnUpdateSentOut_WaitForTimeoutExpired_ExpectStatusUpdateNeeded) { // Arrange @@ -121,8 +131,6 @@ TEST_F(UpdateStatusManagerTest, WaitAsync waiter(count, timeout); EXPECT_CALL(listener_, OnUpdateStatusChanged(_)) .WillRepeatedly(NotifyAsync(&waiter)); - EXPECT_CALL(listener_, IsAllowedPTURetriesExceeded()) - .WillRepeatedly(Return(false)); manager_->ScheduleUpdate(); manager_->OnUpdateSentOut(k_timeout_); status_ = manager_->GetLastUpdateStatus(); @@ -143,16 +151,18 @@ TEST_F( WaitAsync waiter(count, timeout); EXPECT_CALL(listener_, OnUpdateStatusChanged(_)) .WillRepeatedly(NotifyAsync(&waiter)); + EXPECT_CALL(mock_ptu_retry_handler_, RetrySequenceFailed()) + .WillOnce(RetryFailed(manager_, &listener_)); manager_->ScheduleUpdate(); manager_->OnUpdateSentOut(k_timeout_); status_ = manager_->GetLastUpdateStatus(); { ::testing::InSequence s; - EXPECT_CALL(listener_, IsAllowedPTURetriesExceeded()) + EXPECT_CALL(mock_ptu_retry_handler_, IsAllowedRetryCountExceeded()) .WillRepeatedly(Return(false)); - EXPECT_CALL(listener_, IsAllowedPTURetriesExceeded()) + EXPECT_CALL(mock_ptu_retry_handler_, IsAllowedRetryCountExceeded()) .WillRepeatedly(Return(false)); - EXPECT_CALL(listener_, IsAllowedPTURetriesExceeded()) + EXPECT_CALL(mock_ptu_retry_handler_, IsAllowedRetryCountExceeded()) .WillRepeatedly(Return(true)); EXPECT_CALL(listener_, OnPTUFinished(false)); } @@ -277,7 +287,7 @@ TEST_F(UpdateStatusManagerTest, OnResetRetrySequence_ExpectStatusUpToDate) { manager_->OnResetRetrySequence(); status_ = manager_->GetLastUpdateStatus(); // Check - EXPECT_EQ(StatusUpdatePending, status_); + EXPECT_EQ(StatusUpdateRequired, status_); } TEST_F(UpdateStatusManagerTest, diff --git a/src/components/policy/policy_regular/test/policy_manager_impl_test.cc b/src/components/policy/policy_regular/test/policy_manager_impl_test.cc index eb06856eaed..ed80e904b44 100644 --- a/src/components/policy/policy_regular/test/policy_manager_impl_test.cc +++ b/src/components/policy/policy_regular/test/policy_manager_impl_test.cc @@ -1083,7 +1083,7 @@ TEST_F(PolicyManagerImplTest2, OnSystemReady) { TEST_F(PolicyManagerImplTest2, ResetRetrySequence) { // Arrange CreateLocalPT("sdl_preloaded_pt.json"); - manager->ResetRetrySequence(); + manager->ResetRetrySequence(ResetRetryCountType::kResetWithStatusUpdate); EXPECT_EQ("UPDATE_NEEDED", manager->GetPolicyTableStatus()); manager->SetSendOnUpdateSentOut(false); manager->OnUpdateStarted(); diff --git a/src/components/protocol_handler/test/protocol_handler_tm_test.cc b/src/components/protocol_handler/test/protocol_handler_tm_test.cc index 600884bae16..1bea53b075b 100644 --- a/src/components/protocol_handler/test/protocol_handler_tm_test.cc +++ b/src/components/protocol_handler/test/protocol_handler_tm_test.cc @@ -1430,7 +1430,7 @@ TEST_F(ProtocolHandlerImplTest, services.push_back(0x0A); services.push_back(0x0B); EXPECT_CALL(protocol_handler_settings_mock, force_protected_service()) - .WillOnce(ReturnRefOfCopy(services)); + .WillRepeatedly(ReturnRefOfCopy(services)); // call new SSLContext creation EXPECT_CALL(security_manager_mock, CreateSSLContext(connection_key, _)) From e6aa35bdeebafad9b725cffdd0031ab4a260b63d Mon Sep 17 00:00:00 2001 From: sniukalov Date: Thu, 30 May 2019 09:53:27 +0300 Subject: [PATCH 08/19] Answer PR comments --- .../application_manager/message_helper.h | 5 +++- .../src/message_helper/message_helper.cc | 29 ++++++++----------- .../src/policies/policy_handler.cc | 4 ++- .../application_manager/mock_message_helper.h | 9 +++--- .../test/mock_message_helper.cc | 7 +++-- .../include/policy/policy_manager_impl.h | 7 +++-- .../src/policy_manager_impl.cc | 16 ++++++---- .../include/policy/policy_manager_impl.h | 2 +- .../policy_regular/src/policy_manager_impl.cc | 9 +++--- 9 files changed, 51 insertions(+), 37 deletions(-) diff --git a/src/components/application_manager/include/application_manager/message_helper.h b/src/components/application_manager/include/application_manager/message_helper.h index 480694e18de..f878179695f 100644 --- a/src/components/application_manager/include/application_manager/message_helper.h +++ b/src/components/application_manager/include/application_manager/message_helper.h @@ -94,11 +94,14 @@ class MessageHelper { * OnSystemRequestNotification * @param policy_data pt snapshot data * @param connection_key connection key of application + * @param request_type OnSystemRequest request type * @return OnSystemRequest notification smart object */ static smart_objects::SmartObjectSPtr CreateOnSystemRequestNotificationToMobile( - const std::vector& policy_data, const uint32_t connection_key); + const std::vector& policy_data, + const uint32_t connection_key, + const mobile_apis::RequestType::eType request_type); /** * @brief ServiceStatusUpdateNotificationBuilder small utility class used for diff --git a/src/components/application_manager/src/message_helper/message_helper.cc b/src/components/application_manager/src/message_helper/message_helper.cc index 050e6726973..dee157d92c1 100644 --- a/src/components/application_manager/src/message_helper/message_helper.cc +++ b/src/components/application_manager/src/message_helper/message_helper.cc @@ -2467,20 +2467,16 @@ bool MessageHelper::SendUnsubscribedWayPoints(ApplicationManager& app_mngr) { smart_objects::SmartObjectSPtr MessageHelper::CreateOnSystemRequestNotificationToMobile( - const std::vector& policy_data, const uint32_t app_id) { + const std::vector& policy_data, + const uint32_t app_id, + const mobile_apis::RequestType::eType request_type) { auto notification = CreateNotification(mobile_apis::FunctionID::OnSystemRequestID, app_id); (*notification)[strings::params][strings::binary_data] = smart_objects::SmartObject(policy_data); -#if defined(PROPRIETARY_MODE) || defined(EXTERNAL_PROPRIETARY_MODE) - (*notification)[strings::msg_params][strings::request_type] = - mobile_apis::RequestType::PROPRIETARY; -#else - (*notification)[strings::msg_params][strings::request_type] = - mobile_apis::RequestType::HTTP; -#endif // PROPRIETARY || EXTERNAL_PROPRIETARY_MODE + (*notification)[strings::msg_params][strings::request_type] = request_type; return notification; } @@ -2490,8 +2486,14 @@ void MessageHelper::SendPolicySnapshotNotification( const std::vector& policy_data, const std::string& url, ApplicationManager& app_mngr) { - auto notification = - CreateOnSystemRequestNotificationToMobile(policy_data, connection_key); + const auto request_type = +#if defined(PROPRIETARY_MODE) || defined(EXTERNAL_PROPRIETARY_MODE) + mobile_apis::RequestType::PROPRIETARY; +#else + mobile_apis::RequestType::HTTP; +#endif // PROPRIETARY || EXTERNAL_PROPRIETARY_MODE + auto notification = CreateOnSystemRequestNotificationToMobile( + policy_data, connection_key, request_type); if (!url.empty()) { (*notification)[strings::msg_params][strings::url] = @@ -2502,13 +2504,6 @@ void MessageHelper::SendPolicySnapshotNotification( (*notification)[strings::params][strings::binary_data] = smart_objects::SmartObject(policy_data); -#if defined(PROPRIETARY_MODE) || defined(EXTERNAL_PROPRIETARY_MODE) - (*notification)[strings::msg_params][strings::request_type] = - mobile_apis::RequestType::PROPRIETARY; -#else - (*notification)[strings::msg_params][strings::request_type] = - mobile_apis::RequestType::HTTP; -#endif // PROPRIETARY || EXTERNAL_PROPRIETARY_MODE PrintSmartObject(*notification); app_mngr.GetRPCService().ManageMobileCommand(notification, diff --git a/src/components/application_manager/src/policies/policy_handler.cc b/src/components/application_manager/src/policies/policy_handler.cc index b5f0371555b..81d80c2b00a 100644 --- a/src/components/application_manager/src/policies/policy_handler.cc +++ b/src/components/application_manager/src/policies/policy_handler.cc @@ -1524,7 +1524,9 @@ void PolicyHandler::OnSnapshotCreated(const BinaryMessage& pt_string, if (PTUIterationType::RetryIteration == iteration_type) { auto on_system_request_notification = MessageHelper::CreateOnSystemRequestNotificationToMobile( - pt_string, GetAppIdForSending()); + pt_string, + GetAppIdForSending(), + mobile_apis::RequestType::PROPRIETARY); application_manager_.GetRPCService().ManageMobileCommand( on_system_request_notification, commands::Command::SOURCE_SDL); } else { diff --git a/src/components/application_manager/test/include/application_manager/mock_message_helper.h b/src/components/application_manager/test/include/application_manager/mock_message_helper.h index 5e4ddffa95b..21c88fbabc2 100644 --- a/src/components/application_manager/test/include/application_manager/mock_message_helper.h +++ b/src/components/application_manager/test/include/application_manager/mock_message_helper.h @@ -141,10 +141,11 @@ class MockMessageHelper { MOCK_METHOD2(SendDecryptCertificateToHMI, void(const std::string& file_name, ApplicationManager& app_mngr)); - MOCK_METHOD2( - CreateOnSystemRequestNotificationToMobile, - smart_objects::SmartObjectSPtr(const std::vector& policy_data, - const uint32_t connection_key)); + MOCK_METHOD3(CreateOnSystemRequestNotificationToMobile, + smart_objects::SmartObjectSPtr( + const std::vector& policy_data, + const uint32_t connection_key, + const mobile_apis::RequestType::eType request_type)); #ifdef EXTERNAL_PROPRIETARY_MODE MOCK_METHOD4( SendGetListOfPermissionsResponse, diff --git a/src/components/application_manager/test/mock_message_helper.cc b/src/components/application_manager/test/mock_message_helper.cc index a3f864cfd4f..50fcdd4692a 100755 --- a/src/components/application_manager/test/mock_message_helper.cc +++ b/src/components/application_manager/test/mock_message_helper.cc @@ -637,9 +637,12 @@ MessageHelper::ServiceStatusUpdateNotificationBuilder::notification() const { smart_objects::SmartObjectSPtr MessageHelper::CreateOnSystemRequestNotificationToMobile( - const std::vector& policy_data, const uint32_t connection_key) { + const std::vector& policy_data, + const uint32_t connection_key, + const mobile_apis::RequestType::eType request_type) { return MockMessageHelper::message_helper_mock() - ->CreateOnSystemRequestNotificationToMobile(policy_data, connection_key); + ->CreateOnSystemRequestNotificationToMobile( + policy_data, connection_key, request_type); } smart_objects::SmartObject MessageHelper::CreateAppServiceCapabilities( diff --git a/src/components/policy/policy_external/include/policy/policy_manager_impl.h b/src/components/policy/policy_external/include/policy/policy_manager_impl.h index ed4d2f7a016..1524e949ef6 100644 --- a/src/components/policy/policy_external/include/policy/policy_manager_impl.h +++ b/src/components/policy/policy_external/include/policy/policy_manager_impl.h @@ -903,7 +903,10 @@ class PolicyManagerImpl : public PolicyManager { void RetrySequenceFailed() OVERRIDE; /** - * @brief Begins new retry sequence + * @brief In EXTERNAL_PROPRIETARY_MODE PTU sequence is driven by HMI and + * begins with OnSystemRequest from HMI. Following function is called when + * this notification is received to track number of PTU retries and react + * accordingly once allowed retry count is exceeded */ void OnSystemRequestReceived() OVERRIDE; @@ -1288,7 +1291,7 @@ class PolicyManagerImpl : public PolicyManager { /** * @brief Lock for guarding retry sequence */ - sync_primitives::Lock retry_sequence_lock_; + mutable sync_primitives::Lock retry_sequence_lock_; /** * @brief Device id, which is used during PTU handling for specific diff --git a/src/components/policy/policy_external/src/policy_manager_impl.cc b/src/components/policy/policy_external/src/policy_manager_impl.cc index 1b8c7a8c876..33b862e2df5 100644 --- a/src/components/policy/policy_external/src/policy_manager_impl.cc +++ b/src/components/policy/policy_external/src/policy_manager_impl.cc @@ -1297,11 +1297,21 @@ void PolicyManagerImpl::SetUserConsentForApp( bool PolicyManagerImpl::IsAllowedRetryCountExceeded() const { LOG4CXX_AUTO_TRACE(logger_); + sync_primitives::AutoLock auto_lock(retry_sequence_lock_); + return retry_sequence_index_ > retry_sequence_seconds_.size(); } void PolicyManagerImpl::IncrementRetryIndex() { LOG4CXX_AUTO_TRACE(logger_); + sync_primitives::AutoLock auto_lock(retry_sequence_lock_); + + if (!is_ptu_in_progress_) { + LOG4CXX_TRACE(logger_, + "First PTU iteration, skipping incrementing retry index"); + is_ptu_in_progress_ = true; + return; + } ++retry_sequence_index_; LOG4CXX_DEBUG(logger_, @@ -1318,11 +1328,7 @@ void PolicyManagerImpl::RetrySequenceFailed() { void PolicyManagerImpl::OnSystemRequestReceived() { LOG4CXX_AUTO_TRACE(logger_); - if (is_ptu_in_progress_) { - IncrementRetryIndex(); - } else { - is_ptu_in_progress_ = true; - } + IncrementRetryIndex(); } bool PolicyManagerImpl::GetDefaultHmi(const std::string& device_id, diff --git a/src/components/policy/policy_regular/include/policy/policy_manager_impl.h b/src/components/policy/policy_regular/include/policy/policy_manager_impl.h index 7acca8bdee5..92ef67176a1 100644 --- a/src/components/policy/policy_regular/include/policy/policy_manager_impl.h +++ b/src/components/policy/policy_regular/include/policy/policy_manager_impl.h @@ -1021,7 +1021,7 @@ class PolicyManagerImpl : public PolicyManager { /** * @brief Starts new retry sequence */ - void StartRetrySequence(); + void OnPTUIterationTimeout(); private: /** diff --git a/src/components/policy/policy_regular/src/policy_manager_impl.cc b/src/components/policy/policy_regular/src/policy_manager_impl.cc index 5b9856193ec..ee4c9911831 100644 --- a/src/components/policy/policy_regular/src/policy_manager_impl.cc +++ b/src/components/policy/policy_regular/src/policy_manager_impl.cc @@ -79,9 +79,10 @@ PolicyManagerImpl::PolicyManagerImpl() new AccessRemoteImpl(std::static_pointer_cast(cache_))) , retry_sequence_timeout_(kDefaultRetryTimeoutInMSec) , retry_sequence_index_(0) - , timer_retry_sequence_("Retry sequence timer", - new timer::TimerTaskImpl( - this, &PolicyManagerImpl::StartRetrySequence)) + , timer_retry_sequence_( + "Retry sequence timer", + new timer::TimerTaskImpl( + this, &PolicyManagerImpl::OnPTUIterationTimeout)) , ignition_check(true) , retry_sequence_url_(0, 0, "") , wrong_ptu_update_received_(false) @@ -1516,7 +1517,7 @@ void PolicyManagerImpl::set_cache_manager( cache_ = std::shared_ptr(cache_manager); } -void PolicyManagerImpl::StartRetrySequence() { +void PolicyManagerImpl::OnPTUIterationTimeout() { LOG4CXX_DEBUG(logger_, "Start new retry sequence"); const bool is_exceeded_retries_count = From 237d8f377fc4ea6bfe6621c89ea42a9b3e8dcaa7 Mon Sep 17 00:00:00 2001 From: sniukalov Date: Thu, 30 May 2019 09:54:24 +0300 Subject: [PATCH 09/19] Fixes after rebase --- .../application_manager_impl.h | 2 +- .../application_manager/message_helper.h | 5 +- .../policies/policy_handler.h | 6 ++- .../src/application_manager_impl.cc | 2 +- .../src/message_helper/message_helper.cc | 2 +- .../test/application_manager_impl_test.cc | 18 +++---- .../test/help_prompt_manager_test.cc | 2 +- .../application_manager/mock_message_helper.h | 4 +- .../message_helper/message_helper_test.cc | 2 +- .../test/mock_message_helper.cc | 3 +- .../test/policy_event_observer_test.cc | 4 -- .../policies/policy_handler_interface.h | 4 ++ src/components/interfaces/HMI_API.xml | 52 +++++++++---------- .../src/policy_manager_impl.cc | 1 - .../protocol_handler/protocol_handler_impl.h | 6 +++ .../service_status_update_handler_listener.h | 2 +- .../src/service_status_update_handler.cc | 8 +-- ...k_service_status_update_handler_listener.h | 2 +- .../service_status_update_handler_test.cc | 11 ++-- 19 files changed, 72 insertions(+), 64 deletions(-) diff --git a/src/components/application_manager/include/application_manager/application_manager_impl.h b/src/components/application_manager/include/application_manager/application_manager_impl.h index 3be9f56a3f4..702f7a9a4d1 100644 --- a/src/components/application_manager/include/application_manager/application_manager_impl.h +++ b/src/components/application_manager/include/application_manager/application_manager_impl.h @@ -582,7 +582,7 @@ class ApplicationManagerImpl const uint32_t connection_key, hmi_apis::Common_ServiceType::eType service_type, hmi_apis::Common_ServiceEvent::eType service_event, - utils::Optional + utils::Optional service_update_reason) FINAL; bool OnPTUFailed() FINAL; diff --git a/src/components/application_manager/include/application_manager/message_helper.h b/src/components/application_manager/include/application_manager/message_helper.h index f878179695f..b0412a52cf1 100644 --- a/src/components/application_manager/include/application_manager/message_helper.h +++ b/src/components/application_manager/include/application_manager/message_helper.h @@ -111,7 +111,8 @@ class MessageHelper { public: typedef hmi_apis::Common_ServiceType::eType ServiceType; typedef hmi_apis::Common_ServiceEvent::eType ServiceEvent; - typedef hmi_apis::Common_ServiceUpdateReason::eType ServiceUpdateReason; + typedef hmi_apis::Common_ServiceStatusUpdateReason::eType + ServiceStatusUpdateReason; /** * @brief CreateBuilder creates builder instance @@ -135,7 +136,7 @@ class MessageHelper { * @returns ref to builder instance */ ServiceStatusUpdateNotificationBuilder& AddServiceUpdateReason( - const ServiceUpdateReason service_update_reason); + const ServiceStatusUpdateReason service_update_reason); /** * @brief notification gets notification SO diff --git a/src/components/application_manager/include/application_manager/policies/policy_handler.h b/src/components/application_manager/include/application_manager/policies/policy_handler.h index d2dcc109f2b..21e39dad966 100644 --- a/src/components/application_manager/include/application_manager/policies/policy_handler.h +++ b/src/components/application_manager/include/application_manager/policies/policy_handler.h @@ -462,8 +462,12 @@ class PolicyHandler : public PolicyHandlerInterface, std::string& cloud_transport_type, std::string& hybrid_app_preference) const OVERRIDE; + void OnAuthTokenUpdated(const std::string& policy_app_id, + const std::string& auth_token) OVERRIDE; + /** - * @brief Callback for when a SetCloudAppProperties message is received from a + * @brief Callback for when a SetCloudAppProperties message is received + * from a * mobile app * @param message The SetCloudAppProperties message */ diff --git a/src/components/application_manager/src/application_manager_impl.cc b/src/components/application_manager/src/application_manager_impl.cc index 1b8fd0187ed..b737e452a26 100644 --- a/src/components/application_manager/src/application_manager_impl.cc +++ b/src/components/application_manager/src/application_manager_impl.cc @@ -2031,7 +2031,7 @@ void ApplicationManagerImpl::ProcessServiceStatusUpdate( const uint32_t connection_key, hmi_apis::Common_ServiceType::eType service_type, hmi_apis::Common_ServiceEvent::eType service_event, - utils::Optional + utils::Optional service_update_reason) { LOG4CXX_AUTO_TRACE(logger_); diff --git a/src/components/application_manager/src/message_helper/message_helper.cc b/src/components/application_manager/src/message_helper/message_helper.cc index dee157d92c1..e98deab2d2b 100644 --- a/src/components/application_manager/src/message_helper/message_helper.cc +++ b/src/components/application_manager/src/message_helper/message_helper.cc @@ -2264,7 +2264,7 @@ MessageHelper::ServiceStatusUpdateNotificationBuilder::AddAppID( MessageHelper::ServiceStatusUpdateNotificationBuilder& MessageHelper::ServiceStatusUpdateNotificationBuilder::AddServiceUpdateReason( - const ServiceUpdateReason service_update_reason) { + const ServiceStatusUpdateReason service_update_reason) { (*notification_)[strings::msg_params][hmi_notification::reason] = service_update_reason; diff --git a/src/components/application_manager/test/application_manager_impl_test.cc b/src/components/application_manager/test/application_manager_impl_test.cc index cc6c1418c4f..f3297388ff2 100644 --- a/src/components/application_manager/test/application_manager_impl_test.cc +++ b/src/components/application_manager/test/application_manager_impl_test.cc @@ -107,10 +107,11 @@ const WindowID kDefaultWindowId = typedef MockMessageHelper::MockServiceStatusUpdateNotificationBuilder* MockServiceStatusUpdatePtr; -typedef hmi_apis::Common_ServiceUpdateReason::eType ServiceUpdateReason; +typedef hmi_apis::Common_ServiceStatusUpdateReason::eType + ServiceStatusUpdateReason; typedef hmi_apis::Common_ServiceType::eType ServiceType; typedef hmi_apis::Common_ServiceEvent::eType ServiceEvent; -typedef utils::Optional UpdateReasonOptional; +typedef utils::Optional UpdateReasonOptional; #if defined(CLOUD_APP_WEBSOCKET_TRANSPORT_SUPPORT) // Cloud application params @@ -177,11 +178,7 @@ class ApplicationManagerImplTest .WillByDefault(DoAll(SetArgPointee<3u>(app_id_), Return(0))); ON_CALL(mock_connection_handler_, get_session_observer()) .WillByDefault(ReturnRef(mock_session_observer_)); - std::unique_ptr unique_rpc_service( - new MockRPCService); - app_manager_impl_->SetRPCService(unique_rpc_service); - mock_rpc_service_ = - static_cast(&(app_manager_impl_->GetRPCService())); + app_manager_impl_->SetMockRPCService(mock_rpc_service_); app_manager_impl_->resume_controller().set_resumption_storage( mock_storage_); @@ -326,8 +323,9 @@ INSTANTIATE_TEST_CASE_P( TEST_P(ApplicationManagerImplTest, ProcessServiceStatusUpdate_SendMessageToHMI) { - smart_objects::SmartObjectSPtr notification_( - new smart_objects::SmartObject(smart_objects::SmartType_Map)); + smart_objects::SmartObjectSPtr notification_ = + std::make_shared( + smart_objects::SmartType_Map); (*notification_)[strings::msg_params][hmi_notification::service_type] = GetParam().service_type_; (*notification_)[strings::msg_params][hmi_notification::service_event] = @@ -347,7 +345,7 @@ TEST_P(ApplicationManagerImplTest, ON_CALL(*mock_service_status_update_, notification()) .WillByDefault(Return(notification_)); - EXPECT_CALL(*mock_rpc_service_, ManageHMICommand(notification_)) + EXPECT_CALL(*mock_rpc_service_, ManageHMICommand(notification_, _)) .WillOnce(Return(true)); app_manager_impl_->ProcessServiceStatusUpdate(kConnectionKey, diff --git a/src/components/application_manager/test/help_prompt_manager_test.cc b/src/components/application_manager/test/help_prompt_manager_test.cc index 502c1bdbbf2..1a719012a81 100644 --- a/src/components/application_manager/test/help_prompt_manager_test.cc +++ b/src/components/application_manager/test/help_prompt_manager_test.cc @@ -1,4 +1,4 @@ -/* +/* * Copyright (c) 2018, Ford Motor Company * All rights reserved. * diff --git a/src/components/application_manager/test/include/application_manager/mock_message_helper.h b/src/components/application_manager/test/include/application_manager/mock_message_helper.h index 21c88fbabc2..e74e43df013 100644 --- a/src/components/application_manager/test/include/application_manager/mock_message_helper.h +++ b/src/components/application_manager/test/include/application_manager/mock_message_helper.h @@ -356,7 +356,7 @@ class MockMessageHelper { const uint32_t app_id, const hmi_apis::Common_ServiceType::eType service_type, const hmi_apis::Common_ServiceEvent::eType service_event, - const hmi_apis::Common_ServiceUpdateReason::eType + const hmi_apis::Common_ServiceStatusUpdateReason::eType service_update_reason)); class MockServiceStatusUpdateNotificationBuilder @@ -376,7 +376,7 @@ class MockMessageHelper { MOCK_METHOD1(AddServiceUpdateReason, MessageHelper::ServiceStatusUpdateNotificationBuilder&( - const hmi_apis::Common_ServiceUpdateReason::eType)); + const hmi_apis::Common_ServiceStatusUpdateReason::eType)); MOCK_CONST_METHOD0(notification, smart_objects::SmartObjectSPtr()); }; diff --git a/src/components/application_manager/test/message_helper/message_helper_test.cc b/src/components/application_manager/test/message_helper/message_helper_test.cc index 966548d7072..8d75cacdf38 100644 --- a/src/components/application_manager/test/message_helper/message_helper_test.cc +++ b/src/components/application_manager/test/message_helper/message_helper_test.cc @@ -74,7 +74,7 @@ typedef MessageHelper::ServiceStatusUpdateNotificationBuilder::ServiceType typedef MessageHelper::ServiceStatusUpdateNotificationBuilder::ServiceEvent ServiceEvent; typedef MessageHelper::ServiceStatusUpdateNotificationBuilder:: - ServiceUpdateReason UpdateReason; + ServiceStatusUpdateReason UpdateReason; typedef MessageHelper::ServiceStatusUpdateNotificationBuilder ServiceStatusUpdateBuilder; diff --git a/src/components/application_manager/test/mock_message_helper.cc b/src/components/application_manager/test/mock_message_helper.cc index 50fcdd4692a..c11261fe886 100755 --- a/src/components/application_manager/test/mock_message_helper.cc +++ b/src/components/application_manager/test/mock_message_helper.cc @@ -625,7 +625,8 @@ MessageHelper::ServiceStatusUpdateNotificationBuilder::AddAppID( MessageHelper::ServiceStatusUpdateNotificationBuilder& MessageHelper::ServiceStatusUpdateNotificationBuilder::AddServiceUpdateReason( - const hmi_apis::Common_ServiceUpdateReason::eType service_update_reason) { + const hmi_apis::Common_ServiceStatusUpdateReason::eType + service_update_reason) { return MockMessageHelper::on_service_update_builder_mock() ->AddServiceUpdateReason(service_update_reason); } diff --git a/src/components/application_manager/test/policy_event_observer_test.cc b/src/components/application_manager/test/policy_event_observer_test.cc index a425dfe44f2..a74b12071cd 100644 --- a/src/components/application_manager/test/policy_event_observer_test.cc +++ b/src/components/application_manager/test/policy_event_observer_test.cc @@ -38,10 +38,6 @@ #include "policy/policy_types.h" #include "smart_objects/smart_object.h" -#ifdef EXTERNAL_PROPRIETARY_MODE -#include "policy/ptu_retry_handler.h" -#endif - namespace test { namespace components { namespace policy_test { diff --git a/src/components/include/application_manager/policies/policy_handler_interface.h b/src/components/include/application_manager/policies/policy_handler_interface.h index ae18779c035..6c08dbcb0b3 100644 --- a/src/components/include/application_manager/policies/policy_handler_interface.h +++ b/src/components/include/application_manager/policies/policy_handler_interface.h @@ -52,6 +52,10 @@ #include "smart_objects/smart_object.h" #include "utils/callable.h" #include "utils/custom_string.h" +#include "utils/optional.h" +#ifdef EXTERNAL_PROPRIETARY_MODE +#include "policy/ptu_retry_handler.h" +#endif // EXTERNAL_PROPRIETARY_MODE using namespace ::rpc::policy_table_interface_base; namespace policy { diff --git a/src/components/interfaces/HMI_API.xml b/src/components/interfaces/HMI_API.xml index 54cf2c14355..717ddb04f34 100644 --- a/src/components/interfaces/HMI_API.xml +++ b/src/components/interfaces/HMI_API.xml @@ -402,7 +402,7 @@ Indicates that a button press of the Play/Pause button would stop the current playback. - + Enumeration that describes possible contexts the application might be in on HU. @@ -3486,7 +3486,6 @@ - If included, the platform supports RC climate controls. For this baseline version, maxsize=1. i.e. only one climate control module is supported. @@ -3537,10 +3536,10 @@ The position of the haptic rectangle to be highlighted. The center of this rectangle will be "touched" when a press occurs. - + Specifies the version number of the SmartDeviceLink protocol that is supported by the mobile application or app service - + The major version indicates versions that is not-compatible to previous versions. @@ -3561,7 +3560,7 @@ Refers to the RPC service. - + @@ -3570,23 +3569,23 @@ When a request for a Service is Accepted. - + When a request for a Service is Rejected. - - + + - + When a Service is rejected because the system was unable to get a required Policy Table Update. When a Service is rejected because the security certificate is invalid/expired. - + When a Service is rejected because the system was unable to get a valid SystemTime from HMI, which is required for certificate authentication. - - + + @@ -3730,7 +3729,7 @@ - + @@ -3801,7 +3800,7 @@ Using this action plus a supplied direction can give the type of turn. - + @@ -4133,14 +4132,14 @@ Specifies service update event. - + The reason for a service event. Certain events may not have a reason, such as when a service is ACCEPTED (which is the normal expected behavior). ID of the application which triggered the update. - + Request from SDL to HMI to obtain current UTC time. @@ -4492,7 +4491,7 @@ Selected file type. - + Request from SDL to HMI to obtain information about head unit system. @@ -5338,7 +5337,6 @@ - Used to show a custom form; it can be a parent or child screen. If no parent screen is designated, it is set as a parent screen. @@ -6823,18 +6821,18 @@ This request asks the module for current data related to the specific service. It also includes an option to subscribe to that service for future updates - + The type of service that is to be offered by this app. See AppServiceType for known enum equivalent types. Parameter is a string to allow for new service types to be used by apps on older versions of SDL Core. - + If true, the consumer is requesting to subscribe to all future updates from the service publisher. If false, the consumer doesn't wish to subscribe and should be unsubscribed if it was previously subscribed. - + - This response includes the data that was requested from the specific service + This response includes the data that was requested from the specific service @@ -6842,15 +6840,15 @@ Fully qualified URI based on a predetermined scheme provided by the app service. SDL makes no guarantee that this URI is correct. - + The service ID that the app consumer wishes to send this URI. - + This string is the appID of the app requesting the app service provider take the specific action. This will automatically be set by SDL Core in requests originating from the HMI - + This flag signals the requesting consumer would like this service to become the active primary service of the destination's type. @@ -6895,7 +6893,7 @@ True if the service was set to the default service of this type. False if the app was not to be the default - + @@ -6906,7 +6904,7 @@ The ID of the service to be activated - + diff --git a/src/components/policy/policy_external/src/policy_manager_impl.cc b/src/components/policy/policy_external/src/policy_manager_impl.cc index 33b862e2df5..cc3b03e2d9a 100644 --- a/src/components/policy/policy_external/src/policy_manager_impl.cc +++ b/src/components/policy/policy_external/src/policy_manager_impl.cc @@ -52,7 +52,6 @@ #include "policy/access_remote.h" #include "policy/access_remote_impl.h" -#include "policy/ptu_retry_handler.h" #include "utils/timer_task_impl.h" __attribute__((visibility("default"))) policy::PolicyManager* CreateManager() { diff --git a/src/components/protocol_handler/include/protocol_handler/protocol_handler_impl.h b/src/components/protocol_handler/include/protocol_handler/protocol_handler_impl.h index 336ed1f3381..e3b75f805ad 100644 --- a/src/components/protocol_handler/include/protocol_handler/protocol_handler_impl.h +++ b/src/components/protocol_handler/include/protocol_handler/protocol_handler_impl.h @@ -468,6 +468,8 @@ class ProtocolHandlerImpl } #endif + void OnAuthTokenUpdated(const std::string&, const std::string&) OVERRIDE; + private: void SendEndServicePrivate(int32_t primary_connection_id, int32_t connection_id, @@ -545,6 +547,10 @@ class ProtocolHandlerImpl const transport_manager::ConnectionUID connection_id, const transport_manager::CommunicationError& error) OVERRIDE; + void OnConnectionPending( + const transport_manager::DeviceInfo& device_info, + const transport_manager::ConnectionUID connection_id) OVERRIDE; + /** * @brief Notifies that configuration of a transport has been updated. * diff --git a/src/components/protocol_handler/include/protocol_handler/service_status_update_handler_listener.h b/src/components/protocol_handler/include/protocol_handler/service_status_update_handler_listener.h index e784ae6eb68..3c782f72f83 100644 --- a/src/components/protocol_handler/include/protocol_handler/service_status_update_handler_listener.h +++ b/src/components/protocol_handler/include/protocol_handler/service_status_update_handler_listener.h @@ -68,7 +68,7 @@ class ServiceStatusUpdateHandlerListener { const uint32_t connection_key, hmi_apis::Common_ServiceType::eType service_type, hmi_apis::Common_ServiceEvent::eType service_event, - utils::Optional + utils::Optional service_update_reason) = 0; }; diff --git a/src/components/protocol_handler/src/service_status_update_handler.cc b/src/components/protocol_handler/src/service_status_update_handler.cc index 27eb6790993..e81f59677d9 100644 --- a/src/components/protocol_handler/src/service_status_update_handler.cc +++ b/src/components/protocol_handler/src/service_status_update_handler.cc @@ -28,7 +28,7 @@ void ServiceStatusUpdateHandler::OnServiceUpdate( const protocol_handler::ServiceType service_type, ServiceStatus service_status) { using namespace hmi_apis; - typedef utils::Optional + typedef utils::Optional UpdateReasonOptional; auto hmi_service_type = GetHMIServiceType(service_type); @@ -55,7 +55,7 @@ void ServiceStatusUpdateHandler::OnServiceUpdate( UpdateReasonOptional(UpdateReasonOptional::EMPTY)); } case ServiceStatus::PTU_FAILED: { - auto update_reason = Common_ServiceUpdateReason::PTU_FAILED; + auto update_reason = Common_ServiceStatusUpdateReason::PTU_FAILED; return listener_->ProcessServiceStatusUpdate( connection_key, hmi_service_type, @@ -63,7 +63,7 @@ void ServiceStatusUpdateHandler::OnServiceUpdate( update_reason); } case ServiceStatus::CERT_INVALID: { - auto update_reason = Common_ServiceUpdateReason::INVALID_CERT; + auto update_reason = Common_ServiceStatusUpdateReason::INVALID_CERT; return listener_->ProcessServiceStatusUpdate( connection_key, hmi_service_type, @@ -71,7 +71,7 @@ void ServiceStatusUpdateHandler::OnServiceUpdate( update_reason); } case ServiceStatus::INVALID_TIME: { - auto update_reason = Common_ServiceUpdateReason::INVALID_TIME; + auto update_reason = Common_ServiceStatusUpdateReason::INVALID_TIME; return listener_->ProcessServiceStatusUpdate( connection_key, hmi_service_type, diff --git a/src/components/protocol_handler/test/include/protocol_handler/mock_service_status_update_handler_listener.h b/src/components/protocol_handler/test/include/protocol_handler/mock_service_status_update_handler_listener.h index 37485aa3ac4..ccbfeb84388 100644 --- a/src/components/protocol_handler/test/include/protocol_handler/mock_service_status_update_handler_listener.h +++ b/src/components/protocol_handler/test/include/protocol_handler/mock_service_status_update_handler_listener.h @@ -48,7 +48,7 @@ class MockServiceStatusUpdateHandlerListener void(const uint32_t, hmi_apis::Common_ServiceType::eType, hmi_apis::Common_ServiceEvent::eType, - utils::Optional)); + utils::Optional)); }; } // namespace protocol_handler_test } // namespace components diff --git a/src/components/protocol_handler/test/service_status_update_handler_test.cc b/src/components/protocol_handler/test/service_status_update_handler_test.cc index fa64ffbb3b7..b587194d98f 100644 --- a/src/components/protocol_handler/test/service_status_update_handler_test.cc +++ b/src/components/protocol_handler/test/service_status_update_handler_test.cc @@ -46,7 +46,8 @@ using namespace protocol_handler; using ::testing::_; using ::testing::Return; using namespace hmi_apis; -typedef utils::Optional UpdateReasonOptional; +typedef utils::Optional + UpdateReasonOptional; typedef std::shared_ptr ServiceStatusUpdateHandlerPtr; typedef std::shared_ptr @@ -96,19 +97,19 @@ class ServiceStatusUpdateHandlerTest return UpdateReasonOptional::EMPTY; } case ServiceStatus::PTU_FAILED: { - auto reason = Common_ServiceUpdateReason::PTU_FAILED; + auto reason = Common_ServiceStatusUpdateReason::PTU_FAILED; return reason; } case ServiceStatus::CERT_INVALID: { - auto reason = Common_ServiceUpdateReason::INVALID_CERT; + auto reason = Common_ServiceStatusUpdateReason::INVALID_CERT; return reason; } case ServiceStatus::INVALID_TIME: { - auto reason = Common_ServiceUpdateReason::INVALID_TIME; + auto reason = Common_ServiceStatusUpdateReason::INVALID_TIME; return reason; } default: { - auto reason = Common_ServiceUpdateReason::INVALID_ENUM; + auto reason = Common_ServiceStatusUpdateReason::INVALID_ENUM; return reason; } } From 8e009255bb5914de1b56c5cb2fb1f85bfc667588 Mon Sep 17 00:00:00 2001 From: Maksym Ked Date: Fri, 7 Jun 2019 13:56:16 +0300 Subject: [PATCH 10/19] Updates according to proposal changes Added new result codes for ServiceStatusUpdateReasonStructure --- src/components/interfaces/HMI_API.xml | 6 ++++ .../service_status_update_handler.h | 4 ++- .../protocol_handler/src/handshake_handler.cc | 2 +- .../src/protocol_handler_impl.cc | 2 +- .../src/service_status_update_handler.cc | 19 +++++++++++ .../service_status_update_handler_test.cc | 32 +++++++++++++++++-- 6 files changed, 60 insertions(+), 5 deletions(-) diff --git a/src/components/interfaces/HMI_API.xml b/src/components/interfaces/HMI_API.xml index 717ddb04f34..ff4947e7a87 100644 --- a/src/components/interfaces/HMI_API.xml +++ b/src/components/interfaces/HMI_API.xml @@ -3585,6 +3585,12 @@ When a Service is rejected because the system was unable to get a valid SystemTime from HMI, which is required for certificate authentication. + + When a Service is rejected because the system configuration ini file requires the service must be protected, but the app asks for an unprotected service. + + + When a mobile app requests a protected service, but the system starts an unprotected service instead. + diff --git a/src/components/protocol_handler/include/protocol_handler/service_status_update_handler.h b/src/components/protocol_handler/include/protocol_handler/service_status_update_handler.h index 125f3b2909b..cbe374d515e 100644 --- a/src/components/protocol_handler/include/protocol_handler/service_status_update_handler.h +++ b/src/components/protocol_handler/include/protocol_handler/service_status_update_handler.h @@ -49,7 +49,9 @@ enum class ServiceStatus { SERVICE_START_FAILED, PTU_FAILED, CERT_INVALID, - INVALID_TIME + INVALID_TIME, + PROTECTION_ENFORCED, + PROTECTION_DISABLED }; /** diff --git a/src/components/protocol_handler/src/handshake_handler.cc b/src/components/protocol_handler/src/handshake_handler.cc index 405715fe1be..669b73c18b2 100644 --- a/src/components/protocol_handler/src/handshake_handler.cc +++ b/src/components/protocol_handler/src/handshake_handler.cc @@ -225,7 +225,7 @@ void HandshakeHandler::ProcessFailedHandshake(BsonObject& params, service_status_update_handler_.OnServiceUpdate( this->connection_key(), context_.service_type_, - ServiceStatus::SERVICE_ACCEPTED); + ServiceStatus::PROTECTION_DISABLED); protocol_handler_.SendStartSessionAck(context_.connection_id_, context_.new_session_id_, protocol_version_, diff --git a/src/components/protocol_handler/src/protocol_handler_impl.cc b/src/components/protocol_handler/src/protocol_handler_impl.cc index c2423b2fb63..ec4b96e385c 100644 --- a/src/components/protocol_handler/src/protocol_handler_impl.cc +++ b/src/components/protocol_handler/src/protocol_handler_impl.cc @@ -1672,7 +1672,7 @@ RESULT_CODE ProtocolHandlerImpl::HandleControlMessageStartSession( << service_type << ", over transport: " << transport << ", disallowed by settings."); service_status_update_handler_->OnServiceUpdate( - connection_key, service_type, ServiceStatus::SERVICE_START_FAILED); + connection_key, service_type, ServiceStatus::PROTECTION_ENFORCED); SendStartSessionNAck( connection_id, session_id, protocol_version, service_type); return RESULT_OK; diff --git a/src/components/protocol_handler/src/service_status_update_handler.cc b/src/components/protocol_handler/src/service_status_update_handler.cc index e81f59677d9..9bef1b973fb 100644 --- a/src/components/protocol_handler/src/service_status_update_handler.cc +++ b/src/components/protocol_handler/src/service_status_update_handler.cc @@ -30,6 +30,7 @@ void ServiceStatusUpdateHandler::OnServiceUpdate( using namespace hmi_apis; typedef utils::Optional UpdateReasonOptional; + LOG4CXX_AUTO_TRACE(logger_); auto hmi_service_type = GetHMIServiceType(service_type); switch (service_status) { @@ -78,6 +79,24 @@ void ServiceStatusUpdateHandler::OnServiceUpdate( Common_ServiceEvent::REQUEST_REJECTED, update_reason); } + case ServiceStatus::PROTECTION_ENFORCED: { + auto update_reason = + Common_ServiceStatusUpdateReason::PROTECTION_ENFORCED; + return listener_->ProcessServiceStatusUpdate( + connection_key, + hmi_service_type, + Common_ServiceEvent::REQUEST_REJECTED, + update_reason); + } + case ServiceStatus::PROTECTION_DISABLED: { + auto update_reason = + Common_ServiceStatusUpdateReason::PROTECTION_DISABLED; + return listener_->ProcessServiceStatusUpdate( + connection_key, + hmi_service_type, + Common_ServiceEvent::REQUEST_ACCEPTED, + update_reason); + } default: { LOG4CXX_WARN(logger_, "Received unknown ServiceStatus: " diff --git a/src/components/protocol_handler/test/service_status_update_handler_test.cc b/src/components/protocol_handler/test/service_status_update_handler_test.cc index b587194d98f..8da89bdcd1b 100644 --- a/src/components/protocol_handler/test/service_status_update_handler_test.cc +++ b/src/components/protocol_handler/test/service_status_update_handler_test.cc @@ -73,7 +73,8 @@ class ServiceStatusUpdateHandlerTest Common_ServiceEvent::eType GetServiceEvent(ServiceStatus status) { switch (status) { - case ServiceStatus::SERVICE_ACCEPTED: { + case ServiceStatus::SERVICE_ACCEPTED: + case ServiceStatus::PROTECTION_DISABLED: { return Common_ServiceEvent::REQUEST_ACCEPTED; } case ServiceStatus::SERVICE_RECEIVED: { @@ -82,7 +83,8 @@ class ServiceStatusUpdateHandlerTest case ServiceStatus::SERVICE_START_FAILED: case ServiceStatus::PTU_FAILED: case ServiceStatus::CERT_INVALID: - case ServiceStatus::INVALID_TIME: { + case ServiceStatus::INVALID_TIME: + case ServiceStatus::PROTECTION_ENFORCED: { return Common_ServiceEvent::REQUEST_REJECTED; } default: { return Common_ServiceEvent::INVALID_ENUM; } @@ -108,6 +110,14 @@ class ServiceStatusUpdateHandlerTest auto reason = Common_ServiceStatusUpdateReason::INVALID_TIME; return reason; } + case ServiceStatus::PROTECTION_ENFORCED: { + auto reason = Common_ServiceStatusUpdateReason::PROTECTION_ENFORCED; + return reason; + } + case ServiceStatus::PROTECTION_DISABLED: { + auto reason = Common_ServiceStatusUpdateReason::PROTECTION_DISABLED; + return reason; + } default: { auto reason = Common_ServiceStatusUpdateReason::INVALID_ENUM; return reason; @@ -170,6 +180,24 @@ INSTANTIATE_TEST_CASE_P( ServiceUpdate(ServiceType::kMobileNav, ServiceStatus::PTU_FAILED), ServiceUpdate(ServiceType::kRpc, ServiceStatus::PTU_FAILED))); +INSTANTIATE_TEST_CASE_P( + OnServiceUpdate_PROTECTION_ENFRORCED, + ServiceStatusUpdateHandlerTest, + ::testing::Values( + ServiceUpdate(ServiceType::kAudio, ServiceStatus::PROTECTION_ENFORCED), + ServiceUpdate(ServiceType::kMobileNav, + ServiceStatus::PROTECTION_ENFORCED), + ServiceUpdate(ServiceType::kRpc, ServiceStatus::PROTECTION_ENFORCED))); + +INSTANTIATE_TEST_CASE_P( + OnServiceUpdate_PROTECTION_DISABLED, + ServiceStatusUpdateHandlerTest, + ::testing::Values( + ServiceUpdate(ServiceType::kAudio, ServiceStatus::PROTECTION_DISABLED), + ServiceUpdate(ServiceType::kMobileNav, + ServiceStatus::PROTECTION_DISABLED), + ServiceUpdate(ServiceType::kRpc, ServiceStatus::PROTECTION_DISABLED))); + TEST_P(ServiceStatusUpdateHandlerTest, OnServiceUpdate) { auto service_event_ = GetServiceEvent(GetParam().service_status_); auto reason_ = GetUpdateReason(GetParam().service_status_); From cdd3b1fc26cacbc1ab276476599f051de2633dd5 Mon Sep 17 00:00:00 2001 From: mked-luxoft Date: Tue, 20 Aug 2019 17:53:20 +0300 Subject: [PATCH 11/19] Fixes after rebase --- .../policy/policy_external/src/policy_manager_impl.cc | 3 --- 1 file changed, 3 deletions(-) diff --git a/src/components/policy/policy_external/src/policy_manager_impl.cc b/src/components/policy/policy_external/src/policy_manager_impl.cc index cc3b03e2d9a..0629fea0225 100644 --- a/src/components/policy/policy_external/src/policy_manager_impl.cc +++ b/src/components/policy/policy_external/src/policy_manager_impl.cc @@ -836,8 +836,6 @@ void PolicyManagerImpl::CheckPermissions(const PTString& device_id, "CheckPermissions for " << app_id << " and rpc " << rpc << " for " << hmi_level << " level."); - const std::string device_id = GetCurrentDeviceId(app_id); - Permissions rpc_permissions; // Check, if there are calculated permission present in cache @@ -1009,7 +1007,6 @@ policy_table::Strings PolicyManagerImpl::GetGroupsNames( void PolicyManagerImpl::SendNotificationOnPermissionsUpdated( const std::string& device_id, const std::string& application_id) { LOG4CXX_AUTO_TRACE(logger_); - const std::string device_id = GetCurrentDeviceId(application_id); if (device_id.empty()) { LOG4CXX_WARN(logger_, "Couldn't find device info for application id " From 064cd91982455fa812b1b71b2ed37eb792e2757d Mon Sep 17 00:00:00 2001 From: mked-luxoft Date: Wed, 21 Aug 2019 15:51:49 +0300 Subject: [PATCH 12/19] fixup! Added OnServiceUpdate notification --- ...ion.h => on_service_update_notification.h} | 22 +++---- ...n.cc => on_service_update_notification.cc} | 12 ++-- .../sdl_rpc_plugin/src/hmi_command_factory.cc | 5 +- ...service_status_update_notification_test.cc | 16 ++--- .../application_manager/mock_message_helper.h | 64 +++++++++---------- 5 files changed, 58 insertions(+), 61 deletions(-) rename src/components/application_manager/rpc_plugins/sdl_rpc_plugin/include/sdl_rpc_plugin/commands/hmi/{on_service_status_update_notification.h => on_service_update_notification.h} (79%) rename src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/hmi/{on_service_status_update_notification.cc => on_service_update_notification.cc} (85%) diff --git a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/include/sdl_rpc_plugin/commands/hmi/on_service_status_update_notification.h b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/include/sdl_rpc_plugin/commands/hmi/on_service_update_notification.h similarity index 79% rename from src/components/application_manager/rpc_plugins/sdl_rpc_plugin/include/sdl_rpc_plugin/commands/hmi/on_service_status_update_notification.h rename to src/components/application_manager/rpc_plugins/sdl_rpc_plugin/include/sdl_rpc_plugin/commands/hmi/on_service_update_notification.h index f51b0c2907a..bfa9b6e6aef 100644 --- a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/include/sdl_rpc_plugin/commands/hmi/on_service_status_update_notification.h +++ b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/include/sdl_rpc_plugin/commands/hmi/on_service_update_notification.h @@ -30,8 +30,8 @@ * POSSIBILITY OF SUCH DAMAGE. */ -#ifndef SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_SDL_RPC_PLUGIN_INCLUDE_SDL_RPC_PLUGIN_COMMANDS_HMI_ON_SERVICE_STATUS_UPDATE_NOTIFICATION_H_ -#define SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_SDL_RPC_PLUGIN_INCLUDE_SDL_RPC_PLUGIN_COMMANDS_HMI_ON_SERVICE_STATUS_UPDATE_NOTIFICATION_H_ +#ifndef SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_SDL_RPC_PLUGIN_INCLUDE_SDL_RPC_PLUGIN_COMMANDS_HMI_ON_SERVICE_UPDATE_NOTIFICATION_H_ +#define SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_SDL_RPC_PLUGIN_INCLUDE_SDL_RPC_PLUGIN_COMMANDS_HMI_ON_SERVICE_UPDATE_NOTIFICATION_H_ #include "application_manager/commands/notification_to_hmi.h" @@ -42,29 +42,29 @@ namespace commands { namespace hmi { /** - * @brief OnServiceStatusUpdateNotification command class + * @brief OnServiceUpdateNotification command class **/ -class OnServiceStatusUpdateNotification +class OnServiceUpdateNotification : public app_mngr::commands::NotificationToHMI { public: /** - * @brief OnServiceStatusUpdateNotification class constructor + * @brief OnServiceUpdateNotification class constructor * @param application_manager ref to application manager * @param rpc_service ref to rpc service * @param hmi_capabilities ref to HMI capabilities * @param policy_handle ref to policy handler **/ - OnServiceStatusUpdateNotification( + OnServiceUpdateNotification( const app_mngr::commands::MessageSharedPtr& message, app_mngr::ApplicationManager& application_manager, app_mngr::rpc_service::RPCService& rpc_service, app_mngr::HMICapabilities& hmi_capabilities, - policy::PolicyHandlerInterface& policy_handle); + policy::PolicyHandlerInterface& policy_handler); /** - * @brief OnServiceStatusUpdateNotification class destructor + * @brief OnServiceUpdateNotification class destructor **/ - virtual ~OnServiceStatusUpdateNotification() OVERRIDE; + virtual ~OnServiceUpdateNotification() OVERRIDE; /** * @brief Execute command @@ -72,11 +72,11 @@ class OnServiceStatusUpdateNotification void Run() OVERRIDE; private: - DISALLOW_COPY_AND_ASSIGN(OnServiceStatusUpdateNotification); + DISALLOW_COPY_AND_ASSIGN(OnServiceUpdateNotification); }; } // namespace hmi } // namespace commands } // namespace sdl_rpc_plugin -#endif // SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_SDL_RPC_PLUGIN_INCLUDE_SDL_RPC_PLUGIN_COMMANDS_HMI_ON_SERVICE_STATUS_UPDATE_NOTIFICATION_H_ +#endif // SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_SDL_RPC_PLUGIN_INCLUDE_SDL_RPC_PLUGIN_COMMANDS_HMI_ON_SERVICE_UPDATE_NOTIFICATION_H_ diff --git a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/hmi/on_service_status_update_notification.cc b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/hmi/on_service_update_notification.cc similarity index 85% rename from src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/hmi/on_service_status_update_notification.cc rename to src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/hmi/on_service_update_notification.cc index 6dc5f9a7fc2..de03b752140 100644 --- a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/hmi/on_service_status_update_notification.cc +++ b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/hmi/on_service_update_notification.cc @@ -30,7 +30,7 @@ * POSSIBILITY OF SUCH DAMAGE. */ -#include "sdl_rpc_plugin/commands/hmi/on_service_status_update_notification.h" +#include "sdl_rpc_plugin/commands/hmi/on_service_update_notification.h" namespace sdl_rpc_plugin { using namespace application_manager; @@ -39,21 +39,21 @@ namespace commands { namespace hmi { -OnServiceStatusUpdateNotification::OnServiceStatusUpdateNotification( +OnServiceUpdateNotification::OnServiceUpdateNotification( const application_manager::commands::MessageSharedPtr& message, ApplicationManager& application_manager, rpc_service::RPCService& rpc_service, HMICapabilities& hmi_capabilities, - policy::PolicyHandlerInterface& policy_handle) + policy::PolicyHandlerInterface& policy_handler) : NotificationToHMI(message, application_manager, rpc_service, hmi_capabilities, - policy_handle) {} + policy_handler) {} -OnServiceStatusUpdateNotification::~OnServiceStatusUpdateNotification() {} +OnServiceUpdateNotification::~OnServiceUpdateNotification() {} -void OnServiceStatusUpdateNotification::Run() { +void OnServiceUpdateNotification::Run() { LOG4CXX_AUTO_TRACE(logger_); SendNotification(); } diff --git a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/hmi_command_factory.cc b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/hmi_command_factory.cc index 6ac398c0938..a0dee162dd2 100644 --- a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/hmi_command_factory.cc +++ b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/hmi_command_factory.cc @@ -247,7 +247,7 @@ #include "sdl_rpc_plugin/commands/hmi/bc_get_file_path_request.h" #include "sdl_rpc_plugin/commands/hmi/bc_get_file_path_response.h" -#include "sdl_rpc_plugin/commands/hmi/on_service_status_update_notification.h" +#include "sdl_rpc_plugin/commands/hmi/on_service_update_notification.h" #include "sdl_rpc_plugin/commands/hmi/rc_get_capabilities_request.h" #include "sdl_rpc_plugin/commands/hmi/rc_get_capabilities_response.h" #include "sdl_rpc_plugin/commands/hmi/rc_is_ready_request.h" @@ -868,8 +868,7 @@ CommandCreator& HMICommandFactory::get_creator_factory( : factory.GetCreator(); } case hmi_apis::FunctionID::BasicCommunication_OnServiceUpdate: { - return factory - .GetCreator(); + return factory.GetCreator(); } case hmi_apis::FunctionID::Navigation_OnWayPointChange: { return factory.GetCreator(); diff --git a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/test/commands/hmi/on_service_status_update_notification_test.cc b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/test/commands/hmi/on_service_status_update_notification_test.cc index 5df1d6e2076..e35c06b192c 100644 --- a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/test/commands/hmi/on_service_status_update_notification_test.cc +++ b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/test/commands/hmi/on_service_status_update_notification_test.cc @@ -36,19 +36,19 @@ #include "application_manager/mock_application_manager.h" #include "application_manager/smart_object_keys.h" #include "gtest/gtest.h" -#include "hmi/on_service_status_update_notification.h" +#include "hmi/on_service_update_notification.h" #include "smart_objects/smart_object.h" namespace test { namespace components { namespace commands_test { namespace hmi_commands_test { -namespace on_service_status_update_notification { +namespace on_service_update_notification { using namespace application_manager; -using sdl_rpc_plugin::commands::hmi::OnServiceStatusUpdateNotification; +using sdl_rpc_plugin::commands::hmi::OnServiceUpdateNotification; -typedef std::shared_ptr NotificationPtr; +typedef std::shared_ptr NotificationPtr; typedef hmi_apis::Common_ServiceType::eType ServiceType; typedef hmi_apis::Common_ServiceEvent::eType ServiceEvent; @@ -57,10 +57,10 @@ const uint32_t kConnectionKey = 1232u; const uint32_t kHmi_app_id = 321u; } // namespace -class OnServiceStatusUpdateNotificationTest +class OnServiceUpdateNotificationTest : public CommandsTest { public: - OnServiceStatusUpdateNotificationTest() + OnServiceUpdateNotificationTest() : message_(CreateMessage(smart_objects::SmartType_Map)) {} public: @@ -68,13 +68,13 @@ class OnServiceStatusUpdateNotificationTest NotificationPtr command_; }; -TEST_F(OnServiceStatusUpdateNotificationTest, SendNotificationToHMI) { +TEST_F(OnServiceUpdateNotificationTest, SendNotificationToHMI) { (*message_)[strings::msg_params][hmi_notification::service_type] = ServiceType::AUDIO; (*message_)[strings::msg_params][hmi_notification::service_event] = ServiceEvent::REQUEST_ACCEPTED; (*message_)[strings::msg_params][strings::app_id] = kConnectionKey; - command_ = CreateCommand(message_); + command_ = CreateCommand(message_); EXPECT_CALL(mock_rpc_service_, SendMessageToHMI(message_)).Times(1); diff --git a/src/components/application_manager/test/include/application_manager/mock_message_helper.h b/src/components/application_manager/test/include/application_manager/mock_message_helper.h index e74e43df013..6f06a9adce8 100644 --- a/src/components/application_manager/test/include/application_manager/mock_message_helper.h +++ b/src/components/application_manager/test/include/application_manager/mock_message_helper.h @@ -346,44 +346,42 @@ class MockMessageHelper { CreateDisplayCapabilityUpdateToMobile, smart_objects::SmartObjectSPtr(const smart_objects::SmartObject&, application_manager::Application&)); - MOCK_METHOD3(CreateOnServiceStatusUpdateNotification, - smart_objects::SmartObject( - const uint32_t app_id, - const hmi_apis::Common_ServiceType::eType service_type, - const hmi_apis::Common_ServiceEvent::eType service_event)); - MOCK_METHOD4(CreateOnServiceStatusUpdateNotification, - smart_objects::SmartObject( - const uint32_t app_id, - const hmi_apis::Common_ServiceType::eType service_type, - const hmi_apis::Common_ServiceEvent::eType service_event, - const hmi_apis::Common_ServiceStatusUpdateReason::eType - service_update_reason)); + MOCK_METHOD3(CreateOnServiceUpdateNotification, smart_objects::SmartObject( + const uint32_t app_id, + const hmi_apis::Common_ServiceType::eType service_type, + const hmi_apis::Common_ServiceEvent::eType service_event)); + MOCK_METHOD4(CreateOnServiceUpdateNotification, smart_objects::SmartObject( + const uint32_t app_id, + const hmi_apis::Common_ServiceType::eType service_type, + const hmi_apis::Common_ServiceEvent::eType service_event, + const hmi_apis::Common_ServiceStatusUpdateReason::eType + service_update_reason)); - class MockServiceStatusUpdateNotificationBuilder - : public MessageHelper::ServiceStatusUpdateNotificationBuilder { - public: - MockServiceStatusUpdateNotificationBuilder( - const MockServiceStatusUpdateNotificationBuilder& obj){}; - MockServiceStatusUpdateNotificationBuilder(){}; - MOCK_METHOD2(CreateBuilder, - MessageHelper::ServiceStatusUpdateNotificationBuilder( - hmi_apis::Common_ServiceType::eType, - hmi_apis::Common_ServiceEvent::eType)); +class MockServiceStatusUpdateNotificationBuilder + : public MessageHelper::ServiceStatusUpdateNotificationBuilder { + public: + MockServiceStatusUpdateNotificationBuilder( + const MockServiceStatusUpdateNotificationBuilder& obj){}; + MockServiceStatusUpdateNotificationBuilder(){}; + MOCK_METHOD2(CreateBuilder, + MessageHelper::ServiceStatusUpdateNotificationBuilder( + hmi_apis::Common_ServiceType::eType, + hmi_apis::Common_ServiceEvent::eType)); - MOCK_METHOD1(AddAppID, - MessageHelper::ServiceStatusUpdateNotificationBuilder&( - const uint32_t app_id)); + MOCK_METHOD1(AddAppID, + MessageHelper::ServiceStatusUpdateNotificationBuilder & + (const uint32_t app_id)); - MOCK_METHOD1(AddServiceUpdateReason, - MessageHelper::ServiceStatusUpdateNotificationBuilder&( - const hmi_apis::Common_ServiceStatusUpdateReason::eType)); + MOCK_METHOD1(AddServiceUpdateReason, + MessageHelper::ServiceStatusUpdateNotificationBuilder & + (const hmi_apis::Common_ServiceStatusUpdateReason::eType)); - MOCK_CONST_METHOD0(notification, smart_objects::SmartObjectSPtr()); - }; + MOCK_CONST_METHOD0(notification, smart_objects::SmartObjectSPtr()); +}; - static MockMessageHelper* message_helper_mock(); - static MockServiceStatusUpdateNotificationBuilder* - on_service_update_builder_mock(); +static MockMessageHelper* message_helper_mock(); +static MockServiceStatusUpdateNotificationBuilder* +on_service_update_builder_mock(); }; } // namespace application_manager From 4a63327a70e4d6fd817126c41e176a7a284c0a3c Mon Sep 17 00:00:00 2001 From: mked-luxoft Date: Wed, 21 Aug 2019 15:52:52 +0300 Subject: [PATCH 13/19] fixup! Added handling of service status update --- .../include/application_manager/policies/policy_handler.h | 3 +-- .../protocol_handler/service_status_update_handler.h | 2 +- .../test/service_status_update_handler_test.cc | 6 +++--- 3 files changed, 5 insertions(+), 6 deletions(-) diff --git a/src/components/application_manager/include/application_manager/policies/policy_handler.h b/src/components/application_manager/include/application_manager/policies/policy_handler.h index 21e39dad966..5ddac88dd9f 100644 --- a/src/components/application_manager/include/application_manager/policies/policy_handler.h +++ b/src/components/application_manager/include/application_manager/policies/policy_handler.h @@ -467,8 +467,7 @@ class PolicyHandler : public PolicyHandlerInterface, /** * @brief Callback for when a SetCloudAppProperties message is received - * from a - * mobile app + * from a mobile app * @param message The SetCloudAppProperties message */ void OnSetCloudAppProperties( diff --git a/src/components/protocol_handler/include/protocol_handler/service_status_update_handler.h b/src/components/protocol_handler/include/protocol_handler/service_status_update_handler.h index cbe374d515e..3f9e7df1b2f 100644 --- a/src/components/protocol_handler/include/protocol_handler/service_status_update_handler.h +++ b/src/components/protocol_handler/include/protocol_handler/service_status_update_handler.h @@ -38,7 +38,7 @@ namespace protocol_handler { /** - * @brief ServiceUpdateFailureReason helper enum containing reasons for + * @brief ServiceStatus helper enum containing reasons for * service * status to be updated */ diff --git a/src/components/protocol_handler/test/service_status_update_handler_test.cc b/src/components/protocol_handler/test/service_status_update_handler_test.cc index 8da89bdcd1b..7d4516a7ffa 100644 --- a/src/components/protocol_handler/test/service_status_update_handler_test.cc +++ b/src/components/protocol_handler/test/service_status_update_handler_test.cc @@ -39,7 +39,7 @@ namespace components { namespace protocol_handler_test { namespace { -const uint32_t kConnectioKey = 123u; +const uint32_t kConnectionKey = 123u; } using namespace protocol_handler; @@ -204,11 +204,11 @@ TEST_P(ServiceStatusUpdateHandlerTest, OnServiceUpdate) { EXPECT_CALL( *mock_service_status_update_handler_listener_, - ProcessServiceStatusUpdate(kConnectioKey, _, service_event_, reason_)) + ProcessServiceStatusUpdate(kConnectionKey, _, service_event_, reason_)) .Times(1); service_status_update_handler_->OnServiceUpdate( - kConnectioKey, GetParam().service_type_, GetParam().service_status_); + kConnectionKey, GetParam().service_type_, GetParam().service_status_); } TEST_F(ServiceStatusUpdateHandlerTest, GetHMIServiceType) { From 3f86f3864ae18515c5d1a9ddaf9f7fcaf4d59c62 Mon Sep 17 00:00:00 2001 From: mked-luxoft Date: Wed, 21 Aug 2019 15:53:30 +0300 Subject: [PATCH 14/19] fixup! Added sending error on PTU retries exceed allowed count --- .../application_manager/message_helper.h | 14 --------- .../src/message_helper/message_helper.cc | 29 ++++--------------- .../src/policies/policy_handler.cc | 9 ++---- .../application_manager/mock_message_helper.h | 5 ---- .../test/mock_message_helper.cc | 10 ------- 5 files changed, 8 insertions(+), 59 deletions(-) diff --git a/src/components/application_manager/include/application_manager/message_helper.h b/src/components/application_manager/include/application_manager/message_helper.h index b0412a52cf1..ddb6fb71f23 100644 --- a/src/components/application_manager/include/application_manager/message_helper.h +++ b/src/components/application_manager/include/application_manager/message_helper.h @@ -89,20 +89,6 @@ class MessageHelper { static smart_objects::SmartObjectSPtr CreateHMINotification( hmi_apis::FunctionID::eType function_id); - /** - * @brief CreateOnSystemRequestNotificationToMobile creates mobile - * OnSystemRequestNotification - * @param policy_data pt snapshot data - * @param connection_key connection key of application - * @param request_type OnSystemRequest request type - * @return OnSystemRequest notification smart object - */ - static smart_objects::SmartObjectSPtr - CreateOnSystemRequestNotificationToMobile( - const std::vector& policy_data, - const uint32_t connection_key, - const mobile_apis::RequestType::eType request_type); - /** * @brief ServiceStatusUpdateNotificationBuilder small utility class used for * more flexible construction of OnServiceUpdateNotification diff --git a/src/components/application_manager/src/message_helper/message_helper.cc b/src/components/application_manager/src/message_helper/message_helper.cc index e98deab2d2b..5c9e0e80b14 100644 --- a/src/components/application_manager/src/message_helper/message_helper.cc +++ b/src/components/application_manager/src/message_helper/message_helper.cc @@ -2465,49 +2465,32 @@ bool MessageHelper::SendUnsubscribedWayPoints(ApplicationManager& app_mngr) { return app_mngr.GetRPCService().ManageHMICommand(result); } -smart_objects::SmartObjectSPtr -MessageHelper::CreateOnSystemRequestNotificationToMobile( - const std::vector& policy_data, - const uint32_t app_id, - const mobile_apis::RequestType::eType request_type) { - auto notification = - CreateNotification(mobile_apis::FunctionID::OnSystemRequestID, app_id); - - (*notification)[strings::params][strings::binary_data] = - smart_objects::SmartObject(policy_data); - - (*notification)[strings::msg_params][strings::request_type] = request_type; - - return notification; -} - void MessageHelper::SendPolicySnapshotNotification( uint32_t connection_key, const std::vector& policy_data, const std::string& url, ApplicationManager& app_mngr) { + smart_objects::SmartObject content(smart_objects::SmartType_Map); const auto request_type = #if defined(PROPRIETARY_MODE) || defined(EXTERNAL_PROPRIETARY_MODE) mobile_apis::RequestType::PROPRIETARY; #else mobile_apis::RequestType::HTTP; #endif // PROPRIETARY || EXTERNAL_PROPRIETARY_MODE - auto notification = CreateOnSystemRequestNotificationToMobile( - policy_data, connection_key, request_type); + + content[strings::msg_params][strings::request_type] = request_type; if (!url.empty()) { - (*notification)[strings::msg_params][strings::url] = + content[strings::msg_params][strings::url] = url; // Doesn't work with mobile_notification::syncp_url ("URL") } else { LOG4CXX_WARN(logger_, "No service URLs"); } - (*notification)[strings::params][strings::binary_data] = + content[strings::params][strings::binary_data] = smart_objects::SmartObject(policy_data); - PrintSmartObject(*notification); - app_mngr.GetRPCService().ManageMobileCommand(notification, - commands::Command::SOURCE_SDL); + SendSystemRequestNotification(connection_key, content, app_mngr); } void MessageHelper::SendSystemRequestNotification( diff --git a/src/components/application_manager/src/policies/policy_handler.cc b/src/components/application_manager/src/policies/policy_handler.cc index 81d80c2b00a..c3b45206135 100644 --- a/src/components/application_manager/src/policies/policy_handler.cc +++ b/src/components/application_manager/src/policies/policy_handler.cc @@ -1522,13 +1522,8 @@ void PolicyHandler::OnSnapshotCreated(const BinaryMessage& pt_string, } if (PTUIterationType::RetryIteration == iteration_type) { - auto on_system_request_notification = - MessageHelper::CreateOnSystemRequestNotificationToMobile( - pt_string, - GetAppIdForSending(), - mobile_apis::RequestType::PROPRIETARY); - application_manager_.GetRPCService().ManageMobileCommand( - on_system_request_notification, commands::Command::SOURCE_SDL); + MessageHelper::SendPolicySnapshotNotification( + GetAppIdForSending(), pt_string, std::string(""), application_manager_); } else { MessageHelper::SendPolicyUpdate( policy_snapshot_full_path, diff --git a/src/components/application_manager/test/include/application_manager/mock_message_helper.h b/src/components/application_manager/test/include/application_manager/mock_message_helper.h index 6f06a9adce8..a164265ab0f 100644 --- a/src/components/application_manager/test/include/application_manager/mock_message_helper.h +++ b/src/components/application_manager/test/include/application_manager/mock_message_helper.h @@ -141,11 +141,6 @@ class MockMessageHelper { MOCK_METHOD2(SendDecryptCertificateToHMI, void(const std::string& file_name, ApplicationManager& app_mngr)); - MOCK_METHOD3(CreateOnSystemRequestNotificationToMobile, - smart_objects::SmartObjectSPtr( - const std::vector& policy_data, - const uint32_t connection_key, - const mobile_apis::RequestType::eType request_type)); #ifdef EXTERNAL_PROPRIETARY_MODE MOCK_METHOD4( SendGetListOfPermissionsResponse, diff --git a/src/components/application_manager/test/mock_message_helper.cc b/src/components/application_manager/test/mock_message_helper.cc index c11261fe886..b2c932a981c 100755 --- a/src/components/application_manager/test/mock_message_helper.cc +++ b/src/components/application_manager/test/mock_message_helper.cc @@ -636,16 +636,6 @@ MessageHelper::ServiceStatusUpdateNotificationBuilder::notification() const { return MockMessageHelper::on_service_update_builder_mock()->notification(); } -smart_objects::SmartObjectSPtr -MessageHelper::CreateOnSystemRequestNotificationToMobile( - const std::vector& policy_data, - const uint32_t connection_key, - const mobile_apis::RequestType::eType request_type) { - return MockMessageHelper::message_helper_mock() - ->CreateOnSystemRequestNotificationToMobile( - policy_data, connection_key, request_type); -} - smart_objects::SmartObject MessageHelper::CreateAppServiceCapabilities( std::vector& all_services) { return MockMessageHelper::message_helper_mock()->CreateAppServiceCapabilities( From 2d53a14e603cce00709307797725c3cc595129d3 Mon Sep 17 00:00:00 2001 From: mked-luxoft Date: Fri, 23 Aug 2019 14:42:15 +0300 Subject: [PATCH 15/19] Remove notification builder --- .../application_manager/message_helper.h | 62 +----------- .../src/application_manager_impl.cc | 18 ++-- .../src/message_helper/message_helper.cc | 51 ++++------ .../test/application_manager_impl_test.cc | 15 +-- .../application_manager/mock_message_helper.h | 43 ++------- .../message_helper/message_helper_test.cc | 94 ------------------- .../test/mock_message_helper.cc | 46 +++------ 7 files changed, 53 insertions(+), 276 deletions(-) diff --git a/src/components/application_manager/include/application_manager/message_helper.h b/src/components/application_manager/include/application_manager/message_helper.h index ddb6fb71f23..3a0055871b5 100644 --- a/src/components/application_manager/include/application_manager/message_helper.h +++ b/src/components/application_manager/include/application_manager/message_helper.h @@ -89,63 +89,11 @@ class MessageHelper { static smart_objects::SmartObjectSPtr CreateHMINotification( hmi_apis::FunctionID::eType function_id); - /** - * @brief ServiceStatusUpdateNotificationBuilder small utility class used for - * more flexible construction of OnServiceUpdateNotification - */ - class ServiceStatusUpdateNotificationBuilder { - public: - typedef hmi_apis::Common_ServiceType::eType ServiceType; - typedef hmi_apis::Common_ServiceEvent::eType ServiceEvent; - typedef hmi_apis::Common_ServiceStatusUpdateReason::eType - ServiceStatusUpdateReason; - - /** - * @brief CreateBuilder creates builder instance - * @param service_type - enum value containing service type - * @param service_event - enum value containing service event - * @returns builder instance - */ - static ServiceStatusUpdateNotificationBuilder CreateBuilder( - const ServiceType service_type, const ServiceEvent service_event); - - /** - * @brief AddAppID adds app id to notification - * @param app_id application id to add - * @returns ref to builder instance - */ - ServiceStatusUpdateNotificationBuilder& AddAppID(const uint32_t app_id); - - /** - * @brief AddServiceUpdateReason adds service update reason to notification - * @param service_update_reason enum value containing update reason - * @returns ref to builder instance - */ - ServiceStatusUpdateNotificationBuilder& AddServiceUpdateReason( - const ServiceStatusUpdateReason service_update_reason); - - /** - * @brief notification gets notification SO - * @returns shared ptr to notification SO - */ - smart_objects::SmartObjectSPtr notification() const; - - protected: - smart_objects::SmartObjectSPtr notification_; - - /** - * @brief class constructor - * @param service_type - enum value containing service type - * @param service_event - enum value containing service event - */ - ServiceStatusUpdateNotificationBuilder(const ServiceType service_type, - const ServiceEvent service_event); - - /** - * @brief class constructor - */ - ServiceStatusUpdateNotificationBuilder(){}; - }; + static smart_objects::SmartObjectSPtr CreateOnServiceUpdateNotification( + const hmi_apis::Common_ServiceType::eType type, + const hmi_apis::Common_ServiceEvent::eType event, + const hmi_apis::Common_ServiceStatusUpdateReason::eType reason, + const uint32_t app_id); /** * @brief Creates request for different interfaces(JSON) diff --git a/src/components/application_manager/src/application_manager_impl.cc b/src/components/application_manager/src/application_manager_impl.cc index b737e452a26..94e67a0c804 100644 --- a/src/components/application_manager/src/application_manager_impl.cc +++ b/src/components/application_manager/src/application_manager_impl.cc @@ -2042,19 +2042,17 @@ void ApplicationManagerImpl::ProcessServiceStatusUpdate( << " service_update_reason " << service_update_reason); const auto app = application(connection_key); - auto notification_builder = - MessageHelper::ServiceStatusUpdateNotificationBuilder::CreateBuilder( - service_type, service_event); - if (app) { - notification_builder.AddAppID(app->app_id()); - } + const uint32_t app_id = app ? app->app_id() : 0u; - if (service_update_reason) { - notification_builder.AddServiceUpdateReason(*service_update_reason); - } + auto reason = service_update_reason + ? *service_update_reason + : hmi_apis::Common_ServiceStatusUpdateReason::INVALID_ENUM; + + auto notification = MessageHelper::CreateOnServiceUpdateNotification( + service_type, service_event, reason, app_id); - rpc_service_->ManageHMICommand(notification_builder.notification()); + rpc_service_->ManageHMICommand(notification); } void ApplicationManagerImpl::OnSecondaryTransportStartedCallback( diff --git a/src/components/application_manager/src/message_helper/message_helper.cc b/src/components/application_manager/src/message_helper/message_helper.cc index 5c9e0e80b14..31eaa54e5dc 100644 --- a/src/components/application_manager/src/message_helper/message_helper.cc +++ b/src/components/application_manager/src/message_helper/message_helper.cc @@ -2234,45 +2234,32 @@ smart_objects::SmartObjectSPtr MessageHelper::CreateNegativeResponse( return std::make_shared(response_data); } -MessageHelper::ServiceStatusUpdateNotificationBuilder:: - ServiceStatusUpdateNotificationBuilder(const ServiceType service_type, - const ServiceEvent service_event) { - notification_ = MessageHelper::CreateHMINotification( +smart_objects::SmartObjectSPtr MessageHelper::CreateOnServiceUpdateNotification( + const hmi_apis::Common_ServiceType::eType service_type, + const hmi_apis::Common_ServiceEvent::eType service_event, + const hmi_apis::Common_ServiceStatusUpdateReason::eType + service_update_reason, + const uint32_t app_id) { + LOG4CXX_AUTO_TRACE(logger_); + auto notification = MessageHelper::CreateHMINotification( hmi_apis::FunctionID::BasicCommunication_OnServiceUpdate); - (*notification_)[strings::msg_params][hmi_notification::service_type] = + (*notification)[strings::msg_params][hmi_notification::service_type] = service_type; - (*notification_)[strings::msg_params][hmi_notification::service_event] = + (*notification)[strings::msg_params][hmi_notification::service_event] = service_event; -} - -MessageHelper::ServiceStatusUpdateNotificationBuilder -MessageHelper::ServiceStatusUpdateNotificationBuilder::CreateBuilder( - const ServiceType service_type, const ServiceEvent service_event) { - MessageHelper::ServiceStatusUpdateNotificationBuilder builder{service_type, - service_event}; - return builder; -} - -MessageHelper::ServiceStatusUpdateNotificationBuilder& -MessageHelper::ServiceStatusUpdateNotificationBuilder::AddAppID( - const uint32_t app_id) { - (*notification_)[strings::msg_params][strings::app_id] = app_id; - return *this; -} + if (0 != app_id) { + (*notification)[strings::msg_params][strings::app_id] = app_id; + } -MessageHelper::ServiceStatusUpdateNotificationBuilder& -MessageHelper::ServiceStatusUpdateNotificationBuilder::AddServiceUpdateReason( - const ServiceStatusUpdateReason service_update_reason) { - (*notification_)[strings::msg_params][hmi_notification::reason] = - service_update_reason; + if (hmi_apis::Common_ServiceStatusUpdateReason::INVALID_ENUM != + service_update_reason) { + (*notification)[strings::msg_params][hmi_notification::reason] = + service_update_reason; + } - return *this; -} -smart_objects::SmartObjectSPtr -MessageHelper::ServiceStatusUpdateNotificationBuilder::notification() const { - return notification_; + return notification; } void MessageHelper::SendNaviSetVideoConfig( diff --git a/src/components/application_manager/test/application_manager_impl_test.cc b/src/components/application_manager/test/application_manager_impl_test.cc index f3297388ff2..bb87d71a48c 100644 --- a/src/components/application_manager/test/application_manager_impl_test.cc +++ b/src/components/application_manager/test/application_manager_impl_test.cc @@ -105,8 +105,6 @@ const std::string kAppName = "appName"; const WindowID kDefaultWindowId = mobile_apis::PredefinedWindows::DEFAULT_WINDOW; -typedef MockMessageHelper::MockServiceStatusUpdateNotificationBuilder* - MockServiceStatusUpdatePtr; typedef hmi_apis::Common_ServiceStatusUpdateReason::eType ServiceStatusUpdateReason; typedef hmi_apis::Common_ServiceType::eType ServiceType; @@ -154,8 +152,6 @@ class ApplicationManagerImplTest new MockAppServiceManager(mock_app_mngr_, mock_last_state_)) , mock_message_helper_( application_manager::MockMessageHelper::message_helper_mock()) - , mock_service_status_update_(application_manager::MockMessageHelper:: - on_service_update_builder_mock()) { #ifdef ENABLE_LOG @@ -276,7 +272,6 @@ class ApplicationManagerImplTest std::unique_ptr app_manager_impl_; MockAppServiceManager* mock_app_service_manager_; application_manager::MockMessageHelper* mock_message_helper_; - MockServiceStatusUpdatePtr mock_service_status_update_; std::shared_ptr mock_app_ptr_; NiceMock mock_protocol_handler_; @@ -335,14 +330,8 @@ TEST_P(ApplicationManagerImplTest, AddMockApplication(); ON_CALL(*mock_app_ptr_, app_id()).WillByDefault(Return(kConnectionKey)); - ON_CALL(*mock_service_status_update_, - CreateBuilder(GetParam().service_type_, GetParam().service_event_)) - .WillByDefault(Return(*mock_service_status_update_)); - ON_CALL(*mock_service_status_update_, AddAppID(kConnectionKey)) - .WillByDefault(ReturnRef(*mock_service_status_update_)); - ON_CALL(*mock_service_status_update_, AddServiceUpdateReason(_)) - .WillByDefault(ReturnRef(*mock_service_status_update_)); - ON_CALL(*mock_service_status_update_, notification()) + + ON_CALL(*mock_message_helper_, CreateOnServiceUpdateNotification(_, _, _, _)) .WillByDefault(Return(notification_)); EXPECT_CALL(*mock_rpc_service_, ManageHMICommand(notification_, _)) diff --git a/src/components/application_manager/test/include/application_manager/mock_message_helper.h b/src/components/application_manager/test/include/application_manager/mock_message_helper.h index a164265ab0f..072199082e6 100644 --- a/src/components/application_manager/test/include/application_manager/mock_message_helper.h +++ b/src/components/application_manager/test/include/application_manager/mock_message_helper.h @@ -341,42 +341,15 @@ class MockMessageHelper { CreateDisplayCapabilityUpdateToMobile, smart_objects::SmartObjectSPtr(const smart_objects::SmartObject&, application_manager::Application&)); - MOCK_METHOD3(CreateOnServiceUpdateNotification, smart_objects::SmartObject( - const uint32_t app_id, - const hmi_apis::Common_ServiceType::eType service_type, - const hmi_apis::Common_ServiceEvent::eType service_event)); - MOCK_METHOD4(CreateOnServiceUpdateNotification, smart_objects::SmartObject( - const uint32_t app_id, - const hmi_apis::Common_ServiceType::eType service_type, - const hmi_apis::Common_ServiceEvent::eType service_event, - const hmi_apis::Common_ServiceStatusUpdateReason::eType - service_update_reason)); - -class MockServiceStatusUpdateNotificationBuilder - : public MessageHelper::ServiceStatusUpdateNotificationBuilder { - public: - MockServiceStatusUpdateNotificationBuilder( - const MockServiceStatusUpdateNotificationBuilder& obj){}; - MockServiceStatusUpdateNotificationBuilder(){}; - MOCK_METHOD2(CreateBuilder, - MessageHelper::ServiceStatusUpdateNotificationBuilder( - hmi_apis::Common_ServiceType::eType, - hmi_apis::Common_ServiceEvent::eType)); - - MOCK_METHOD1(AddAppID, - MessageHelper::ServiceStatusUpdateNotificationBuilder & - (const uint32_t app_id)); - - MOCK_METHOD1(AddServiceUpdateReason, - MessageHelper::ServiceStatusUpdateNotificationBuilder & - (const hmi_apis::Common_ServiceStatusUpdateReason::eType)); - - MOCK_CONST_METHOD0(notification, smart_objects::SmartObjectSPtr()); -}; + MOCK_METHOD4(CreateOnServiceUpdateNotification, + smart_objects::SmartObjectSPtr( + const hmi_apis::Common_ServiceType::eType service_type, + const hmi_apis::Common_ServiceEvent::eType service_event, + const hmi_apis::Common_ServiceStatusUpdateReason::eType + service_update_reason, + const uint32_t app_id)); -static MockMessageHelper* message_helper_mock(); -static MockServiceStatusUpdateNotificationBuilder* -on_service_update_builder_mock(); + static MockMessageHelper* message_helper_mock(); }; } // namespace application_manager diff --git a/src/components/application_manager/test/message_helper/message_helper_test.cc b/src/components/application_manager/test/message_helper/message_helper_test.cc index 8d75cacdf38..a174d74d5db 100644 --- a/src/components/application_manager/test/message_helper/message_helper_test.cc +++ b/src/components/application_manager/test/message_helper/message_helper_test.cc @@ -69,14 +69,6 @@ using namespace application_manager; typedef std::shared_ptr MockApplicationSharedPtr; typedef std::vector StringArray; typedef std::shared_ptr ApplicationSharedPtr; -typedef MessageHelper::ServiceStatusUpdateNotificationBuilder::ServiceType - ServiceType; -typedef MessageHelper::ServiceStatusUpdateNotificationBuilder::ServiceEvent - ServiceEvent; -typedef MessageHelper::ServiceStatusUpdateNotificationBuilder:: - ServiceStatusUpdateReason UpdateReason; -typedef MessageHelper::ServiceStatusUpdateNotificationBuilder - ServiceStatusUpdateBuilder; using testing::_; using testing::AtLeast; @@ -1113,92 +1105,6 @@ TEST_F(MessageHelperTest, ExtractWindowIdFromSmartObject_FromWrongType) { MessageHelper::ExtractWindowIdFromSmartObject(message)); } -TEST(ServiceStatusUpdateNotificationBuilderTest, CreateBuilderIsCorrect) { - auto service_status_update_builder_ = - ServiceStatusUpdateBuilder::CreateBuilder(ServiceType::AUDIO, - ServiceEvent::REQUEST_ACCEPTED); - auto notification_ = service_status_update_builder_.notification(); - - auto message_type_exist_ = - (*notification_)[strings::params].keyExists(strings::message_type); - auto message_type_ = - (*notification_)[strings::params][strings::message_type].asInt(); - auto function_id_exist_ = - (*notification_)[strings::params].keyExists(strings::function_id); - auto function_id_ = - (*notification_)[strings::params][strings::function_id].asInt(); - auto protocol_version_exist_ = - (*notification_)[strings::params].keyExists(strings::protocol_version); - auto protocol_version_ = - (*notification_)[strings::params][strings::protocol_version].asInt(); - auto protocol_type_exist_ = - (*notification_)[strings::params].keyExists(strings::protocol_type); - auto protocol_type_ = - (*notification_)[strings::params][strings::protocol_type].asInt(); - auto service_type_exist_ = (*notification_)[strings::msg_params].keyExists( - hmi_notification::service_type); - auto service_type_ = - (*notification_)[strings::msg_params][hmi_notification::service_type] - .asInt(); - auto service_event_exist_ = (*notification_)[strings::msg_params].keyExists( - hmi_notification::service_event); - auto service_event_ = - (*notification_)[strings::msg_params][hmi_notification::service_event] - .asInt(); - - EXPECT_TRUE(message_type_exist_); - EXPECT_EQ(static_cast(kNotification), message_type_); - EXPECT_TRUE(function_id_exist_); - EXPECT_EQ(static_cast( - hmi_apis::FunctionID::BasicCommunication_OnServiceUpdate), - function_id_); - EXPECT_TRUE(protocol_version_exist_); - EXPECT_EQ(static_cast(commands::CommandImpl::protocol_version_), - protocol_version_); - EXPECT_TRUE(protocol_type_exist_); - EXPECT_EQ(static_cast(commands::CommandImpl::hmi_protocol_type_), - protocol_type_); - EXPECT_TRUE(service_type_exist_); - EXPECT_EQ(static_cast(ServiceType::AUDIO), service_type_); - EXPECT_TRUE(service_event_exist_); - EXPECT_EQ(static_cast(ServiceEvent::REQUEST_ACCEPTED), - service_event_); -} - -TEST(ServiceStatusUpdateNotificationBuilderTest, AddAppID) { - auto service_status_update_builder_ = - ServiceStatusUpdateBuilder::CreateBuilder(ServiceType::RPC, - ServiceEvent::REQUEST_RECEIVED); - const uint32_t kAppId = 1234u; - - service_status_update_builder_.AddAppID(kAppId); - auto notification_ = service_status_update_builder_.notification(); - - auto app_id_exist_ = - (*notification_)[strings::msg_params].keyExists(strings::app_id); - auto app_id_ = (*notification_)[strings::msg_params][strings::app_id].asInt(); - - EXPECT_TRUE(app_id_exist_); - EXPECT_EQ(kAppId, app_id_); -} - -TEST(ServiceStatusUpdateNotificationBuilderTest, AddServiceUpdateReason) { - auto service_status_update_builder_ = - ServiceStatusUpdateBuilder::CreateBuilder(ServiceType::VIDEO, - ServiceEvent::REQUEST_REJECTED); - - service_status_update_builder_.AddServiceUpdateReason( - UpdateReason::INVALID_CERT); - auto notification_ = service_status_update_builder_.notification(); - auto reason_exist_ = - (*notification_)[strings::msg_params].keyExists(hmi_notification::reason); - auto reason_ = - (*notification_)[strings::msg_params][hmi_notification::reason].asInt(); - - EXPECT_TRUE(reason_exist_); - EXPECT_EQ(static_cast(UpdateReason::INVALID_CERT), reason_); -} - } // namespace application_manager_test } // namespace components } // namespace test diff --git a/src/components/application_manager/test/mock_message_helper.cc b/src/components/application_manager/test/mock_message_helper.cc index b2c932a981c..628fd97ae85 100755 --- a/src/components/application_manager/test/mock_message_helper.cc +++ b/src/components/application_manager/test/mock_message_helper.cc @@ -601,41 +601,6 @@ void MessageHelper::SendUnsubscribeButtonNotification( ->SendUnsubscribeButtonNotification(button, application, app_mngr); } -MockMessageHelper::MockServiceStatusUpdateNotificationBuilder* -MockMessageHelper::on_service_update_builder_mock() { - static ::testing::NiceMock< - MockMessageHelper::MockServiceStatusUpdateNotificationBuilder> - on_service_update_builder_mock; - return &on_service_update_builder_mock; -} - -MessageHelper::ServiceStatusUpdateNotificationBuilder -MessageHelper::ServiceStatusUpdateNotificationBuilder::CreateBuilder( - hmi_apis::Common_ServiceType::eType service_type, - hmi_apis::Common_ServiceEvent::eType service_event) { - return MockMessageHelper::on_service_update_builder_mock()->CreateBuilder( - service_type, service_event); -} - -MessageHelper::ServiceStatusUpdateNotificationBuilder& -MessageHelper::ServiceStatusUpdateNotificationBuilder::AddAppID( - const uint32_t app_id) { - return MockMessageHelper::on_service_update_builder_mock()->AddAppID(app_id); -} - -MessageHelper::ServiceStatusUpdateNotificationBuilder& -MessageHelper::ServiceStatusUpdateNotificationBuilder::AddServiceUpdateReason( - const hmi_apis::Common_ServiceStatusUpdateReason::eType - service_update_reason) { - return MockMessageHelper::on_service_update_builder_mock() - ->AddServiceUpdateReason(service_update_reason); -} - -smart_objects::SmartObjectSPtr -MessageHelper::ServiceStatusUpdateNotificationBuilder::notification() const { - return MockMessageHelper::on_service_update_builder_mock()->notification(); -} - smart_objects::SmartObject MessageHelper::CreateAppServiceCapabilities( std::vector& all_services) { return MockMessageHelper::message_helper_mock()->CreateAppServiceCapabilities( @@ -662,4 +627,15 @@ MessageHelper::CreateDisplayCapabilityUpdateToMobile( return MockMessageHelper::message_helper_mock() ->CreateDisplayCapabilityUpdateToMobile(system_capabilities, app); } + +smart_objects::SmartObjectSPtr MessageHelper::CreateOnServiceUpdateNotification( + const hmi_apis::Common_ServiceType::eType service_type, + const hmi_apis::Common_ServiceEvent::eType service_event, + const hmi_apis::Common_ServiceStatusUpdateReason::eType + service_update_reason, + const uint32_t app_id) { + return MockMessageHelper::message_helper_mock() + ->CreateOnServiceUpdateNotification( + service_type, service_event, service_update_reason, app_id); +} } // namespace application_manager From dddcb6bd3f2299fac1effdf272cc8fe87ba54de2 Mon Sep 17 00:00:00 2001 From: Dmitriy Boltovskiy Date: Fri, 23 Aug 2019 11:55:58 -0400 Subject: [PATCH 16/19] fixup! Style --- .../commands/hmi/on_service_status_update_notification_test.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/test/commands/hmi/on_service_status_update_notification_test.cc b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/test/commands/hmi/on_service_status_update_notification_test.cc index e35c06b192c..a9bc97f8425 100644 --- a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/test/commands/hmi/on_service_status_update_notification_test.cc +++ b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/test/commands/hmi/on_service_status_update_notification_test.cc @@ -89,7 +89,7 @@ TEST_F(OnServiceUpdateNotificationTest, SendNotificationToHMI) { command_->Run(); } -} // namespace on_service_status_update_notification +} // namespace on_service_update_notification } // namespace hmi_commands_test } // namespace commands_test } // namespace components From 81f3743811556c689860749f248b08483e934a1c Mon Sep 17 00:00:00 2001 From: mked-luxoft Date: Tue, 27 Aug 2019 12:22:18 +0300 Subject: [PATCH 17/19] fixup! Remove notification builder --- .../include/application_manager/message_helper.h | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/components/application_manager/include/application_manager/message_helper.h b/src/components/application_manager/include/application_manager/message_helper.h index 3a0055871b5..aff46593237 100644 --- a/src/components/application_manager/include/application_manager/message_helper.h +++ b/src/components/application_manager/include/application_manager/message_helper.h @@ -92,8 +92,9 @@ class MessageHelper { static smart_objects::SmartObjectSPtr CreateOnServiceUpdateNotification( const hmi_apis::Common_ServiceType::eType type, const hmi_apis::Common_ServiceEvent::eType event, - const hmi_apis::Common_ServiceStatusUpdateReason::eType reason, - const uint32_t app_id); + const hmi_apis::Common_ServiceStatusUpdateReason::eType reason = + hmi_apis::Common_ServiceStatusUpdateReason::INVALID_ENUM, + const uint32_t app_id = 0); /** * @brief Creates request for different interfaces(JSON) From e0f98265a13599b4c8c88df4e6aba58b9ba35a20 Mon Sep 17 00:00:00 2001 From: mked-luxoft Date: Wed, 28 Aug 2019 12:49:57 +0300 Subject: [PATCH 18/19] Fix force unprotected service --- .../protocol_handler/protocol_handler_impl.h | 6 ++ .../service_status_update_handler.h | 3 +- .../src/protocol_handler_impl.cc | 88 ++++++++++++------- .../src/service_status_update_handler.cc | 9 ++ 4 files changed, 75 insertions(+), 31 deletions(-) diff --git a/src/components/protocol_handler/include/protocol_handler/protocol_handler_impl.h b/src/components/protocol_handler/include/protocol_handler/protocol_handler_impl.h index e3b75f805ad..8dbfc4ed4d2 100644 --- a/src/components/protocol_handler/include/protocol_handler/protocol_handler_impl.h +++ b/src/components/protocol_handler/include/protocol_handler/protocol_handler_impl.h @@ -717,6 +717,12 @@ class ProtocolHandlerImpl const std::string TransportTypeFromTransport( const utils::custom_string::CustomString& transport) const; + const ServiceStatus ServiceDisallowedBySettings( + const ServiceType service_type, + const ConnectionID connection_id, + const uint8_t session_id, + const bool protection) const; + const ProtocolHandlerSettings& settings_; /** diff --git a/src/components/protocol_handler/include/protocol_handler/service_status_update_handler.h b/src/components/protocol_handler/include/protocol_handler/service_status_update_handler.h index 3f9e7df1b2f..c94ddb91e4b 100644 --- a/src/components/protocol_handler/include/protocol_handler/service_status_update_handler.h +++ b/src/components/protocol_handler/include/protocol_handler/service_status_update_handler.h @@ -51,7 +51,8 @@ enum class ServiceStatus { CERT_INVALID, INVALID_TIME, PROTECTION_ENFORCED, - PROTECTION_DISABLED + PROTECTION_DISABLED, + UNSECURE_START_FAILED }; /** diff --git a/src/components/protocol_handler/src/protocol_handler_impl.cc b/src/components/protocol_handler/src/protocol_handler_impl.cc index ec4b96e385c..643e6a9fffd 100644 --- a/src/components/protocol_handler/src/protocol_handler_impl.cc +++ b/src/components/protocol_handler/src/protocol_handler_impl.cc @@ -1596,6 +1596,56 @@ RESULT_CODE ProtocolHandlerImpl::HandleControlMessageEndSession( return RESULT_OK; } +const ServiceStatus ProtocolHandlerImpl::ServiceDisallowedBySettings( + const ServiceType service_type, + const ConnectionID connection_id, + const uint8_t session_id, + const bool protection) const { + const std::string& transport = + session_observer_.TransportTypeProfileStringFromConnHandle(connection_id); + + const auto video_transports = settings_.video_service_transports(); + const bool is_video_allowed = + video_transports.empty() || + std::find(video_transports.begin(), video_transports.end(), transport) != + video_transports.end(); + + const auto audio_transports = settings_.audio_service_transports(); + const bool is_audio_allowed = + audio_transports.empty() || + std::find(audio_transports.begin(), audio_transports.end(), transport) != + audio_transports.end(); + + const auto& force_protected = get_settings().force_protected_service(); + + const auto& force_unprotected = get_settings().force_unprotected_service(); + + const bool is_force_protected = + (helpers::in_range(force_protected, service_type)); + + const bool is_force_unprotected = + (helpers::in_range(force_unprotected, service_type)); + + const bool can_start_protected = is_force_protected && protection; + + const bool can_start_unprotected = is_force_unprotected && !protection; + + if ((ServiceType::kMobileNav == service_type && !is_video_allowed) || + (ServiceType::kAudio == service_type && !is_audio_allowed)) { + return ServiceStatus::SERVICE_START_FAILED; + } + + if (is_force_protected && !can_start_protected) { + return ServiceStatus::PROTECTION_ENFORCED; + } + + if (is_force_unprotected && !can_start_unprotected) { + return ServiceStatus::UNSECURE_START_FAILED; + } + + return ServiceStatus::INVALID_ENUM; +} + RESULT_CODE ProtocolHandlerImpl::HandleControlMessageEndServiceACK( const ProtocolPacket& packet) { LOG4CXX_AUTO_TRACE(logger_); @@ -1636,43 +1686,21 @@ RESULT_CODE ProtocolHandlerImpl::HandleControlMessageStartSession( const ConnectionID connection_id = packet->connection_id(); const uint8_t session_id = packet->session_id(); - const std::string& transport = - session_observer_.TransportTypeProfileStringFromConnHandle(connection_id); - - const auto video_transports = settings_.video_service_transports(); - const bool is_video_allowed = - video_transports.empty() || - std::find(video_transports.begin(), video_transports.end(), transport) != - video_transports.end(); - - const auto audio_transports = settings_.audio_service_transports(); - const bool is_audio_allowed = - audio_transports.empty() || - std::find(audio_transports.begin(), audio_transports.end(), transport) != - audio_transports.end(); - - const uint32_t connection_key = session_observer_.KeyFromPair( - packet->connection_id(), packet->session_id()); - - const auto& force_protected = get_settings().force_protected_service(); - - const bool is_force_protected = - (helpers::in_range(force_protected, service_type)); - - const bool can_start_unprotected = is_force_protected && protection; + const uint32_t connection_key = + session_observer_.KeyFromPair(connection_id, session_id); service_status_update_handler_->OnServiceUpdate( connection_key, service_type, ServiceStatus::SERVICE_RECEIVED); - if ((ServiceType::kMobileNav == service_type && !is_video_allowed) || - (ServiceType::kAudio == service_type && !is_audio_allowed) || - (is_force_protected && !can_start_unprotected)) { + const auto settings_check = ServiceDisallowedBySettings( + service_type, connection_id, session_id, protection); + + if (ServiceStatus::INVALID_ENUM != settings_check) { LOG4CXX_DEBUG(logger_, "Rejecting StartService for service:" - << service_type << ", over transport: " << transport - << ", disallowed by settings."); + << service_type << ", disallowed by settings."); service_status_update_handler_->OnServiceUpdate( - connection_key, service_type, ServiceStatus::PROTECTION_ENFORCED); + connection_key, service_type, settings_check); SendStartSessionNAck( connection_id, session_id, protocol_version, service_type); return RESULT_OK; diff --git a/src/components/protocol_handler/src/service_status_update_handler.cc b/src/components/protocol_handler/src/service_status_update_handler.cc index 9bef1b973fb..7b2c67ea23a 100644 --- a/src/components/protocol_handler/src/service_status_update_handler.cc +++ b/src/components/protocol_handler/src/service_status_update_handler.cc @@ -97,6 +97,15 @@ void ServiceStatusUpdateHandler::OnServiceUpdate( Common_ServiceEvent::REQUEST_ACCEPTED, update_reason); } + case ServiceStatus::UNSECURE_START_FAILED: { + auto update_reason = + Common_ServiceStatusUpdateReason::PROTECTION_DISABLED; + return listener_->ProcessServiceStatusUpdate( + connection_key, + hmi_service_type, + Common_ServiceEvent::REQUEST_REJECTED, + update_reason); + } default: { LOG4CXX_WARN(logger_, "Received unknown ServiceStatus: " From 8d85b72adb1b25da1d760c897198d43b52ed9975 Mon Sep 17 00:00:00 2001 From: mked-luxoft Date: Thu, 29 Aug 2019 18:58:19 +0300 Subject: [PATCH 19/19] fixup! Fixes after rebase --- .../include/policy/policy_external/policy/policy_manager.h | 2 +- .../include/test/protocol_handler/mock_protocol_handler.h | 1 + src/components/protocol_handler/src/protocol_handler_impl.cc | 1 + 3 files changed, 3 insertions(+), 1 deletion(-) diff --git a/src/components/include/policy/policy_external/policy/policy_manager.h b/src/components/include/policy/policy_external/policy/policy_manager.h index da1a99fcdee..bf0e03b0b89 100644 --- a/src/components/include/policy/policy_external/policy/policy_manager.h +++ b/src/components/include/policy/policy_external/policy/policy_manager.h @@ -53,7 +53,7 @@ typedef std::shared_ptr StatusNotifier; class PolicyManager : public usage_statistics::StatisticsManager, public PolicyEncryptionFlagGetterInterface, - public PTURetryHandler { + public PTURetryHandler { public: /** * @brief The NotificationMode enum defines whether application will be diff --git a/src/components/include/test/protocol_handler/mock_protocol_handler.h b/src/components/include/test/protocol_handler/mock_protocol_handler.h index df75c71c490..354c797c247 100644 --- a/src/components/include/test/protocol_handler/mock_protocol_handler.h +++ b/src/components/include/test/protocol_handler/mock_protocol_handler.h @@ -69,6 +69,7 @@ class MockProtocolHandler : public ::protocol_handler::ProtocolHandler { std::vector& rejected_params)); MOCK_METHOD0(NotifyOnGetSystemTimeFailed, void()); MOCK_CONST_METHOD1(IsRPCServiceSecure, bool(const uint32_t connection_key)); + MOCK_METHOD0(ProcessFailedPTU, void()); #ifdef EXTERNAL_PROPRIETARY_MODE MOCK_METHOD0(ProcessFailedCertDecrypt, void()); #endif diff --git a/src/components/protocol_handler/src/protocol_handler_impl.cc b/src/components/protocol_handler/src/protocol_handler_impl.cc index 643e6a9fffd..268af48fdcf 100644 --- a/src/components/protocol_handler/src/protocol_handler_impl.cc +++ b/src/components/protocol_handler/src/protocol_handler_impl.cc @@ -1601,6 +1601,7 @@ const ServiceStatus ProtocolHandlerImpl::ServiceDisallowedBySettings( const ConnectionID connection_id, const uint8_t session_id, const bool protection) const { + LOG4CXX_AUTO_TRACE(logger_); const std::string& transport = session_observer_.TransportTypeProfileStringFromConnHandle(connection_id);