| // Copyright 2020 The Chromium OS Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "hermes/lpa_util.h" |
| |
| #include <map> |
| #include <string> |
| |
| #include <base/strings/stringprintf.h> |
| #include <brillo/errors/error_codes.h> |
| #include <brillo/map_utils.h> |
| #include <chromeos/dbus/service_constants.h> |
| #include <google-lpa/lpa/card/euicc_card.h> |
| #include <google-lpa/lpa/core/lpa.h> |
| #include <google-lpa/lpa/smdx/smdp_client.h> |
| |
| namespace hermes { |
| |
| namespace { |
| |
| constexpr int kOuterErrorBase = 100000; |
| constexpr int kInnerErrorMax = 1000; |
| |
| struct InnerError { |
| const char* error_code_; |
| const char* error_message_; |
| }; |
| |
| const std::map<int, const char*>& GetOuterErrorMap() { |
| static std::map<int, const char*> err_map{ |
| {0, ""}, |
| {lpa::core::Lpa::kSetTestModeError, "Lpa SetTestModeError: "}, |
| {lpa::core::Lpa::kGetEidError, "Lpa GetEid: "}, |
| {lpa::core::Lpa::kGetInstalledProfilesError, |
| "Lpa GetInstalledProfiles: "}, |
| {lpa::core::Lpa::kEnableProfileError, "Lpa EnableProfile: "}, |
| {lpa::core::Lpa::kDisableProfileError, "Lpa DisableProfile: "}, |
| {lpa::core::Lpa::kSetProfileNicknameError, "Lpa SetProfileNickname: "}, |
| {lpa::core::Lpa::kDeleteProfileError, "Lpa DeleteProfile: "}, |
| {lpa::core::Lpa::kResetMemoryError, "Lpa ResetMemory: "}, |
| {lpa::core::Lpa::kDownloadProfileError, "Lpa DownloadProfile: "}, |
| {lpa::core::Lpa::kGetProfileFromActivationCodeError, |
| "Lpa GetProfileFromActivationCode: "}, |
| {lpa::core::Lpa::kGetDefaultProfileFromSmdpError, |
| "Lpa GetDefaultProfileFromSmdp: "}, |
| {lpa::core::Lpa::kSendNotificationsError, "Lpa SendNotifications: "}, |
| }; |
| return err_map; |
| } |
| |
| const std::map<int, const char*>& GetMidErrorMap() { |
| static std::map<int, const char*> err_map{ |
| {0, ""}, |
| {lpa::card::EuiccCard::kGetEidError, "EuiccCard GetEid: "}, |
| {lpa::card::EuiccCard::kGetProfilesInfoError, |
| "EuiccCard GetProfilesInfo: "}, |
| {lpa::card::EuiccCard::kEnableProfileError, "EuiccCard EnableProfile: "}, |
| {lpa::card::EuiccCard::kDisableProfileError, |
| "EuiccCard DisableProfile: "}, |
| {lpa::card::EuiccCard::kDeleteProfileError, "EuiccCard DeleteProfile: "}, |
| {lpa::card::EuiccCard::kSetNicknameError, "EuiccCard SetNickname: "}, |
| {lpa::card::EuiccCard::kGetEuiccConfiguredAddressesError, |
| "EuiccCard GetEuiccConfiguredAddresses: "}, |
| {lpa::card::EuiccCard::kSetDefaultSmdpAddressError, |
| "EuiccCard SetDefaultSmdpAddress: "}, |
| {lpa::card::EuiccCard::kGetRatError, "EuiccCard GetRat: "}, |
| {lpa::card::EuiccCard::kResetMemoryError, "EuiccCard ResetMemory: "}, |
| {lpa::card::EuiccCard::kGetEuiccChallengeError, |
| "EuiccCard GetEuiccChallenge: "}, |
| {lpa::card::EuiccCard::kGetEuiccInfo1Error, "EuiccCard GetEuiccInfo1: "}, |
| {lpa::card::EuiccCard::kGetEuiccInfo2Error, "EuiccCard GetEuiccInfo2: "}, |
| {lpa::card::EuiccCard::kAuthenticateServerError, |
| "EuiccCard AuthenticateServer: "}, |
| {lpa::card::EuiccCard::kPrepareDownloadError, |
| "EuiccCard PrepareDownload: "}, |
| {lpa::card::EuiccCard::kLoadBoundProfilePackageError, |
| "EuiccCard LoadBoundProfilePackage: "}, |
| {lpa::card::EuiccCard::kCancelSessionError, "EuiccCard CancelSession: "}, |
| {lpa::card::EuiccCard::kListNotificationsError, |
| "EuiccCard ListNotifications: "}, |
| {lpa::card::EuiccCard::kRetrieveNotificationListError, |
| "EuiccCard RetrieveNotificationList: "}, |
| {lpa::card::EuiccCard::kRetrieveNotificationError, |
| "EuiccCard RetrieveNotification: "}, |
| {lpa::card::EuiccCard::kRemoveNotificationFromListError, |
| "EuiccCard RemoveNotificationFromList: "}, |
| {lpa::smdp::SmdpClient::kInitiateAuthenticationError, |
| "Smdp InitiateAuthentication: "}, |
| {lpa::smdp::SmdpClient::kAuthenticateClientError, |
| "Smdp AuthenticateClient: "}, |
| {lpa::smdp::SmdpClient::kGetBoundProfilePackageError, |
| "Smdp GetBoundProfilePackage: "}, |
| {lpa::smdp::SmdpClient::kCancelSessionError, "Smdp CancelSession: "}, |
| {lpa::smdp::SmdpClient::kHandleNotificationError, |
| "Smdp HandleNotification: "}, |
| }; |
| return err_map; |
| } |
| |
| const std::map<int, InnerError>& GetInnerErrorMap() { |
| static std::map<int, InnerError> err_map{ |
| {lpa::core::Lpa::kWrongState, |
| {kErrorWrongState, "Invalid state for requested method"}}, |
| {lpa::core::Lpa::kIccidNotFound, {kErrorInvalidIccid, "Invalid iccid"}}, |
| {lpa::core::Lpa::kProfileAlreadyEnabled, |
| {kErrorAlreadyEnabled, |
| "Requested method provided an already-enabled profile"}}, |
| {lpa::core::Lpa::kProfileAlreadyDisabled, |
| {kErrorAlreadyDisabled, "Requested method provided a disabled profile"}}, |
| {lpa::core::Lpa::kNeedConfirmationCode, |
| {kErrorNeedConfirmationCode, "Need confirmation code"}}, |
| {lpa::core::Lpa::kInvalidActivationCode, |
| {kErrorInvalidActivationCode, "Invalid activation code"}}, |
| {lpa::core::Lpa::kFailedToSendNotifications, |
| {kErrorSendNotificationFailure, "Failed to send notifications"}}, |
| {lpa::core::Lpa::kNoOpForTestingProfile, |
| {kErrorTestProfileInProd, "Non-test mode cannot use test profile"}}, |
| {lpa::card::EuiccCard::kNoResponses, |
| {kErrorNoResponse, "No response from eUICC"}}, |
| {lpa::card::EuiccCard::kMalformedResponse, |
| {kErrorMalformedResponse, "Malformed response from eUICC"}}, |
| {lpa::card::EuiccCard::kSendApduError, |
| {kErrorSendApduFailure, "Failed to send APDU to eUICC"}}, |
| {lpa::card::EuiccCard::kInvalidIccid, |
| {kErrorInvalidIccid, "Invalid iccid"}}, |
| {lpa::card::EuiccCard::kBadRequest, |
| {kErrorBadRequest, "Bad eUICC request"}}, |
| {lpa::smdp::SmdpClient::kMalformedResponse, |
| {kErrorMalformedResponse, "Malformed response"}}, |
| {lpa::smdp::SmdpClient::kSendHttpsError, |
| {kErrorSendHttpsFailure, "Error sending HTTPS"}}, |
| {lpa::smdp::SmdpClient::kBadNotification, |
| {kErrorBadNotification, "Bad notification"}}, |
| }; |
| return err_map; |
| } |
| |
| } // namespace |
| |
| brillo::ErrorPtr LpaErrorToBrillo(const base::Location& location, int error) { |
| int lpa_inner_code = error % kInnerErrorMax; |
| if (lpa_inner_code == lpa::core::Lpa::kNoError) { |
| return nullptr; |
| } |
| |
| int lpa_outer_mod = error % kOuterErrorBase; |
| int lpa_outer_code = error - lpa_outer_mod; |
| std::string error_message = brillo::GetOrDefault( |
| GetOuterErrorMap(), lpa_outer_code, "Lpa UnknownMethod: "); |
| |
| int lpa_mid_code = lpa_outer_mod - lpa_inner_code; |
| error_message += |
| brillo::GetOrDefault(GetMidErrorMap(), lpa_mid_code, "UnknownMid: "); |
| |
| const auto& inner_error = brillo::GetOrDefault( |
| GetInnerErrorMap(), lpa_inner_code, {kErrorUnknown, "Unknown error"}); |
| error_message += |
| base::StringPrintf("%s (%d)", inner_error.error_message_, lpa_inner_code); |
| |
| return brillo::Error::Create(location, brillo::errors::dbus::kDomain, |
| inner_error.error_code_, error_message); |
| } |
| |
| } // namespace hermes |