diff options
Diffstat (limited to 'src/components/policy/policy_regular/src/policy_manager_impl.cc')
-rw-r--r-- | src/components/policy/policy_regular/src/policy_manager_impl.cc | 734 |
1 files changed, 548 insertions, 186 deletions
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 00a3d33379..0cdca26f2e 100644 --- a/src/components/policy/policy_regular/src/policy_manager_impl.cc +++ b/src/components/policy/policy_regular/src/policy_manager_impl.cc @@ -36,13 +36,13 @@ #include <limits> #include <queue> #include <set> -#include "json/reader.h" #include "json/writer.h" #include "policy/policy_helper.h" #include "policy/policy_table.h" #include "policy/pt_representation.h" #include "utils/date_time.h" #include "utils/file_system.h" +#include "utils/jsoncpp_reader_wrapper.h" #include "utils/logger.h" #include "config_profile/profile.h" @@ -53,13 +53,6 @@ #include "policy/access_remote.h" #include "policy/access_remote_impl.h" -policy::PolicyManager* CreateManager() { - return new policy::PolicyManagerImpl(); -} -void DeleteManager(policy::PolicyManager* pm) { - delete pm; -} - namespace { const uint32_t kDefaultRetryTimeoutInMSec = 60u * date_time::MILLISECONDS_IN_SECOND; @@ -77,14 +70,17 @@ PolicyManagerImpl::PolicyManagerImpl() new AccessRemoteImpl(std::static_pointer_cast<CacheManager>(cache_))) , retry_sequence_timeout_(kDefaultRetryTimeoutInMSec) , retry_sequence_index_(0) - , timer_retry_sequence_("Retry sequence timer", - new timer::TimerTaskImpl<PolicyManagerImpl>( - this, &PolicyManagerImpl::RetrySequence)) + , applications_pending_ptu_count_(0) + , timer_retry_sequence_( + "Retry sequence timer", + new timer::TimerTaskImpl<PolicyManagerImpl>( + this, &PolicyManagerImpl::OnPTUIterationTimeout)) , ignition_check(true) , retry_sequence_url_(0, 0, "") - , wrong_ptu_update_received_(false) , send_on_update_sent_out_(false) - , trigger_ptu_(false) {} + , trigger_ptu_(false) + , ptu_requested_(false) + , last_registered_policy_app_id_(std::string()) {} void PolicyManagerImpl::set_listener(PolicyListener* listener) { listener_ = listener; @@ -96,9 +92,10 @@ void PolicyManagerImpl::set_listener(PolicyListener* listener) { std::shared_ptr<policy_table::Table> PolicyManagerImpl::Parse( const BinaryMessage& pt_content) { std::string json(pt_content.begin(), pt_content.end()); + utils::JsonReader reader; Json::Value value; - Json::Reader reader; - if (reader.parse(json.c_str(), value)) { + + if (reader.parse(json, &value)) { return std::make_shared<policy_table::Table>(&value); } else { return std::make_shared<policy_table::Table>(); @@ -110,9 +107,10 @@ std::shared_ptr<policy_table::Table> PolicyManagerImpl::Parse( std::shared_ptr<policy_table::Table> PolicyManagerImpl::ParseArray( const BinaryMessage& pt_content) { std::string json(pt_content.begin(), pt_content.end()); + utils::JsonReader reader; Json::Value value; - Json::Reader reader; - if (reader.parse(json.c_str(), value)) { + + if (reader.parse(json, &value)) { // For PT Update received from SDL Server. if (value["data"].size() != 0) { Json::Value data = value["data"]; @@ -164,7 +162,9 @@ void FilterInvalidFunctions(policy_table::Rpc& rpcs) { * schema * @param rpc_parameters parameters to filter */ -void FilterInvalidRPCParameters(policy_table::RpcParameters& rpc_parameters) { +void FilterInvalidRPCParameters( + policy_table::RpcParameters& rpc_parameters, + const std::vector<policy_table::VehicleDataItem>& vehicle_data_items) { policy_table::HmiLevels valid_hmi_levels; for (const auto& hmi_level : rpc_parameters.hmi_levels) { if (hmi_level.is_valid()) { @@ -173,10 +173,31 @@ void FilterInvalidRPCParameters(policy_table::RpcParameters& rpc_parameters) { } rpc_parameters.hmi_levels.swap(valid_hmi_levels); + auto ParamExists = + [&vehicle_data_items](const rpc::String<0, 255>& param_name) { + policy_table::Parameter parameter_enum; + if (policy_table::EnumFromJsonString(param_name, ¶meter_enum)) { + return true; + } + + // In case when this collection is empty that means collection is not + // initialized + if (vehicle_data_items.empty()) { + return false; + } + + for (const auto& vdi : vehicle_data_items) { + if (param_name == vdi.name) { + return true; + } + } + return false; + }; + policy_table::Parameters valid_params; const policy_table::Parameters& params = *(rpc_parameters.parameters); for (const auto& param : params) { - if (param.is_valid()) { + if (param.is_valid() && ParamExists(param)) { valid_params.push_back(param); } } @@ -261,7 +282,9 @@ void FilterInvalidApplicationParameters( * @brief FilterPolicyTable filter values that not present in schema * @param pt policy table to filter */ -void FilterPolicyTable(policy_table::PolicyTable& pt) { +void FilterPolicyTable( + policy_table::PolicyTable& pt, + const std::vector<policy_table::VehicleDataItem>& current_vd_items) { policy_table::ModuleConfig& module_config = pt.module_config; if (module_config.is_initialized() && module_config.notifications_per_minute_by_priority.is_initialized()) { @@ -280,14 +303,24 @@ void FilterPolicyTable(policy_table::PolicyTable& pt) { policy_table::Rpc& rpcs = group.second.rpcs; FilterInvalidFunctions(rpcs); + policy_table::VehicleDataItems vehicle_data_items; + + if (!pt.vehicle_data->struct_empty()) { + vehicle_data_items = + pt.vehicle_data.is_initialized() && + pt.vehicle_data->schema_items.is_initialized() + ? *pt.vehicle_data->schema_items + : current_vd_items; + } + for (auto& func : rpcs) { - FilterInvalidRPCParameters(func.second); + FilterInvalidRPCParameters(func.second, vehicle_data_items); } } } -bool PolicyManagerImpl::LoadPT(const std::string& file, - const BinaryMessage& pt_content) { +PolicyManager::PtProcessingResult PolicyManagerImpl::LoadPT( + const std::string& file, const BinaryMessage& pt_content) { LOG4CXX_INFO(logger_, "LoadPT of size " << pt_content.size()); LOG4CXX_DEBUG( logger_, @@ -304,91 +337,227 @@ bool PolicyManagerImpl::LoadPT(const std::string& file, std::shared_ptr<policy_table::Table> pt_update = ParseArray(pt_content); #endif if (!pt_update) { - LOG4CXX_WARN(logger_, "Parsed table pointer is 0."); - update_status_manager_.OnWrongUpdateReceived(); - return false; + LOG4CXX_WARN(logger_, "Parsed table pointer is NULL."); + ; + return PtProcessingResult::kWrongPtReceived; } file_system::DeleteFile(file); - FilterPolicyTable(pt_update->policy_table); + auto current_vd_items = GetVehicleDataItems(); + + FilterPolicyTable(pt_update->policy_table, current_vd_items); if (!IsPTValid(pt_update, policy_table::PT_UPDATE)) { - wrong_ptu_update_received_ = true; - update_status_manager_.OnWrongUpdateReceived(); - return false; + LOG4CXX_WARN(logger_, "Received policy table update is not valid"); + return PtProcessingResult::kWrongPtReceived; } - update_status_manager_.OnValidUpdateReceived(); - cache_->SaveUpdateRequired(false); - // Update finished, no need retry if (timer_retry_sequence_.is_running()) { LOG4CXX_INFO(logger_, "Stop retry sequence"); timer_retry_sequence_.Stop(); } - { - sync_primitives::AutoLock lock(apps_registration_lock_); + cache_->SaveUpdateRequired(false); - // Get current DB data, since it could be updated during awaiting of PTU - std::shared_ptr<policy_table::Table> policy_table_snapshot = - cache_->GenerateSnapshot(); - if (!policy_table_snapshot) { - LOG4CXX_ERROR( - logger_, - "Failed to create snapshot of policy table, trying another exchange"); - ForcePTExchange(); - return false; - } + sync_primitives::AutoLock lock(apps_registration_lock_); + + // Get current DB data, since it could be updated during awaiting of PTU + auto policy_table_snapshot = cache_->GenerateSnapshot(); + if (!policy_table_snapshot) { + LOG4CXX_ERROR( + logger_, + "Failed to create snapshot of policy table, trying another exchange"); + return PtProcessingResult::kNewPtRequired; + } - // Checking of difference between PTU and current policy state - // Must to be done before PTU applying since it is possible, that functional - // groups, which had been present before are absent in PTU and will be - // removed after update. So in case of revoked groups system has to know - // names and ids of revoked groups before they will be removed. - CheckPermissionsChanges(pt_update, policy_table_snapshot); + // Checking of difference between PTU and current policy state + // Must to be done before PTU applying since it is possible, that functional + // groups, which had been present before are absent in PTU and will be + // removed after update. So in case of revoked groups system has to know + // names and ids of revoked groups before they will be removed. + const auto results = + CheckPermissionsChanges(pt_update, policy_table_snapshot); - // Replace current data with updated - if (!cache_->ApplyUpdate(*pt_update)) { - LOG4CXX_WARN( - logger_, - "Unsuccessful save of updated policy table, trying another exchange"); - ForcePTExchange(); - return false; - } - CheckPermissionsChangesAfterUpdate(*pt_update, *policy_table_snapshot); + // Replace current data with updated + if (!cache_->ApplyUpdate(*pt_update)) { + LOG4CXX_WARN( + logger_, + "Unsuccessful save of updated policy table, trying another exchange"); + return PtProcessingResult::kNewPtRequired; + } + CheckPermissionsChangesAfterUpdate(*pt_update, *policy_table_snapshot); - listener_->OnCertificateUpdated( - *(pt_update->policy_table.module_config.certificate)); + ProcessAppPolicyCheckResults( + results, pt_update->policy_table.app_policies_section.apps); - std::map<std::string, StringArray> app_hmi_types; - cache_->GetHMIAppTypeAfterUpdate(app_hmi_types); - if (!app_hmi_types.empty()) { - LOG4CXX_INFO(logger_, "app_hmi_types is full calling OnUpdateHMIAppType"); - listener_->OnUpdateHMIAppType(app_hmi_types); - } else { - LOG4CXX_INFO(logger_, "app_hmi_types empty" << pt_content.size()); - } + listener_->OnCertificateUpdated( + *(pt_update->policy_table.module_config.certificate)); - std::vector<std::string> enabled_apps; - cache_->GetEnabledCloudApps(enabled_apps); - for (auto it = enabled_apps.begin(); it != enabled_apps.end(); ++it) { - SendAuthTokenUpdated(*it); - } + std::map<std::string, StringArray> app_hmi_types; + cache_->GetHMIAppTypeAfterUpdate(app_hmi_types); + if (!app_hmi_types.empty()) { + LOG4CXX_INFO(logger_, "app_hmi_types is full calling OnUpdateHMIAppType"); + listener_->OnUpdateHMIAppType(app_hmi_types); + } else { + LOG4CXX_INFO(logger_, "app_hmi_types empty" << pt_content.size()); + } + + std::vector<std::string> enabled_apps; + cache_->GetEnabledCloudApps(enabled_apps); + for (auto it = enabled_apps.begin(); it != enabled_apps.end(); ++it) { + SendAuthTokenUpdated(*it); + } + + return PtProcessingResult::kSuccess; +} + +void PolicyManagerImpl::OnPTUFinished(const PtProcessingResult ptu_result) { + LOG4CXX_AUTO_TRACE(logger_); + ptu_requested_ = false; + if (PtProcessingResult::kWrongPtReceived == ptu_result) { + LOG4CXX_DEBUG(logger_, "Wrong PT was received"); + update_status_manager_.OnWrongUpdateReceived(); + return; } + update_status_manager_.OnValidUpdateReceived(); + + if (PtProcessingResult::kNewPtRequired == ptu_result) { + LOG4CXX_DEBUG(logger_, "New PTU interation is required"); + ForcePTExchange(); + return; + } + + ResumePendingAppPolicyActions(); + // If there was a user request for policy table update, it should be started // right after current update is finished - if (update_status_manager_.IsUpdateRequired()) { + if (update_status_manager_.IsUpdateRequired() && HasApplicationForPTU()) { + LOG4CXX_DEBUG(logger_, + "PTU was successful and new PTU iteration was scheduled"); StartPTExchange(); - return true; + return; } RefreshRetrySequence(); - return true; } -void PolicyManagerImpl::CheckPermissionsChanges( +void PolicyManagerImpl::ProcessAppPolicyCheckResults( + const CheckAppPolicyResults& results, + const rpc::policy_table_interface_base::ApplicationPolicies& app_policies) { + LOG4CXX_AUTO_TRACE(logger_); + + ApplicationsPoliciesActions actions_for_apps_policies; + FillActionsForAppPolicies filler(actions_for_apps_policies, app_policies); + + std::for_each(results.begin(), results.end(), filler); + + ProcessActionsForAppPolicies(actions_for_apps_policies, app_policies); +} + +void PolicyManagerImpl::ProcessActionsForAppPolicies( + const ApplicationsPoliciesActions& actions, + const policy_table::ApplicationPolicies& app_policies) { + notify_system_list_.clear(); + send_permissions_list_.clear(); + + ApplicationsPoliciesActions::const_iterator it_actions = actions.begin(); + for (; it_actions != actions.end(); ++it_actions) { + auto app_policy = app_policies.find(it_actions->first); + if (app_policies.end() == app_policy) { + continue; + } + + if (it_actions->second.app_properties_changed) { + app_properties_changed_list_.push_back(app_policy->first); + } + + const auto devices_ids = listener()->GetDevicesIds(app_policy->first); + for (const auto& device_id : devices_ids) { + if (it_actions->second.is_consent_needed) { + // Post-check after ExternalConsent consent changes + const std::string& policy_app_id = app_policy->first; + if (!IsConsentNeeded(device_id, policy_app_id)) { + sync_primitives::AutoLock lock(app_permissions_diff_lock_); + + PendingPermissions::iterator app_id_diff = + app_permissions_diff_.find(policy_app_id); + + if (app_permissions_diff_.end() != app_id_diff) { + app_id_diff->second.appPermissionsConsentNeeded = false; + } + } + } + if (it_actions->second.is_notify_system) { + notify_system_list_.push_back(std::make_pair(device_id, *app_policy)); + } + if (it_actions->second.is_send_permissions_to_app) { + send_permissions_list_.push_back( + std::make_pair(device_id, *app_policy)); + } + } + } +} + +void PolicyManagerImpl::SendOnAppPropertiesChangeNotification( + const std::string& policy_app_id) const { + LOG4CXX_AUTO_TRACE(logger_); + listener_->SendOnAppPropertiesChangeNotification(policy_app_id); +} + +void PolicyManagerImpl::ResumePendingAppPolicyActions() { + LOG4CXX_AUTO_TRACE(logger_); + + for (auto& notify_system_params : notify_system_list_) { + NotifySystem(notify_system_params.first, notify_system_params.second); + } + notify_system_list_.clear(); + + for (auto& send_permissions_params : send_permissions_list_) { + SendPermissionsToApp(send_permissions_params.first, + send_permissions_params.second); + } + + for (auto& app : app_properties_changed_list_) { + SendOnAppPropertiesChangeNotification(app); + } + + send_permissions_list_.clear(); +} + +void PolicyManagerImpl::NotifySystem( + const std::string& device_id, + const PolicyManagerImpl::AppPoliciesValueType& app_policy) const { + listener()->OnPendingPermissionChange(device_id, app_policy.first); +} + +void PolicyManagerImpl::SendPermissionsToApp( + const std::string& device_id, + const PolicyManagerImpl::AppPoliciesValueType& app_policy) { + const std::string app_id = app_policy.first; + + std::vector<FunctionalGroupPermission> group_permissons; + GetPermissionsForApp(device_id, app_id, group_permissons); + + Permissions notification_data; + + // Need to get rid of this call + auto policy_table_snapshot = cache_->GenerateSnapshot(); + + PrepareNotificationData( + policy_table_snapshot->policy_table.functional_groupings, + app_policy.second.groups, + group_permissons, + notification_data); + + std::string default_hmi; + default_hmi = "NONE"; + listener()->OnPermissionsUpdated( + device_id, app_id, notification_data, default_hmi); +} + +CheckAppPolicyResults PolicyManagerImpl::CheckPermissionsChanges( const std::shared_ptr<policy_table::Table> pt_update, const std::shared_ptr<policy_table::Table> snapshot) { LOG4CXX_AUTO_TRACE(logger_); @@ -397,9 +566,13 @@ void PolicyManagerImpl::CheckPermissionsChanges( // to actual values of default section UnwrapAppPolicies(pt_update->policy_table.app_policies_section.apps); + CheckAppPolicyResults out_results; + std::for_each(pt_update->policy_table.app_policies_section.apps.begin(), pt_update->policy_table.app_policies_section.apps.end(), - CheckAppPolicy(this, pt_update, snapshot)); + CheckAppPolicy(this, pt_update, snapshot, out_results)); + + return out_results; } void PolicyManagerImpl::CheckPermissionsChangesAfterUpdate( @@ -418,49 +591,50 @@ void PolicyManagerImpl::PrepareNotificationData( const policy_table::Strings& group_names, const std::vector<FunctionalGroupPermission>& group_permission, Permissions& notification_data) { - LOG4CXX_INFO(logger_, "Preparing data for notification."); + LOG4CXX_AUTO_TRACE(logger_); ProcessFunctionalGroup processor(groups, group_permission, notification_data); std::for_each(group_names.begin(), group_names.end(), processor); } void PolicyManagerImpl::GetUpdateUrls(const std::string& service_type, - EndpointUrls& out_end_points) { + EndpointUrls& out_end_points) const { LOG4CXX_AUTO_TRACE(logger_); cache_->GetUpdateUrls(service_type, out_end_points); } + void PolicyManagerImpl::GetUpdateUrls(const uint32_t service_type, - EndpointUrls& out_end_points) { + EndpointUrls& out_end_points) const { LOG4CXX_AUTO_TRACE(logger_); 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::Table> policy_table_snapshot = - cache_->GenerateSnapshot(); - if (!policy_table_snapshot) { - LOG4CXX_ERROR(logger_, "Failed to create snapshot of policy table"); - return false; - } - - IsPTValid(policy_table_snapshot, policy_table::PT_SNAPSHOT); + BinaryMessage update; + if (PTUIterationType::DefaultIteration == iteration_type) { + std::shared_ptr<policy_table::Table> policy_table_snapshot = + cache_->GenerateSnapshot(); + if (!policy_table_snapshot) { + LOG4CXX_ERROR(logger_, "Failed to create snapshot of policy table"); + return false; + } - Json::Value value = policy_table_snapshot->ToJsonValue(); - Json::FastWriter writer; - std::string message_string = writer.write(value); + IsPTValid(policy_table_snapshot, policy_table::PT_SNAPSHOT); - LOG4CXX_DEBUG(logger_, "Snapshot contents is : " << message_string); + Json::Value value = policy_table_snapshot->ToJsonValue(); + Json::StreamWriterBuilder writer_builder; + writer_builder["indentation"] = ""; + std::string message_string = Json::writeString(writer_builder, value); - BinaryMessage update(message_string.begin(), message_string.end()); + LOG4CXX_DEBUG(logger_, "Snapshot contents is : " << message_string); - listener_->OnSnapshotCreated(update); + update = BinaryMessage(message_string.begin(), message_string.end()); + } + ptu_requested_ = true; + listener_->OnSnapshotCreated(update, iteration_type); return true; } -std::string PolicyManagerImpl::GetLockScreenIconUrl() const { - return cache_->GetLockScreenIconUrl(); -} - std::string PolicyManagerImpl::GetIconUrl( const std::string& policy_app_id) const { return cache_->GetIconUrl(policy_app_id); @@ -488,14 +662,16 @@ void PolicyManagerImpl::StartPTExchange() { return; } - if (listener_ && listener_->CanUpdate()) { + if (listener_) { if (ignition_check) { CheckTriggers(); ignition_check = false; } if (update_status_manager_.IsUpdateRequired()) { - if (RequestPTUpdate() && !timer_retry_sequence_.is_running()) { + update_status_manager_.PendingUpdate(); + if (RequestPTUpdate(PTUIterationType::DefaultIteration) && + !timer_retry_sequence_.is_running()) { // Start retry sequency const uint32_t timeout_msec = NextRetryTimeout(); @@ -520,15 +696,36 @@ void PolicyManagerImpl::OnAppsSearchCompleted(const bool trigger_ptu) { trigger_ptu_ = trigger_ptu; - if (update_status_manager_.IsUpdateRequired()) { + if (update_status_manager_.IsUpdateRequired() && !ptu_requested_ && + HasApplicationForPTU()) { StartPTExchange(); } } -void PolicyManagerImpl::OnAppRegisteredOnMobile( - const std::string& application_id) { +void PolicyManagerImpl::OnLocalAppAdded() { + LOG4CXX_AUTO_TRACE(logger_); + update_status_manager_.ScheduleUpdate(); StartPTExchange(); - SendNotificationOnPermissionsUpdated(application_id); +} + +void PolicyManagerImpl::UpdatePTUReadyAppsCount(const uint32_t new_app_count) { + LOG4CXX_AUTO_TRACE(logger_); + applications_pending_ptu_count_ = new_app_count; +} + +void PolicyManagerImpl::OnAppRegisteredOnMobile( + const std::string& device_id, const std::string& application_id) { + if (application_id != last_registered_policy_app_id_) { + if (last_registered_policy_app_id_.empty()) { + LOG4CXX_DEBUG(logger_, "Stopping update after first app is registered"); + // ResetRetrySequence(ResetRetryCountType::kResetInternally); + StopRetrySequence(); + } + StartPTExchange(); + last_registered_policy_app_id_ = application_id; + } + + SendNotificationOnPermissionsUpdated(device_id, application_id); } void PolicyManagerImpl::OnDeviceSwitching(const std::string& device_id_from, @@ -562,9 +759,18 @@ const std::vector<std::string> PolicyManagerImpl::GetAppRequestSubTypes( cache_->GetAppRequestSubTypes(policy_app_id, request_subtypes); return request_subtypes; } +const std::vector<policy_table::VehicleDataItem> +PolicyManagerImpl::GetVehicleDataItems() const { + return cache_->GetVehicleDataItems(); +} + +std::vector<policy_table::VehicleDataItem> +PolicyManagerImpl::GetRemovedVehicleDataItems() const { + return cache_->GetRemovedVehicleDataItems(); +} -const VehicleInfo PolicyManagerImpl::GetVehicleInfo() const { - return cache_->GetVehicleInfo(); +Json::Value PolicyManagerImpl::GetPolicyTableData() const { + return cache_->GetPolicyTableData(); } void PolicyManagerImpl::GetEnabledCloudApps( @@ -572,21 +778,13 @@ void PolicyManagerImpl::GetEnabledCloudApps( cache_->GetEnabledCloudApps(enabled_apps); } -bool PolicyManagerImpl::GetCloudAppParameters( - const std::string& policy_app_id, - bool& enabled, - std::string& endpoint, - std::string& certificate, - std::string& auth_token, - std::string& cloud_transport_type, - std::string& hybrid_app_preference) const { - return cache_->GetCloudAppParameters(policy_app_id, - enabled, - endpoint, - certificate, - auth_token, - cloud_transport_type, - hybrid_app_preference); +std::vector<std::string> PolicyManagerImpl::GetEnabledLocalApps() const { + return cache_->GetEnabledLocalApps(); +} + +bool PolicyManagerImpl::GetAppProperties( + const std::string& policy_app_id, AppProperties& out_app_properties) const { + return cache_->GetAppProperties(policy_app_id, out_app_properties); } void PolicyManagerImpl::InitCloudApp(const std::string& policy_app_id) { @@ -681,16 +879,8 @@ bool PolicyManagerImpl::ResetUserConsent() { } void PolicyManagerImpl::SendNotificationOnPermissionsUpdated( - const std::string& application_id) { + 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 " - "'" << application_id - << "'"); - return; - } std::vector<FunctionalGroupPermission> app_group_permissions; GetPermissionsForApp(device_id, application_id, app_group_permissions); @@ -699,12 +889,8 @@ void PolicyManagerImpl::SendNotificationOnPermissionsUpdated( cache_->GetFunctionalGroupings(functional_groupings); policy_table::Strings app_groups; - std::vector<FunctionalGroupPermission>::const_iterator it = - app_group_permissions.begin(); - std::vector<FunctionalGroupPermission>::const_iterator it_end = - app_group_permissions.end(); - for (; it != it_end; ++it) { - app_groups.push_back((*it).group_name); + for (const auto& group_permission : app_group_permissions) { + app_groups.push_back(group_permission.group_name); } Permissions notification_data; @@ -714,19 +900,19 @@ void PolicyManagerImpl::SendNotificationOnPermissionsUpdated( notification_data); LOG4CXX_INFO(logger_, - "Send notification for application_id:" << application_id); + "Send notification for application_id: " << application_id); - std::string default_hmi; - default_hmi = "NONE"; + std::string default_hmi = "NONE"; const ApplicationOnDevice who = {device_id, application_id}; if (access_remote_->IsAppRemoteControl(who)) { - listener()->OnPermissionsUpdated(application_id, notification_data); + listener()->OnPermissionsUpdated( + device_id, application_id, notification_data); return; } listener()->OnPermissionsUpdated( - application_id, notification_data, default_hmi); + device_id, application_id, notification_data, default_hmi); } bool PolicyManagerImpl::CleanupUnpairedDevices() { @@ -748,6 +934,9 @@ void PolicyManagerImpl::SetUserConsentForDevice(const std::string& device_id, DeviceConsent current_consent = GetUserConsentForDevice(device_id); bool is_current_device_allowed = DeviceConsent::kDeviceAllowed == current_consent ? true : false; + if (is_allowed) { + StartPTExchange(); + } if (DeviceConsent::kDeviceHasNoConsent != current_consent && is_current_device_allowed == is_allowed) { const std::string consent = is_allowed ? "allowed" : "disallowed"; @@ -756,8 +945,13 @@ void PolicyManagerImpl::SetUserConsentForDevice(const std::string& device_id, } } -bool PolicyManagerImpl::ReactOnUserDevConsentForApp(const std::string app_id, - bool is_device_allowed) { +bool PolicyManagerImpl::ReactOnUserDevConsentForApp( + const transport_manager::DeviceHandle& device_handle, + const std::string app_id, + bool is_device_allowed) { + UNUSED(device_handle); + UNUSED(app_id); + UNUSED(is_device_allowed); return true; } @@ -868,11 +1062,11 @@ void PolicyManagerImpl::SetUserConsentForApp( LOG4CXX_AUTO_TRACE(logger_); } -bool PolicyManagerImpl::GetDefaultHmi(const std::string& policy_app_id, +bool PolicyManagerImpl::GetDefaultHmi(const std::string& device_id, + const std::string& policy_app_id, std::string* default_hmi) const { LOG4CXX_AUTO_TRACE(logger_); - const std::string device_id = GetCurrentDeviceId(policy_app_id); - DeviceConsent device_consent = GetUserConsentForDevice(device_id); + const DeviceConsent device_consent = GetUserConsentForDevice(device_id); const std::string app_id = policy::kDeviceAllowed != device_consent ? kPreDataConsentId : policy_app_id; @@ -955,7 +1149,7 @@ void PolicyManagerImpl::GetPermissionsForApp( app_id_to_check = kDefaultId; allowed_by_default = true; } else if (cache_->IsPredataPolicy(policy_app_id) || - policy::kDeviceDisallowed == GetUserConsentForDevice(device_id)) { + policy::kDeviceAllowed != GetUserConsentForDevice(device_id)) { app_id_to_check = kPreDataConsentId; allowed_by_default = true; } @@ -1010,9 +1204,11 @@ void PolicyManagerImpl::GetPermissionsForApp( } std::string& PolicyManagerImpl::GetCurrentDeviceId( + const transport_manager::DeviceHandle& device_handle, const std::string& policy_app_id) const { LOG4CXX_AUTO_TRACE(logger_); - last_device_id_ = listener()->OnCurrentDeviceIdUpdateRequired(policy_app_id); + last_device_id_ = + listener()->OnCurrentDeviceIdUpdateRequired(device_handle, policy_app_id); return last_device_id_; } @@ -1024,14 +1220,6 @@ void PolicyManagerImpl::SetSystemInfo(const std::string& ccpu_version, LOG4CXX_AUTO_TRACE(logger_); } -void PolicyManagerImpl::OnSystemReady() { - // Update policy table for the first time with system information - if (cache_->IsPTPreloaded()) { - listener()->OnSystemInfoUpdateRequired(); - return; - } -} - uint32_t PolicyManagerImpl::GetNotificationsNumber( const std::string& priority) const { LOG4CXX_AUTO_TRACE(logger_); @@ -1077,6 +1265,7 @@ void PolicyManagerImpl::KmsChanged(int kilometers) { LOG4CXX_INFO(logger_, "Enough kilometers passed to send for PT update."); update_status_manager_.ScheduleUpdate(); StartPTExchange(); + PTUpdatedAt(KILOMETERS, kilometers); } } @@ -1097,10 +1286,24 @@ void PolicyManagerImpl::IncrementIgnitionCycles() { std::string PolicyManagerImpl::ForcePTExchange() { update_status_manager_.ScheduleUpdate(); + + ptu_requested_ = false; StartPTExchange(); return update_status_manager_.StringifiedUpdateStatus(); } +void PolicyManagerImpl::StopRetrySequence() { + LOG4CXX_AUTO_TRACE(logger_); + + if (timer_retry_sequence_.is_running()) { + timer_retry_sequence_.Stop(); + } + + if (cache_->UpdateRequired()) { + ResetRetrySequence(ResetRetryCountType::kResetWithStatusUpdate); + } +} + std::string PolicyManagerImpl::ForcePTExchangeAtUserRequest() { update_status_manager_.ScheduleManualUpdate(); StartPTExchange(); @@ -1112,6 +1315,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; @@ -1137,16 +1341,23 @@ 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(); 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(); + retry_sequence_url_ = RetrySequenceURL(); + ptu_requested_ = false; + if (ResetRetryCountType::kResetWithStatusUpdate == reset_type) { + update_status_manager_.OnResetRetrySequence(); + } } uint32_t PolicyManagerImpl::TimeoutExchangeMSec() { @@ -1202,7 +1413,8 @@ bool PolicyManagerImpl::IsApplicationRevoked(const std::string& app_id) const { return cache_->IsApplicationRevoked(app_id); } -bool PolicyManagerImpl::IsConsentNeeded(const std::string& app_id) { +bool PolicyManagerImpl::IsConsentNeeded(const std::string& device_id, + const std::string& app_id) { LOG4CXX_AUTO_TRACE(logger_); return false; } @@ -1210,15 +1422,17 @@ bool PolicyManagerImpl::IsConsentNeeded(const std::string& app_id) { void PolicyManagerImpl::SetVINValue(const std::string& value) {} AppPermissions PolicyManagerImpl::GetAppPermissionsChanges( - const std::string& policy_app_id) { + const std::string& device_id, const std::string& policy_app_id) { typedef std::map<std::string, AppPermissions>::iterator PermissionsIt; PermissionsIt app_id_diff = app_permissions_diff_.find(policy_app_id); AppPermissions permissions(policy_app_id); if (app_permissions_diff_.end() != app_id_diff) { permissions = app_id_diff->second; } else { - permissions.appPermissionsConsentNeeded = IsConsentNeeded(policy_app_id); + permissions.appPermissionsConsentNeeded = + IsConsentNeeded(device_id, policy_app_id); permissions.appRevoked = IsApplicationRevoked(policy_app_id); + permissions.isSDLAllowed = true; GetPriority(permissions.application_id, &permissions.priority); } return permissions; @@ -1305,11 +1519,11 @@ class CallStatusChange : public utils::Callable { }; StatusNotifier PolicyManagerImpl::AddApplication( + const std::string& device_id, const std::string& application_id, const rpc::policy_table_interface_base::AppHmiTypes& hmi_types) { LOG4CXX_AUTO_TRACE(logger_); - const std::string device_id = GetCurrentDeviceId(application_id); - DeviceConsent device_consent = GetUserConsentForDevice(device_id); + auto device_consent = GetUserConsentForDevice(device_id); sync_primitives::AutoLock lock(apps_registration_lock_); if (IsNewApplication(application_id)) { AddNewApplication(application_id, device_consent); @@ -1317,7 +1531,9 @@ StatusNotifier PolicyManagerImpl::AddApplication( device_consent); } PromoteExistedApplication(application_id, device_consent); - update_status_manager_.OnExistedApplicationAdded(cache_->UpdateRequired()); + if (!ptu_requested_) { + update_status_manager_.OnExistedApplicationAdded(cache_->UpdateRequired()); + } return std::make_shared<utils::CallNothing>(); } @@ -1356,6 +1572,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) { @@ -1398,10 +1615,10 @@ bool PolicyManagerImpl::InitPT(const std::string& file_name, if (!certificate_data.empty()) { listener_->OnCertificateUpdated(certificate_data); } - std::vector<std::string> enabled_apps; - cache_->GetEnabledCloudApps(enabled_apps); - for (auto it = enabled_apps.begin(); it != enabled_apps.end(); ++it) { - SendAuthTokenUpdated(*it); + std::vector<std::string> enabled_cloud_apps; + cache_->GetEnabledCloudApps(enabled_cloud_apps); + for (auto app : enabled_cloud_apps) { + SendAuthTokenUpdated(app); } } return ret; @@ -1412,6 +1629,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); } @@ -1420,8 +1642,36 @@ void PolicyManagerImpl::set_cache_manager( cache_ = std::shared_ptr<CacheManagerInterface>(cache_manager); } -void PolicyManagerImpl::RetrySequence() { - LOG4CXX_INFO(logger_, "Start new retry sequence"); +void PolicyManagerImpl::ResetTimeout() { + LOG4CXX_AUTO_TRACE(logger_); + if (update_status_manager_.IsUpdatePending()) { + if (timer_retry_sequence_.is_running()) { + timer_retry_sequence_.Stop(); + } + timer_retry_sequence_.Start(cache_->TimeoutResponse(), timer::kSingleShot); + } +} + +void PolicyManagerImpl::OnPTUIterationTimeout() { + 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(); + ResetRetrySequence(ResetRetryCountType::kResetWithStatusUpdate); + if (timer_retry_sequence_.is_running()) { + timer_retry_sequence_.Stop(); + } + + if (HasApplicationForPTU()) { + StartPTExchange(); + } + return; + } + update_status_manager_.OnUpdateTimeoutOccurs(); const uint32_t timeout_msec = NextRetryTimeout(); @@ -1433,14 +1683,21 @@ void PolicyManagerImpl::RetrySequence() { return; } - RequestPTUpdate(); + RequestPTUpdate(PTUIterationType::RetryIteration); timer_retry_sequence_.Start(timeout_msec, timer::kPeriodic); } -void PolicyManagerImpl::SetDefaultHmiTypes(const std::string& application_id, - const std::vector<int>& hmi_types) { +bool PolicyManagerImpl::HasApplicationForPTU() const { + return applications_pending_ptu_count_ > 0; +} + +void PolicyManagerImpl::SetDefaultHmiTypes( + const transport_manager::DeviceHandle& device_handle, + const std::string& application_id, + const std::vector<int>& hmi_types) { LOG4CXX_INFO(logger_, "SetDefaultHmiTypes"); - const std::string device_id = GetCurrentDeviceId(application_id); + const std::string device_id = + GetCurrentDeviceId(device_handle, application_id); ApplicationOnDevice who = {device_id, application_id}; access_remote_->SetDefaultHmiTypes(who, hmi_types); } @@ -1478,7 +1735,7 @@ bool PolicyManagerImpl::CheckModule(const PTString& app_id, void PolicyManagerImpl::SendHMILevelChanged(const ApplicationOnDevice& who) { std::string default_hmi("NONE"); - if (GetDefaultHmi(who.app_id, &default_hmi)) { + if (GetDefaultHmi(who.dev_id, who.app_id, &default_hmi)) { listener()->OnUpdateHMIStatus(who.dev_id, who.app_id, default_hmi); } else { LOG4CXX_WARN( @@ -1515,16 +1772,14 @@ void PolicyManagerImpl::SendAppPermissionsChanged( const std::string& device_id, const std::string& application_id) { Permissions notification_data; GetPermissions(device_id, application_id, ¬ification_data); - listener()->OnPermissionsUpdated(application_id, notification_data); + listener()->OnPermissionsUpdated( + device_id, application_id, notification_data); } void PolicyManagerImpl::SendAuthTokenUpdated(const std::string policy_app_id) { - bool enabled = false; - std::string end, cert, ctt, hap; - std::string auth_token; - cache_->GetCloudAppParameters( - policy_app_id, enabled, end, cert, auth_token, ctt, hap); - listener_->OnAuthTokenUpdated(policy_app_id, auth_token); + AppProperties app_properties; + cache_->GetAppProperties(policy_app_id, app_properties); + listener_->OnAuthTokenUpdated(policy_app_id, app_properties.auth_token); } void PolicyManagerImpl::OnPrimaryGroupsChanged( @@ -1552,4 +1807,111 @@ void PolicyManagerImpl::set_access_remote( access_remote_ = access_remote; } +bool PolicyManagerImpl::AppNeedEncryption( + const std::string& policy_app_id) const { + LOG4CXX_AUTO_TRACE(logger_); + const auto encryption_required = + cache_->GetAppEncryptionRequiredFlag(policy_app_id); + + return encryption_required.is_initialized() ? *encryption_required : true; +} + +const rpc::Optional<rpc::Boolean> PolicyManagerImpl::GetAppEncryptionRequired( + const std::string& policy_app_id) const { + LOG4CXX_AUTO_TRACE(logger_); + return cache_->GetAppEncryptionRequiredFlag(policy_app_id); +} + +const std::vector<std::string> PolicyManagerImpl::GetFunctionalGroupsForApp( + const std::string& policy_app_id) const { + LOG4CXX_AUTO_TRACE(logger_); + using namespace rpc::policy_table_interface_base; + DCHECK(kDeviceId != policy_app_id); + + std::vector<std::string> function_groups; + + ApplicationParams app_policies; + cache_->GetApplicationParams(policy_app_id, app_policies); + + const auto& policy_function_group = app_policies.groups; + + for (const auto& group : policy_function_group) { + function_groups.push_back(group); + } + + return function_groups; +} + +const std::vector<std::string> PolicyManagerImpl::GetApplicationPolicyIDs() + const { + LOG4CXX_AUTO_TRACE(logger_); + std::vector<std::string> policy_app_ids; + + const auto apps = cache_->GetPolicyAppIDs(); + + for (const auto& app : apps) { + policy_app_ids.push_back(app); + } + + return policy_app_ids; +} + +bool PolicyManagerImpl::FunctionGroupNeedEncryption( + const std::string& policy_group) const { + LOG4CXX_AUTO_TRACE(logger_); + FunctionalGroupings functional_groupings; + cache_->GetFunctionalGroupings(functional_groupings); + + const auto& grouping_itr = functional_groupings.find(policy_group); + if (grouping_itr == functional_groupings.end()) { + LOG4CXX_WARN(logger_, "Group " << policy_group << " not found"); + return false; + } + + const auto& grouping = (*grouping_itr).second; + + return grouping.encryption_required.is_initialized() + ? *grouping.encryption_required + : false; +} + +void PolicyManagerImpl::TriggerPTUOnStartupIfRequired() { + LOG4CXX_AUTO_TRACE(logger_); + if (ignition_check) { + StartPTExchange(); + } +} + +const std::string PolicyManagerImpl::GetPolicyFunctionName( + const uint32_t function_id) const { + return policy_table::EnumToJsonString( + static_cast<policy_table::FunctionID>(function_id)); +} + +const std::vector<std::string> PolicyManagerImpl::GetRPCsForFunctionGroup( + const std::string& group) const { + std::vector<std::string> rpcs_for_group; + + FunctionalGroupings functional_groupings; + cache_->GetFunctionalGroupings(functional_groupings); + + const auto& rpcs = functional_groupings[group].rpcs; + + for (const auto& rpc : rpcs) { + rpcs_for_group.push_back(rpc.first); + } + + return rpcs_for_group; +} + } // namespace policy + +__attribute__((visibility("default"))) policy::PolicyManager* CreateManager() { + return new policy::PolicyManagerImpl(); +} + +__attribute__((visibility("default"))) void DeleteManager( + policy::PolicyManager* pm) { + delete pm; + DELETE_THREAD_LOGGER(policy::logger_); +} |