diff --git a/libwvdrmengine/cdm/core/include/wv_cdm_types.h b/libwvdrmengine/cdm/core/include/wv_cdm_types.h index f228d308..6211f47a 100644 --- a/libwvdrmengine/cdm/core/include/wv_cdm_types.h +++ b/libwvdrmengine/cdm/core/include/wv_cdm_types.h @@ -47,6 +47,136 @@ enum CdmResponseType { NEED_PROVISIONING, DEVICE_REVOKED, INSUFFICIENT_CRYPTO_RESOURCES, + ADD_KEY_ERROR, + CERT_PROVISIONING_GET_KEYBOX_ERROR_1, + CERT_PROVISIONING_GET_KEYBOX_ERROR_2, + CERT_PROVISIONING_INVALID_CERT_TYPE, + CERT_PROVISIONING_REQUEST_ERROR_1, + CERT_PROVISIONING_REQUEST_ERROR_2, + CERT_PROVISIONING_REQUEST_ERROR_3, + CERT_PROVISIONING_REQUEST_ERROR_4, + CERT_PROVISIONING_RESPONSE_ERROR_1, + CERT_PROVISIONING_RESPONSE_ERROR_2, + CERT_PROVISIONING_RESPONSE_ERROR_3, + CERT_PROVISIONING_RESPONSE_ERROR_4, + CERT_PROVISIONING_RESPONSE_ERROR_5, + CERT_PROVISIONING_RESPONSE_ERROR_6, + CERT_PROVISIONING_RESPONSE_ERROR_7, + CERT_PROVISIONING_RESPONSE_ERROR_8, + CRYPTO_SESSION_OPEN_ERROR_1, + CRYPTO_SESSION_OPEN_ERROR_2, + CRYPTO_SESSION_OPEN_ERROR_3, + CRYPTO_SESSION_OPEN_ERROR_4, + CRYPTO_SESSION_OPEN_ERROR_5, + DECRYPT_NOT_READY, + DEVICE_CERTIFICATE_ERROR_1, + DEVICE_CERTIFICATE_ERROR_2, + DEVICE_CERTIFICATE_ERROR_3, + DEVICE_CERTIFICATE_ERROR_4, + EMPTY_KEY_DATA_1, + EMPTY_KEY_DATA_2, + EMPTY_KEYSET_ID, + EMPTY_KEYSET_ID_ENG_1, + EMPTY_KEYSET_ID_ENG_2, + EMPTY_KEYSET_ID_ENG_3, + EMPTY_KEYSET_ID_ENG_4, + EMPTY_LICENSE_REQUEST, + EMPTY_LICENSE_RESPONSE_1, + EMPTY_LICENSE_RESPONSE_2, + EMPTY_PROVISIONING_CERTIFICATE, + EMPTY_PROVISIONING_RESPONSE, + EMPTY_SESSION_ID, + GENERATE_DERIVED_KEYS_ERROR, + GENERATE_NONCE_ERROR, + GENERATE_USAGE_REPORT_ERROR, + GET_LICENSE_ERROR, + GET_RELEASED_LICENSE_ERROR, + GET_USAGE_INFO_ERROR_1, + GET_USAGE_INFO_ERROR_2, + GET_USAGE_INFO_ERROR_3, + GET_USAGE_INFO_ERROR_4, + INIT_DATA_NOT_FOUND, + INVALID_CRYPTO_SESSION_1, + INVALID_CRYPTO_SESSION_2, + INVALID_CRYPTO_SESSION_3, + INVALID_CRYPTO_SESSION_4, + INVALID_CRYPTO_SESSION_5, + INVALID_DECRYPT_PARAMETERS_ENG_1, + INVALID_DECRYPT_PARAMETERS_ENG_2, + INVALID_DECRYPT_PARAMETERS_ENG_3, + INVALID_DECRYPT_PARAMETERS_ENG_4, + INVALID_DEVICE_CERTIFICATE_TYPE, + INVALID_KEY_SYSTEM, + INVALID_LICENSE_RESPONSE, + INVALID_LICENSE_TYPE, + INVALID_PARAMETERS_ENG_1, + INVALID_PARAMETERS_ENG_2, + INVALID_PARAMETERS_ENG_3, + INVALID_PARAMETERS_ENG_4, + INVALID_PARAMETERS_LIC_1, + INVALID_PARAMETERS_LIC_2, + INVALID_PROVISIONING_PARAMETERS_1, + INVALID_PROVISIONING_PARAMETERS_2, + INVALID_PROVISIONING_REQUEST_PARAM_1, + INVALID_PROVISIONING_REQUEST_PARAM_2, + INVALID_QUERY_KEY, + INVALID_SESSION_ID, + KEY_REQUEST_ERROR_1, + KEY_REQUEST_ERROR_2, + KEY_SIZE_ERROR, + KEYSET_ID_NOT_FOUND_1, + KEYSET_ID_NOT_FOUND_2, + KEYSET_ID_NOT_FOUND_3, + LICENSE_ID_NOT_FOUND, + LICENSE_PARSER_INIT_ERROR, + LICENSE_PARSER_NOT_INITIALIZED_1, + LICENSE_PARSER_NOT_INITIALIZED_2, + LICENSE_PARSER_NOT_INITIALIZED_3, + LICENSE_RESPONSE_NOT_SIGNED, + LICENSE_RESPONSE_PARSE_ERROR_1, + LICENSE_RESPONSE_PARSE_ERROR_2, + LICENSE_RESPONSE_PARSE_ERROR_3, + LOAD_KEY_ERROR, + NO_CONTENT_KEY, + REFRESH_KEYS_ERROR, + RELEASE_ALL_USAGE_INFO_ERROR_1, + RELEASE_ALL_USAGE_INFO_ERROR_2, + RELEASE_KEY_ERROR, + RELEASE_KEY_REQUEST_ERROR, + RELEASE_LICENSE_ERROR_1, + RELEASE_LICENSE_ERROR_2, + RELEASE_USAGE_INFO_ERROR, + RENEW_KEY_ERROR_1, + RENEW_KEY_ERROR_2, + RENEWAL_REQUEST_ERROR, + RESTORE_OFFLINE_LICENSE_ERROR_1, + RESTORE_OFFLINE_LICENSE_ERROR_2, + SESSION_INIT_ERROR_1, + SESSION_INIT_ERROR_2, + SESSION_INIT_GET_KEYBOX_ERROR, + SESSION_NOT_FOUND_1, + SESSION_NOT_FOUND_2, + SESSION_NOT_FOUND_3, + SESSION_NOT_FOUND_4, + SESSION_NOT_FOUND_5, + SESSION_NOT_FOUND_6, + SESSION_NOT_FOUND_7, + SESSION_NOT_FOUND_8, + SESSION_NOT_FOUND_9, + SESSION_NOT_FOUND_10, + SESSION_NOT_FOUND_FOR_DECRYPT, + SESSION_KEYS_NOT_FOUND, + SIGNATURE_NOT_FOUND, + STORE_LICENSE_ERROR_1, + STORE_LICENSE_ERROR_2, + STORE_LICENSE_ERROR_3, + STORE_USAGE_INFO_ERROR, + UNPROVISION_ERROR_1, + UNPROVISION_ERROR_2, + UNPROVISION_ERROR_3, + UNPROVISION_ERROR_4, + UNSUPPORTED_INIT_DATA, + USAGE_INFO_NOT_FOUND, }; enum CdmKeyStatus { diff --git a/libwvdrmengine/cdm/core/src/cdm_engine.cpp b/libwvdrmengine/cdm/core/src/cdm_engine.cpp index f3166d67..a3953713 100644 --- a/libwvdrmengine/cdm/core/src/cdm_engine.cpp +++ b/libwvdrmengine/cdm/core/src/cdm_engine.cpp @@ -83,19 +83,19 @@ CdmResponseType CdmEngine::OpenSession(const CdmKeySystem& key_system, if (!ValidateKeySystem(key_system)) { LOGI("CdmEngine::OpenSession: invalid key_system = %s", key_system.c_str()); - return KEY_ERROR; + return INVALID_KEY_SYSTEM; } if (!session_id) { LOGE("CdmEngine::OpenSession: no session ID destination provided"); - return KEY_ERROR; + return INVALID_PARAMETERS_ENG_1; } scoped_ptr new_session( new CdmSession(property_set, origin, event_listener)); if (new_session->session_id().empty()) { LOGE("CdmEngine::OpenSession: failure to generate session ID"); - return UNKNOWN_ERROR; + return EMPTY_SESSION_ID; } CdmResponseType sts = new_session->Init(); @@ -121,7 +121,7 @@ CdmResponseType CdmEngine::OpenKeySetSession( if (key_set_id.empty()) { LOGE("CdmEngine::OpenKeySetSession: invalid key set id"); - return KEY_ERROR; + return EMPTY_KEYSET_ID_ENG_1; } CdmSessionId session_id; @@ -141,7 +141,7 @@ CdmResponseType CdmEngine::CloseSession(const CdmSessionId& session_id) { CdmSessionMap::iterator iter = sessions_.find(session_id); if (iter == sessions_.end()) { LOGE("CdmEngine::CloseSession: session not found = %s", session_id.c_str()); - return KEY_ERROR; + return SESSION_NOT_FOUND_1; } CdmSession* session = iter->second; sessions_.erase(session_id); @@ -156,7 +156,7 @@ CdmResponseType CdmEngine::CloseKeySetSession(const CdmKeySetId& key_set_id) { if (iter == release_key_sets_.end()) { LOGE("CdmEngine::CloseKeySetSession: key set id not found = %s", key_set_id.c_str()); - return KEY_ERROR; + return KEYSET_ID_NOT_FOUND_1; } CdmResponseType sts = CloseSession(iter->second); @@ -183,20 +183,20 @@ CdmResponseType CdmEngine::GenerateKeyRequest( if (license_type == kLicenseTypeRelease) { if (key_set_id.empty()) { LOGE("CdmEngine::GenerateKeyRequest: invalid key set ID"); - return UNKNOWN_ERROR; + return EMPTY_KEYSET_ID_ENG_2; } if (!session_id.empty()) { LOGE("CdmEngine::GenerateKeyRequest: invalid session ID = %s", session_id.c_str()); - return UNKNOWN_ERROR; + return INVALID_SESSION_ID; } CdmReleaseKeySetMap::iterator iter = release_key_sets_.find(key_set_id); if (iter == release_key_sets_.end()) { LOGE("CdmEngine::GenerateKeyRequest: key set ID not found = %s", key_set_id.c_str()); - return UNKNOWN_ERROR; + return KEYSET_ID_NOT_FOUND_2; } id = iter->second; @@ -206,12 +206,12 @@ CdmResponseType CdmEngine::GenerateKeyRequest( if (iter == sessions_.end()) { LOGE("CdmEngine::GenerateKeyRequest: session_id not found = %s", id.c_str()); - return KEY_ERROR; + return SESSION_NOT_FOUND_2; } if (!key_request) { LOGE("CdmEngine::GenerateKeyRequest: no key request destination provided"); - return KEY_ERROR; + return INVALID_PARAMETERS_ENG_2; } key_request->clear(); @@ -257,18 +257,18 @@ CdmResponseType CdmEngine::AddKey(const CdmSessionId& session_id, if (license_type_release) { if (!key_set_id) { LOGE("CdmEngine::AddKey: no key set id provided"); - return KEY_ERROR; + return INVALID_PARAMETERS_ENG_3; } if (key_set_id->empty()) { LOGE("CdmEngine::AddKey: invalid key set id"); - return KEY_ERROR; + return EMPTY_KEYSET_ID_ENG_3; } CdmReleaseKeySetMap::iterator iter = release_key_sets_.find(*key_set_id); if (iter == release_key_sets_.end()) { LOGE("CdmEngine::AddKey: key set id not found = %s", key_set_id->c_str()); - return KEY_ERROR; + return KEYSET_ID_NOT_FOUND_3; } id = iter->second; @@ -278,12 +278,12 @@ CdmResponseType CdmEngine::AddKey(const CdmSessionId& session_id, if (iter == sessions_.end()) { LOGE("CdmEngine::AddKey: session id not found = %s", id.c_str()); - return KEY_ERROR; + return SESSION_NOT_FOUND_3; } if (key_data.empty()) { LOGE("CdmEngine::AddKey: no key_data"); - return KEY_ERROR; + return EMPTY_KEY_DATA_1; } CdmResponseType sts = iter->second->AddKey(key_data, key_set_id); @@ -302,14 +302,14 @@ CdmResponseType CdmEngine::RestoreKey(const CdmSessionId& session_id, if (key_set_id.empty()) { LOGI("CdmEngine::RestoreKey: invalid key set id"); - return KEY_ERROR; + return EMPTY_KEYSET_ID_ENG_4; } CdmSessionMap::iterator iter = sessions_.find(session_id); if (iter == sessions_.end()) { LOGE("CdmEngine::RestoreKey: session_id not found = %s ", session_id.c_str()); - return UNKNOWN_ERROR; + return SESSION_NOT_FOUND_4; } CdmResponseType sts = @@ -321,7 +321,7 @@ CdmResponseType CdmEngine::RestoreKey(const CdmSessionId& session_id, if (sts != KEY_ADDED) { LOGE("CdmEngine::RestoreKey: restore offline session failed = %d", sts); } - return sts; + return sts; // TODO ewew } CdmResponseType CdmEngine::RemoveKeys(const CdmSessionId& session_id) { @@ -331,7 +331,7 @@ CdmResponseType CdmEngine::RemoveKeys(const CdmSessionId& session_id) { if (iter == sessions_.end()) { LOGE("CdmEngine::RemoveKeys: session_id not found = %s", session_id.c_str()); - return KEY_ERROR; + return SESSION_NOT_FOUND_5; } iter->second->ReleaseCrypto(); @@ -347,12 +347,12 @@ CdmResponseType CdmEngine::GenerateRenewalRequest( if (iter == sessions_.end()) { LOGE("CdmEngine::GenerateRenewalRequest: session_id not found = %s", session_id.c_str()); - return KEY_ERROR; + return SESSION_NOT_FOUND_6; } if (!key_request) { LOGE("CdmEngine::GenerateRenewalRequest: no key request destination"); - return KEY_ERROR; + return INVALID_PARAMETERS_ENG_4; } key_request->clear(); @@ -376,12 +376,12 @@ CdmResponseType CdmEngine::RenewKey(const CdmSessionId& session_id, CdmSessionMap::iterator iter = sessions_.find(session_id); if (iter == sessions_.end()) { LOGE("CdmEngine::RenewKey: session_id not found = %s", session_id.c_str()); - return KEY_ERROR; + return SESSION_NOT_FOUND_7; } if (key_data.empty()) { LOGE("CdmEngine::RenewKey: no key_data"); - return KEY_ERROR; + return EMPTY_KEY_DATA_2; } CdmResponseType sts = iter->second->RenewKey(key_data); @@ -412,7 +412,7 @@ CdmResponseType CdmEngine::QueryStatus(CdmQueryMap* key_info) { QUERY_VALUE_SECURITY_LEVEL_UNKNOWN; break; default: - return KEY_ERROR; + return INVALID_QUERY_KEY; } std::string deviceId; @@ -472,7 +472,7 @@ CdmResponseType CdmEngine::QuerySessionStatus(const CdmSessionId& session_id, if (iter == sessions_.end()) { LOGE("CdmEngine::QuerySessionStatus: session_id not found = %s", session_id.c_str()); - return KEY_ERROR; + return SESSION_NOT_FOUND_8; } return iter->second->QueryStatus(key_info); } @@ -484,7 +484,7 @@ CdmResponseType CdmEngine::QueryKeyStatus(const CdmSessionId& session_id, if (iter == sessions_.end()) { LOGE("CdmEngine::QueryKeyStatus: session_id not found = %s", session_id.c_str()); - return KEY_ERROR; + return SESSION_NOT_FOUND_9; } return iter->second->QueryKeyStatus(key_info); } @@ -496,7 +496,7 @@ CdmResponseType CdmEngine::QueryKeyControlInfo(const CdmSessionId& session_id, if (iter == sessions_.end()) { LOGE("CdmEngine::QueryKeyControlInfo: session_id not found = %s", session_id.c_str()); - return KEY_ERROR; + return SESSION_NOT_FOUND_10; } return iter->second->QueryKeyControlInfo(key_info); } @@ -506,15 +506,19 @@ CdmResponseType CdmEngine::QueryKeyControlInfo(const CdmSessionId& session_id, * in *request. It also returns the default url for the provisioning server * in *default_url. * - * Returns NO_ERROR for success and UNKNOWN_ERROR if fails. + * Returns NO_ERROR for success and CdmResponseType error code if fails. */ CdmResponseType CdmEngine::GetProvisioningRequest( CdmCertificateType cert_type, const std::string& cert_authority, const std::string& origin, CdmProvisioningRequest* request, std::string* default_url) { - if (!request || !default_url) { + if (!request) { LOGE("CdmEngine::GetProvisioningRequest: invalid output parameters"); - return UNKNOWN_ERROR; + return INVALID_PROVISIONING_REQUEST_PARAM_1; + } + if (!default_url) { + LOGE("CdmEngine::GetProvisioningRequest: invalid output parameters"); + return INVALID_PROVISIONING_REQUEST_PARAM_2; } if (NULL == cert_provisioning_.get()) { cert_provisioning_.reset(new CertificateProvisioning()); @@ -533,7 +537,7 @@ CdmResponseType CdmEngine::GetProvisioningRequest( * The device RSA key is stored in the T.E.E. The device certificate is stored * in the device. * - * Returns NO_ERROR for success and UNKNOWN_ERROR if fails. + * Returns NO_ERROR for success and CdmResponseType error code if fails. */ CdmResponseType CdmEngine::HandleProvisioningResponse( const std::string& origin, CdmProvisioningResponse& response, @@ -541,24 +545,24 @@ CdmResponseType CdmEngine::HandleProvisioningResponse( if (response.empty()) { LOGE("CdmEngine::HandleProvisioningResponse: Empty provisioning response."); cert_provisioning_.reset(NULL); - return UNKNOWN_ERROR; + return EMPTY_PROVISIONING_RESPONSE; } if (NULL == cert) { LOGE( "CdmEngine::HandleProvisioningResponse: invalid certificate " "destination"); cert_provisioning_.reset(NULL); - return UNKNOWN_ERROR; + return INVALID_PROVISIONING_PARAMETERS_1; } if (NULL == wrapped_key) { LOGE("CdmEngine::HandleProvisioningResponse: invalid wrapped key " "destination"); cert_provisioning_.reset(NULL); - return UNKNOWN_ERROR; + return INVALID_PROVISIONING_PARAMETERS_2; } if (NULL == cert_provisioning_.get()) { LOGE("CdmEngine::HandleProvisioningResponse: provisioning object missing."); - return UNKNOWN_ERROR; + return EMPTY_PROVISIONING_CERTIFICATE; } CdmResponseType ret = cert_provisioning_->HandleProvisioningResponse( origin, response, cert, wrapped_key); @@ -581,20 +585,20 @@ CdmResponseType CdmEngine::Unprovision(CdmSecurityLevel security_level, DeviceFiles handle; if (!handle.Init(security_level)) { LOGE("CdmEngine::Unprovision: unable to initialize device files"); - return UNKNOWN_ERROR; + return UNPROVISION_ERROR_1; } if (origin != EMPTY_ORIGIN) { if (!handle.RemoveCertificate(origin)) { LOGE("CdmEngine::Unprovision: unable to delete certificate for origin %s", origin.c_str()); - return UNKNOWN_ERROR; + return UNPROVISION_ERROR_2; } return NO_ERROR; } else { if (!handle.DeleteAllFiles()) { LOGE("CdmEngine::Unprovision: unable to delete files"); - return UNKNOWN_ERROR; + return UNPROVISION_ERROR_3; } scoped_ptr crypto_session(new CryptoSession()); @@ -602,7 +606,7 @@ CdmResponseType CdmEngine::Unprovision(CdmSecurityLevel security_level, security_level == kSecurityLevelL3 ? kLevel3 : kLevelDefault); if (NO_ERROR != status) { LOGE("CdmEngine::Unprovision: error opening crypto session: %d", status); - return UNKNOWN_ERROR; + return UNPROVISION_ERROR_4; } status = crypto_session->DeleteAllUsageReports(); if (status != NO_ERROR) { @@ -630,7 +634,7 @@ CdmResponseType CdmEngine::GetUsageInfo(const std::string& app_id, DeviceFiles handle; if (!handle.Init(usage_session_->GetSecurityLevel())) { LOGE("CdmEngine::GetUsageInfo: device file init error"); - return UNKNOWN_ERROR; + return GET_USAGE_INFO_ERROR_1; } CdmKeyMessage license_request; @@ -648,12 +652,12 @@ CdmResponseType CdmEngine::GetUsageInfo(const std::string& app_id, } if (!handle.Reset(usage_session_->GetSecurityLevel())) { LOGE("CdmEngine::GetUsageInfo: device file init error"); - return UNKNOWN_ERROR; + return GET_USAGE_INFO_ERROR_2; } if (!handle.RetrieveUsageInfo(app_id, ssid, &license_request, &license_response)) { // No entry found for that ssid. - return UNKNOWN_ERROR; + return USAGE_INFO_NOT_FOUND; } } @@ -720,13 +724,13 @@ CdmResponseType CdmEngine::GetUsageInfo(const std::string& app_id, DeviceFiles handle; if (!handle.Init(usage_session_->GetSecurityLevel())) { LOGE("CdmEngine::GetUsageInfo: unable to initialize device files"); - return UNKNOWN_ERROR; + return GET_USAGE_INFO_ERROR_3; } std::vector > license_info; if (!handle.RetrieveUsageInfo(app_id, &license_info)) { LOGE("CdmEngine::GetUsageInfo: unable to read usage information"); - return UNKNOWN_ERROR; + return GET_USAGE_INFO_ERROR_4; } if (0 == license_info.size()) { @@ -775,7 +779,7 @@ CdmResponseType CdmEngine::ReleaseAllUsageInfo(const std::string& app_id) { if (!handle.DeleteAllUsageInfoForApp(app_id, &provider_session_tokens)) { LOGE("CdmEngine::ReleaseAllUsageInfo: failed to delete L%d secure" "stops", j); - status = UNKNOWN_ERROR; + status = RELEASE_ALL_USAGE_INFO_ERROR_1; } else { CdmResponseType status2 = usage_session_-> DeleteMultipleUsageInformation(provider_session_tokens); @@ -786,7 +790,7 @@ CdmResponseType CdmEngine::ReleaseAllUsageInfo(const std::string& app_id) { } else { LOGE("CdmEngine::ReleaseAllUsageInfo: failed to initialize L%d device" "files", j); - status = UNKNOWN_ERROR; + status = RELEASE_ALL_USAGE_INFO_ERROR_2; } } return status; @@ -796,7 +800,7 @@ CdmResponseType CdmEngine::ReleaseUsageInfo( const CdmUsageInfoReleaseMessage& message) { if (NULL == usage_session_.get()) { LOGE("CdmEngine::ReleaseUsageInfo: cdm session not initialized"); - return UNKNOWN_ERROR; + return RELEASE_USAGE_INFO_ERROR; } CdmResponseType status = usage_session_->ReleaseKey(message); @@ -811,24 +815,24 @@ CdmResponseType CdmEngine::Decrypt(const CdmSessionId& session_id, const CdmDecryptionParameters& parameters) { if (parameters.key_id == NULL) { LOGE("CdmEngine::Decrypt: no key_id"); - return KEY_ERROR; + return INVALID_DECRYPT_PARAMETERS_ENG_1; } if (parameters.encrypt_buffer == NULL) { LOGE("CdmEngine::Decrypt: no src encrypt buffer"); - return KEY_ERROR; + return INVALID_DECRYPT_PARAMETERS_ENG_2; } if (parameters.iv == NULL) { LOGE("CdmEngine::Decrypt: no iv"); - return KEY_ERROR; + return INVALID_DECRYPT_PARAMETERS_ENG_3; } if (parameters.decrypt_buffer == NULL) { if (!parameters.is_secure && !Properties::Properties::oem_crypto_use_fifo()) { LOGE("CdmEngine::Decrypt: no dest decrypt buffer"); - return KEY_ERROR; + return INVALID_DECRYPT_PARAMETERS_ENG_4; } // else we must be level 1 direct and we don't need to return a buffer. } @@ -847,7 +851,7 @@ CdmResponseType CdmEngine::Decrypt(const CdmSessionId& session_id, if (iter == sessions_.end()) { LOGE("CdmEngine::Decrypt: session not found: id=%s, id size=%d", session_id.c_str(), session_id.size()); - return KEY_ERROR; + return SESSION_NOT_FOUND_FOR_DECRYPT; } return iter->second->Decrypt(parameters); diff --git a/libwvdrmengine/cdm/core/src/cdm_session.cpp b/libwvdrmengine/cdm/core/src/cdm_session.cpp index b609e118..9f21ded2 100644 --- a/libwvdrmengine/cdm/core/src/cdm_session.cpp +++ b/libwvdrmengine/cdm/core/src/cdm_session.cpp @@ -58,11 +58,11 @@ CdmSession::~CdmSession() { Properties::RemoveSessionPropertySet(session_id_); } CdmResponseType CdmSession::Init() { if (session_id_.empty()) { LOGE("CdmSession::Init: Failed, session not properly constructed"); - return UNKNOWN_ERROR; + return SESSION_INIT_ERROR_1; } if (initialized_) { LOGE("CdmSession::Init: Failed due to previous initialization"); - return UNKNOWN_ERROR; + return SESSION_INIT_ERROR_2; } CdmResponseType sts = crypto_session_->Open(requested_security_level_); if (NO_ERROR != sts) return sts; @@ -77,12 +77,13 @@ CdmResponseType CdmSession::Init() { return NEED_PROVISIONING; } } else { - if (!crypto_session_->GetToken(&token)) return UNKNOWN_ERROR; + if (!crypto_session_->GetToken(&token)) + return SESSION_INIT_GET_KEYBOX_ERROR; } if (!license_parser_->Init(token, crypto_session_.get(), policy_engine_.get())) - return UNKNOWN_ERROR; + return LICENSE_PARSER_INIT_ERROR; license_received_ = false; is_initial_decryption_ = true; @@ -95,7 +96,8 @@ CdmResponseType CdmSession::RestoreOfflineSession( key_set_id_ = key_set_id; // Retrieve license information from persistent store - if (!file_handle_->Reset(security_level_)) return UNKNOWN_ERROR; + if (!file_handle_->Reset(security_level_)) + return RESTORE_OFFLINE_LICENSE_ERROR_1; DeviceFiles::LicenseState license_state; int64_t playback_start_time; @@ -108,7 +110,7 @@ CdmResponseType CdmSession::RestoreOfflineSession( &playback_start_time, &last_playback_time)) { LOGE("CdmSession::Init failed to retrieve license. key set id = %s", key_set_id.c_str()); - return UNKNOWN_ERROR; + return GET_LICENSE_ERROR; } // Do not restore a released offline license, unless a release retry @@ -116,19 +118,19 @@ CdmResponseType CdmSession::RestoreOfflineSession( license_state == DeviceFiles::kLicenseStateActive)) { LOGE("CdmSession::Init invalid offline license state = %d, type = %d", license_state, license_type); - return UNKNOWN_ERROR; + return GET_RELEASED_LICENSE_ERROR; } if (license_type == kLicenseTypeRelease) { if (!license_parser_->RestoreLicenseForRelease(key_request_, key_response_)) { - return UNKNOWN_ERROR; + return RELEASE_LICENSE_ERROR_1; } } else { if (!license_parser_->RestoreOfflineLicense( key_request_, key_response_, offline_key_renewal_response_, playback_start_time, last_playback_time)) { - return UNKNOWN_ERROR; + return RESTORE_OFFLINE_LICENSE_ERROR_2; } } @@ -144,7 +146,7 @@ CdmResponseType CdmSession::RestoreUsageSession( key_response_ = key_response; if (!license_parser_->RestoreLicenseForRelease(key_request_, key_response_)) { - return UNKNOWN_ERROR; + return RELEASE_LICENSE_ERROR_2; } license_received_ = true; @@ -160,12 +162,12 @@ CdmResponseType CdmSession::GenerateKeyRequest( CdmKeySetId* key_set_id) { if (crypto_session_.get() == NULL) { LOGW("CdmSession::GenerateKeyRequest: Invalid crypto session"); - return UNKNOWN_ERROR; + return INVALID_CRYPTO_SESSION_1; } if (!crypto_session_->IsOpen()) { LOGW("CdmSession::GenerateKeyRequest: Crypto session not open"); - return UNKNOWN_ERROR; + return CRYPTO_SESSION_OPEN_ERROR_1; } switch (license_type) { @@ -181,7 +183,7 @@ CdmResponseType CdmSession::GenerateKeyRequest( default: LOGE("CdmSession::GenerateKeyRequest: unrecognized license type: %ld", license_type); - return UNKNOWN_ERROR; + return INVALID_LICENSE_TYPE; } if (is_release_) { @@ -195,21 +197,21 @@ CdmResponseType CdmSession::GenerateKeyRequest( if (!init_data.is_supported()) { LOGW("CdmSession::GenerateKeyRequest: unsupported init data type (%s)", init_data.type().c_str()); - return KEY_ERROR; + return UNSUPPORTED_INIT_DATA; } if (init_data.IsEmpty() && !license_parser_->HasInitData()) { LOGW("CdmSession::GenerateKeyRequest: init data absent"); - return KEY_ERROR; + return INIT_DATA_NOT_FOUND; } if (is_offline_ && !GenerateKeySetId(&key_set_id_)) { LOGE("CdmSession::GenerateKeyRequest: Unable to generate key set ID"); - return UNKNOWN_ERROR; + return KEY_REQUEST_ERROR_1; } if (!license_parser_->PrepareKeyRequest(init_data, license_type, app_parameters, session_id_, key_request, server_url)) { - return KEY_ERROR; + return KEY_REQUEST_ERROR_2; } key_request_ = *key_request; @@ -228,12 +230,12 @@ CdmResponseType CdmSession::AddKey(const CdmKeyResponse& key_response, CdmKeySetId* key_set_id) { if (crypto_session_.get() == NULL) { LOGW("CdmSession::AddKey: Invalid crypto session"); - return UNKNOWN_ERROR; + return INVALID_CRYPTO_SESSION_2; } if (!crypto_session_->IsOpen()) { LOGW("CdmSession::AddKey: Crypto session not open"); - return UNKNOWN_ERROR; + return CRYPTO_SESSION_OPEN_ERROR_2; } if (is_release_) { @@ -244,7 +246,7 @@ CdmResponseType CdmSession::AddKey(const CdmKeyResponse& key_response, } else { CdmResponseType sts = license_parser_->HandleKeyResponse(key_response); - if (sts != KEY_ADDED) return sts; + if (sts != KEY_ADDED) return (KEY_ERROR == sts) ? ADD_KEY_ERROR : sts; license_received_ = true; key_response_ = key_response; @@ -262,12 +264,12 @@ CdmResponseType CdmSession::AddKey(const CdmKeyResponse& key_response, CdmResponseType CdmSession::QueryStatus(CdmQueryMap* key_info) { if (crypto_session_.get() == NULL) { LOGE("CdmSession::QueryStatus: Invalid crypto session"); - return UNKNOWN_ERROR; + return INVALID_CRYPTO_SESSION_3; } if (!crypto_session_->IsOpen()) { LOGE("CdmSession::QueryStatus: Crypto session not open"); - return UNKNOWN_ERROR; + return CRYPTO_SESSION_OPEN_ERROR_3; } switch (security_level_) { @@ -286,7 +288,7 @@ CdmResponseType CdmSession::QueryStatus(CdmQueryMap* key_info) { QUERY_VALUE_SECURITY_LEVEL_UNKNOWN; break; default: - return KEY_ERROR; + return INVALID_QUERY_KEY; } return NO_ERROR; } @@ -298,12 +300,12 @@ CdmResponseType CdmSession::QueryKeyStatus(CdmQueryMap* key_info) { CdmResponseType CdmSession::QueryKeyControlInfo(CdmQueryMap* key_info) { if (crypto_session_.get() == NULL) { LOGW("CdmSession::QueryKeyControlInfo: Invalid crypto session"); - return UNKNOWN_ERROR; + return INVALID_CRYPTO_SESSION_4; } if (!crypto_session_->IsOpen()) { LOGW("CdmSession::QueryKeyControlInfo: Crypto session not open"); - return UNKNOWN_ERROR; + return CRYPTO_SESSION_OPEN_ERROR_4; } std::stringstream ss; @@ -314,13 +316,20 @@ CdmResponseType CdmSession::QueryKeyControlInfo(CdmQueryMap* key_info) { // Decrypt() - Accept encrypted buffer and return decrypted data. CdmResponseType CdmSession::Decrypt(const CdmDecryptionParameters& params) { - if (crypto_session_.get() == NULL || !crypto_session_->IsOpen()) - return UNKNOWN_ERROR; + if (crypto_session_.get() == NULL) { + LOGW("CdmSession::Decrypt: Invalid crypto session"); + return INVALID_CRYPTO_SESSION_5; + } + + if (!crypto_session_->IsOpen()) { + LOGW("CdmSession::Decrypt: Crypto session not open"); + return CRYPTO_SESSION_OPEN_ERROR_5; + } // Playback may not begin until either the start time passes or the license - // is updated, so we treat this Decrypt call as invalid and return KEY_ERROR. + // is updated, so we treat this Decrypt call as invalid. if (params.is_encrypted && !policy_engine_->CanDecrypt(*params.key_id)) { - return policy_engine_->IsLicenseForFuture() ? KEY_ERROR : NEED_KEY; + return policy_engine_->IsLicenseForFuture() ? DECRYPT_NOT_READY : NEED_KEY; } CdmResponseType status = crypto_session_->Decrypt(params); @@ -367,11 +376,12 @@ CdmResponseType CdmSession::GenerateRenewalRequest(CdmKeyMessage* key_request, CdmResponseType CdmSession::RenewKey(const CdmKeyResponse& key_response) { CdmResponseType sts = license_parser_->HandleKeyUpdateResponse(true, key_response); - if (sts != KEY_ADDED) return sts; + if (sts != KEY_ADDED) return (KEY_ERROR == sts) ? RENEW_KEY_ERROR_1 : sts; if (is_offline_) { offline_key_renewal_response_ = key_response; - if (!StoreLicense(DeviceFiles::kLicenseStateActive)) return UNKNOWN_ERROR; + if (!StoreLicense(DeviceFiles::kLicenseStateActive)) + return RENEW_KEY_ERROR_2; } return KEY_ADDED; } @@ -386,7 +396,7 @@ CdmResponseType CdmSession::GenerateReleaseRequest(CdmKeyMessage* key_request, if (is_offline_) { // Mark license as being released if (!StoreLicense(DeviceFiles::kLicenseStateReleasing)) - return UNKNOWN_ERROR; + return RELEASE_KEY_REQUEST_ERROR; } return KEY_MESSAGE; } @@ -395,7 +405,7 @@ CdmResponseType CdmSession::GenerateReleaseRequest(CdmKeyMessage* key_request, CdmResponseType CdmSession::ReleaseKey(const CdmKeyResponse& key_response) { CdmResponseType sts = license_parser_->HandleKeyUpdateResponse(false, key_response); - if (KEY_ADDED != sts) return sts; + if (KEY_ADDED != sts) return (KEY_ERROR == sts) ? RELEASE_KEY_ERROR : sts; if (is_offline_ || !license_parser_->provider_session_token().empty()) { DeleteLicense(); @@ -443,7 +453,7 @@ CdmResponseType CdmSession::StoreLicense() { if (is_offline_) { if (key_set_id_.empty()) { LOGE("CdmSession::StoreLicense: No key set ID"); - return UNKNOWN_ERROR; + return EMPTY_KEYSET_ID; } if (!StoreLicense(DeviceFiles::kLicenseStateActive)) { @@ -455,7 +465,7 @@ CdmResponseType CdmSession::StoreLicense() { } key_set_id_.clear(); - return UNKNOWN_ERROR; + return STORE_LICENSE_ERROR_1; } return NO_ERROR; } @@ -464,12 +474,12 @@ CdmResponseType CdmSession::StoreLicense() { license_parser_->provider_session_token(); if (provider_session_token.empty()) { LOGE("CdmSession::StoreLicense: No provider session token and not offline"); - return UNKNOWN_ERROR; + return STORE_LICENSE_ERROR_2; } if (!file_handle_->Reset(security_level_)) { LOGE("CdmSession::StoreLicense: Unable to initialize device files"); - return UNKNOWN_ERROR; + return STORE_LICENSE_ERROR_3; } std::string app_id; @@ -477,7 +487,7 @@ CdmResponseType CdmSession::StoreLicense() { if (!file_handle_->StoreUsageInfo(provider_session_token, key_request_, key_response_, app_id)) { LOGE("CdmSession::StoreLicense: Unable to store usage info"); - return UNKNOWN_ERROR; + return STORE_USAGE_INFO_ERROR; } return NO_ERROR; } diff --git a/libwvdrmengine/cdm/core/src/certificate_provisioning.cpp b/libwvdrmengine/cdm/core/src/certificate_provisioning.cpp index 9c41fde0..6779965d 100644 --- a/libwvdrmengine/cdm/core/src/certificate_provisioning.cpp +++ b/libwvdrmengine/cdm/core/src/certificate_provisioning.cpp @@ -53,7 +53,7 @@ void CertificateProvisioning::ComposeJsonRequestAsQueryString( * in *request. It also returns the default url for the provisioning server * in *default_url. * - * Returns NO_ERROR for success and UNKNOWN_ERROR if fails. + * Returns NO_ERROR for success and CERT_PROVISIONING_REQUEST_ERROR_? if fails. */ CdmResponseType CertificateProvisioning::GetProvisioningRequest( SecurityLevel requested_security_level, CdmCertificateType cert_type, @@ -61,7 +61,7 @@ CdmResponseType CertificateProvisioning::GetProvisioningRequest( CdmProvisioningRequest* request, std::string* default_url) { if (!default_url) { LOGE("GetProvisioningRequest: pointer for returning URL is NULL"); - return UNKNOWN_ERROR; + return CERT_PROVISIONING_REQUEST_ERROR_1; } default_url->assign(kProvisioningServerUrl); @@ -79,14 +79,14 @@ CdmResponseType CertificateProvisioning::GetProvisioningRequest( std::string token; if (!crypto_session_.GetToken(&token)) { LOGE("GetProvisioningRequest: fails to get token"); - return UNKNOWN_ERROR; + return CERT_PROVISIONING_GET_KEYBOX_ERROR_1; } client_id->set_token(token); uint32_t nonce; if (!crypto_session_.GenerateNonce(&nonce)) { LOGE("GetProvisioningRequest: fails to generate a nonce"); - return UNKNOWN_ERROR; + return CERT_PROVISIONING_REQUEST_ERROR_2; } // The provisioning server does not convert the nonce to uint32_t, it just @@ -107,7 +107,7 @@ CdmResponseType CertificateProvisioning::GetProvisioningRequest( break; default: LOGE("GetProvisioningRequest: unknown certificate type %ld", cert_type); - return UNKNOWN_ERROR; + return CERT_PROVISIONING_INVALID_CERT_TYPE; } cert_type_ = cert_type; @@ -117,7 +117,7 @@ CdmResponseType CertificateProvisioning::GetProvisioningRequest( std::string device_unique_id; if (!crypto_session_.GetDeviceUniqueId(&device_unique_id)) { LOGE("GetProvisioningRequest: fails to get device unique ID"); - return UNKNOWN_ERROR; + return CERT_PROVISIONING_GET_KEYBOX_ERROR_2; } provisioning_request.set_stable_id(device_unique_id + origin); } @@ -130,11 +130,11 @@ CdmResponseType CertificateProvisioning::GetProvisioningRequest( if (!crypto_session_.PrepareRequest(serialized_message, true, &request_signature)) { LOGE("GetProvisioningRequest: fails to prepare request"); - return UNKNOWN_ERROR; + return CERT_PROVISIONING_REQUEST_ERROR_3; } if (request_signature.empty()) { LOGE("GetProvisioningRequest: request signature is empty"); - return UNKNOWN_ERROR; + return CERT_PROVISIONING_REQUEST_ERROR_4; } SignedProvisioningMessage signed_provisioning_msg; @@ -186,7 +186,7 @@ bool CertificateProvisioning::ParseJsonResponse( * The device RSA key is stored in the T.E.E. The device certificate is stored * in the device. * - * Returns NO_ERROR for success and UNKNOWN_ERROR if fails. + * Returns NO_ERROR for success and CERT_PROVISIONING_RESPONSE_ERROR_? if fails. */ CdmResponseType CertificateProvisioning::HandleProvisioningResponse( const std::string& origin, CdmProvisioningResponse& response, @@ -198,7 +198,7 @@ CdmResponseType CertificateProvisioning::HandleProvisioningResponse( if (!ParseJsonResponse(response, kMessageStart, kMessageEnd, &serialized_signed_response)) { LOGE("Fails to extract signed serialized response from JSON response"); - return UNKNOWN_ERROR; + return CERT_PROVISIONING_RESPONSE_ERROR_1; } // Authenticates provisioning response using D1s (server key derived from @@ -207,7 +207,7 @@ CdmResponseType CertificateProvisioning::HandleProvisioningResponse( SignedProvisioningMessage signed_response; if (!signed_response.ParseFromString(serialized_signed_response)) { LOGE("HandleProvisioningResponse: fails to parse signed response"); - return UNKNOWN_ERROR; + return CERT_PROVISIONING_RESPONSE_ERROR_2; } bool error = false; @@ -221,19 +221,19 @@ CdmResponseType CertificateProvisioning::HandleProvisioningResponse( error = true; } - if (error) return UNKNOWN_ERROR; + if (error) return CERT_PROVISIONING_RESPONSE_ERROR_3; const std::string& signed_message = signed_response.message(); ProvisioningResponse provisioning_response; if (!provisioning_response.ParseFromString(signed_message)) { LOGE("HandleProvisioningResponse: Fails to parse signed message"); - return UNKNOWN_ERROR; + return CERT_PROVISIONING_RESPONSE_ERROR_4; } if (!provisioning_response.has_device_rsa_key()) { LOGE("HandleProvisioningResponse: key not found"); - return UNKNOWN_ERROR; + return CERT_PROVISIONING_RESPONSE_ERROR_5; } const std::string& enc_rsa_key = provisioning_response.device_rsa_key(); @@ -245,7 +245,7 @@ CdmResponseType CertificateProvisioning::HandleProvisioningResponse( enc_rsa_key, rsa_key_iv, &wrapped_rsa_key)) { LOGE("HandleProvisioningResponse: RewrapDeviceRSAKey fails"); - return UNKNOWN_ERROR; + return CERT_PROVISIONING_RESPONSE_ERROR_6; } crypto_session_.Close(); @@ -262,11 +262,11 @@ CdmResponseType CertificateProvisioning::HandleProvisioningResponse( DeviceFiles handle; if (!handle.Init(crypto_session_.GetSecurityLevel())) { LOGE("HandleProvisioningResponse: failed to init DeviceFiles"); - return UNKNOWN_ERROR; + return CERT_PROVISIONING_RESPONSE_ERROR_7; } if (!handle.StoreCertificate(origin, device_certificate, wrapped_rsa_key)) { LOGE("HandleProvisioningResponse: failed to save provisioning certificate"); - return UNKNOWN_ERROR; + return CERT_PROVISIONING_RESPONSE_ERROR_8; } handle.DeleteAllLicenses(); diff --git a/libwvdrmengine/cdm/core/src/crypto_session.cpp b/libwvdrmengine/cdm/core/src/crypto_session.cpp index 846282a6..e5fc002c 100644 --- a/libwvdrmengine/cdm/core/src/crypto_session.cpp +++ b/libwvdrmengine/cdm/core/src/crypto_session.cpp @@ -440,7 +440,7 @@ CdmResponseType CryptoSession::LoadKeys( return INSUFFICIENT_CRYPTO_RESOURCES; } else { LOGE("CryptoSession::LoadKeys: OEMCrypto_LoadKeys error=%d", sts); - return KEY_ERROR; + return LOAD_KEY_ERROR; } } diff --git a/libwvdrmengine/cdm/core/src/license.cpp b/libwvdrmengine/cdm/core/src/license.cpp index 0069e667..df1aa45a 100644 --- a/libwvdrmengine/cdm/core/src/license.cpp +++ b/libwvdrmengine/cdm/core/src/license.cpp @@ -466,15 +466,15 @@ CdmResponseType CdmLicense::PrepareKeyUpdateRequest( bool is_renewal, CdmKeyMessage* signed_request, std::string* server_url) { if (!initialized_) { LOGE("CdmLicense::PrepareKeyUpdateRequest: not initialized"); - return UNKNOWN_ERROR; + return LICENSE_PARSER_NOT_INITIALIZED_1; } if (!signed_request) { LOGE("CdmLicense::PrepareKeyUpdateRequest: No signed request provided"); - return UNKNOWN_ERROR; + return INVALID_PARAMETERS_LIC_1; } if (!server_url) { LOGE("CdmLicense::PrepareKeyUpdateRequest: No server url provided"); - return UNKNOWN_ERROR; + return INVALID_PARAMETERS_LIC_2; } LicenseRequest license_request; @@ -508,7 +508,7 @@ CdmResponseType CdmLicense::PrepareKeyUpdateRequest( if (NO_ERROR == status) current_license->set_session_usage_table_entry(usage_report); else - return KEY_ERROR; + return GENERATE_USAGE_REPORT_ERROR; } } @@ -527,7 +527,7 @@ CdmResponseType CdmLicense::PrepareKeyUpdateRequest( // of the license response. uint32_t nonce; if (!session_->GenerateNonce(&nonce)) { - return KEY_ERROR; + return GENERATE_NONCE_ERROR; } license_request.set_key_control_nonce(nonce); LOGD("PrepareKeyUpdateRequest: nonce=%u", nonce); @@ -541,13 +541,13 @@ CdmResponseType CdmLicense::PrepareKeyUpdateRequest( std::string license_request_signature; if (!session_->PrepareRenewalRequest(serialized_license_req, &license_request_signature)) - return KEY_ERROR; + return RENEWAL_REQUEST_ERROR; if (license_request_signature.empty()) { LOGE( "CdmLicense::PrepareKeyUpdateRequest: empty license request" " signature"); - return KEY_ERROR; + return EMPTY_LICENSE_REQUEST; } // Put serialize license request and signature together @@ -565,11 +565,11 @@ CdmResponseType CdmLicense::HandleKeyResponse( const CdmKeyResponse& license_response) { if (!initialized_) { LOGE("CdmLicense::HandleKeyResponse: not initialized"); - return KEY_ERROR; + return LICENSE_PARSER_NOT_INITIALIZED_2; } if (license_response.empty()) { LOGE("CdmLicense::HandleKeyResponse: empty license response"); - return KEY_ERROR; + return EMPTY_LICENSE_RESPONSE_1; } SignedMessage signed_response; @@ -577,7 +577,7 @@ CdmResponseType CdmLicense::HandleKeyResponse( LOGE( "CdmLicense::HandleKeyResponse: unable to parse signed license" " response"); - return KEY_ERROR; + return INVALID_LICENSE_RESPONSE; } switch (signed_response.type()) { @@ -591,29 +591,29 @@ CdmResponseType CdmLicense::HandleKeyResponse( LOGE( "CdmLicense::HandleKeyResponse: unrecognized signed message type: %d", signed_response.type()); - return KEY_ERROR; + return INVALID_LICENSE_TYPE; } if (!signed_response.has_signature()) { LOGE("CdmLicense::HandleKeyResponse: license response is not signed"); - return KEY_ERROR; + return LICENSE_RESPONSE_NOT_SIGNED; } License license; if (!license.ParseFromString(signed_response.msg())) { LOGE("CdmLicense::HandleKeyResponse: unable to parse license response"); - return KEY_ERROR; + return LICENSE_RESPONSE_PARSE_ERROR_1; } if (Properties::use_certificates_as_identification()) { if (!signed_response.has_session_key()) { LOGE("CdmLicense::HandleKeyResponse: no session keys present"); - return KEY_ERROR; + return SESSION_KEYS_NOT_FOUND; } if (!session_->GenerateDerivedKeys(key_request_, signed_response.session_key())) - return KEY_ERROR; + return GENERATE_DERIVED_KEYS_ERROR; } // Extract mac key @@ -634,14 +634,14 @@ CdmResponseType CdmLicense::HandleKeyResponse( "CdmLicense::HandleKeyResponse: mac key/iv size error" "(key/iv size expected: %d/%d, actual: %d/%d", MAC_KEY_SIZE, KEY_IV_SIZE, mac_key.size(), mac_key_iv.size()); - return KEY_ERROR; + return KEY_SIZE_ERROR; } } std::vector key_array = ExtractContentKeys(license); if (!key_array.size()) { LOGE("CdmLicense::HandleKeyResponse : No content keys."); - return KEY_ERROR; + return NO_CONTENT_KEY; } if (license.id().has_provider_session_token()) @@ -671,17 +671,17 @@ CdmResponseType CdmLicense::HandleKeyUpdateResponse( bool is_renewal, const CdmKeyResponse& license_response) { if (!initialized_) { LOGE("CdmLicense::HandleKeyUpdateResponse: not initialized"); - return KEY_ERROR; + return LICENSE_PARSER_NOT_INITIALIZED_3; } if (license_response.empty()) { LOGE("CdmLicense::HandleKeyUpdateResponse : Empty license response."); - return KEY_ERROR; + return EMPTY_LICENSE_RESPONSE_2; } SignedMessage signed_response; if (!signed_response.ParseFromString(license_response)) { LOGE("CdmLicense::HandleKeyUpdateResponse: Unable to parse signed message"); - return KEY_ERROR; + return LICENSE_RESPONSE_PARSE_ERROR_2; } if (signed_response.type() == SignedMessage::ERROR_RESPONSE) { @@ -690,7 +690,7 @@ CdmResponseType CdmLicense::HandleKeyUpdateResponse( if (!signed_response.has_signature()) { LOGE("CdmLicense::HandleKeyUpdateResponse: signature missing"); - return KEY_ERROR; + return SIGNATURE_NOT_FOUND; } License license; @@ -698,12 +698,12 @@ CdmResponseType CdmLicense::HandleKeyUpdateResponse( LOGE( "CdmLicense::HandleKeyUpdateResponse: Unable to parse license" " from signed message"); - return KEY_ERROR; + return LICENSE_RESPONSE_PARSE_ERROR_3; } if (!license.has_id()) { LOGE("CdmLicense::HandleKeyUpdateResponse: license id not present"); - return KEY_ERROR; + return LICENSE_ID_NOT_FOUND; } policy_engine_->UpdateLicense(license); @@ -729,7 +729,7 @@ CdmResponseType CdmLicense::HandleKeyUpdateResponse( key_array.size(), &key_array[0])) { return KEY_ADDED; } else { - return KEY_ERROR; + return REFRESH_KEYS_ERROR; } } @@ -928,7 +928,7 @@ CdmResponseType CdmLicense::HandleServiceCertificateResponse( LOGE( "CdmLicense::HandleServiceCertificateResponse: unable to parse" "signed device certificate"); - return KEY_ERROR; + return DEVICE_CERTIFICATE_ERROR_1; } RsaPublicKey root_ca_key; @@ -939,7 +939,7 @@ CdmResponseType CdmLicense::HandleServiceCertificateResponse( LOGE( "CdmLicense::HandleServiceCertificateResponse: public key " "initialization failed"); - return KEY_ERROR; + return DEVICE_CERTIFICATE_ERROR_2; } if (!root_ca_key.VerifySignature( @@ -948,7 +948,7 @@ CdmResponseType CdmLicense::HandleServiceCertificateResponse( LOGE( "CdmLicense::HandleServiceCertificateResponse: service " "certificate verification failed"); - return KEY_ERROR; + return DEVICE_CERTIFICATE_ERROR_3; } DeviceCertificate service_certificate; @@ -957,7 +957,7 @@ CdmResponseType CdmLicense::HandleServiceCertificateResponse( LOGE( "CdmLicense::HandleServiceCertificateResponse: unable to parse " "retrieved service certificate"); - return KEY_ERROR; + return DEVICE_CERTIFICATE_ERROR_4; } if (service_certificate.type() != @@ -966,7 +966,7 @@ CdmResponseType CdmLicense::HandleServiceCertificateResponse( "CdmLicense::HandleServiceCertificateResponse: certificate not of type" " service, %d", service_certificate.type()); - return KEY_ERROR; + return INVALID_DEVICE_CERTIFICATE_TYPE; } service_certificate_ = signed_service_certificate.device_certificate(); diff --git a/libwvdrmengine/cdm/core/test/cdm_session_unittest.cpp b/libwvdrmengine/cdm/core/test/cdm_session_unittest.cpp index 1d7e4b91..1e4cd121 100644 --- a/libwvdrmengine/cdm/core/test/cdm_session_unittest.cpp +++ b/libwvdrmengine/cdm/core/test/cdm_session_unittest.cpp @@ -222,7 +222,7 @@ TEST_F(CdmSessionTest, ReInitFail) { Properties::set_use_certificates_as_identification(true); ASSERT_EQ(NO_ERROR, cdm_session_->Init()); - ASSERT_EQ(UNKNOWN_ERROR, cdm_session_->Init()); + ASSERT_NE(NO_ERROR, cdm_session_->Init()); } TEST_F(CdmSessionTest, InitFailCryptoError) { diff --git a/libwvdrmengine/cdm/core/test/test_printers.cpp b/libwvdrmengine/cdm/core/test/test_printers.cpp index b65deb11..7badaff3 100644 --- a/libwvdrmengine/cdm/core/test/test_printers.cpp +++ b/libwvdrmengine/cdm/core/test/test_printers.cpp @@ -8,72 +8,333 @@ namespace wvcdm { void PrintTo(const enum CdmResponseType& value, ::std::ostream* os) { switch (value) { - case NO_ERROR: *os << "NO_ERROR"; + case NO_ERROR: *os << "NO_ERROR"; break; - case UNKNOWN_ERROR: *os << "UNKNOWN_ERROR"; + case UNKNOWN_ERROR: *os << "UNKNOWN_ERROR"; break; - case KEY_ADDED: *os << "KEY_ADDED"; + case KEY_ADDED: *os << "KEY_ADDED"; break; - case KEY_ERROR: *os << "KEY_ERROR"; + case KEY_ERROR: *os << "KEY_ERROR"; break; - case KEY_MESSAGE: *os << "KEY_MESSAGE"; + case KEY_MESSAGE: *os << "KEY_MESSAGE"; break; - case NEED_KEY: *os << "NEED_KEY"; + case NEED_KEY: *os << "NEED_KEY"; break; - case KEY_CANCELED: *os << "KEY_CANCELED"; + case KEY_CANCELED: *os << "KEY_CANCELED"; break; - case NEED_PROVISIONING: *os << "NEED_PROVISIONING"; + case NEED_PROVISIONING: *os << "NEED_PROVISIONING"; break; - case DEVICE_REVOKED: *os << "DEVICE_REVOKED"; + case DEVICE_REVOKED: *os << "DEVICE_REVOKED"; break; - case INSUFFICIENT_CRYPTO_RESOURCES: *os << "INSUFFICIENT_CRYPTO_RESOURCES"; + case INSUFFICIENT_CRYPTO_RESOURCES: *os << "INSUFFICIENT_CRYPTO_RESOURCES"; + break; + case ADD_KEY_ERROR: *os << "ADD_KEY_ERROR"; + break; + case CERT_PROVISIONING_GET_KEYBOX_ERROR_1: *os << "CERT_PROVISIONING_GET_KEYBOX_ERROR_1"; + break; + case CERT_PROVISIONING_GET_KEYBOX_ERROR_2: *os << "CERT_PROVISIONING_GET_KEYBOX_ERROR_2"; + break; + case CERT_PROVISIONING_INVALID_CERT_TYPE: *os << "CERT_PROVISIONING_INVALID_CERT_TYPE"; + break; + case CERT_PROVISIONING_REQUEST_ERROR_1: *os << "CERT_PROVISIONING_REQUEST_ERROR_1"; + break; + case CERT_PROVISIONING_REQUEST_ERROR_2: *os << "CERT_PROVISIONING_REQUEST_ERROR_2"; + break; + case CERT_PROVISIONING_REQUEST_ERROR_3: *os << "CERT_PROVISIONING_REQUEST_ERROR_3"; + break; + case CERT_PROVISIONING_REQUEST_ERROR_4: *os << "CERT_PROVISIONING_REQUEST_ERROR_4"; + break; + case CERT_PROVISIONING_RESPONSE_ERROR_1: *os << "CERT_PROVISIONING_RESPONSE_ERROR_1"; + break; + case CERT_PROVISIONING_RESPONSE_ERROR_2: *os << "CERT_PROVISIONING_RESPONSE_ERROR_2"; + break; + case CERT_PROVISIONING_RESPONSE_ERROR_3: *os << "CERT_PROVISIONING_RESPONSE_ERROR_3"; + break; + case CERT_PROVISIONING_RESPONSE_ERROR_4: *os << "CERT_PROVISIONING_RESPONSE_ERROR_4"; + break; + case CERT_PROVISIONING_RESPONSE_ERROR_5: *os << "CERT_PROVISIONING_RESPONSE_ERROR_5"; + break; + case CERT_PROVISIONING_RESPONSE_ERROR_6: *os << "CERT_PROVISIONING_RESPONSE_ERROR_6"; + break; + case CERT_PROVISIONING_RESPONSE_ERROR_7: *os << "CERT_PROVISIONING_RESPONSE_ERROR_7"; + break; + case CERT_PROVISIONING_RESPONSE_ERROR_8: *os << "CERT_PROVISIONING_RESPONSE_ERROR_8"; + break; + case CRYPTO_SESSION_OPEN_ERROR_1: *os << "CRYPTO_SESSION_OPEN_ERROR_1"; + break; + case CRYPTO_SESSION_OPEN_ERROR_2: *os << "CRYPTO_SESSION_OPEN_ERROR_2"; + break; + case CRYPTO_SESSION_OPEN_ERROR_3: *os << "CRYPTO_SESSION_OPEN_ERROR_3"; + break; + case CRYPTO_SESSION_OPEN_ERROR_4: *os << "CRYPTO_SESSION_OPEN_ERROR_4"; + break; + case CRYPTO_SESSION_OPEN_ERROR_5: *os << "CRYPTO_SESSION_OPEN_ERROR_5"; + break; + case DECRYPT_NOT_READY: *os << "DECRYPT_NOT_READY"; + break; + case DEVICE_CERTIFICATE_ERROR_1: *os << "DEVICE_CERTIFICATE_ERROR_1"; + break; + case DEVICE_CERTIFICATE_ERROR_2: *os << "DEVICE_CERTIFICATE_ERROR_2"; + break; + case DEVICE_CERTIFICATE_ERROR_3: *os << "DEVICE_CERTIFICATE_ERROR_3"; + break; + case DEVICE_CERTIFICATE_ERROR_4: *os << "DEVICE_CERTIFICATE_ERROR_4"; + break; + case EMPTY_KEY_DATA_1: *os << "EMPTY_KEY_DATA_1"; + break; + case EMPTY_KEY_DATA_2: *os << "EMPTY_KEY_DATA_2"; + break; + case EMPTY_KEYSET_ID: *os << "EMPTY_KEYSET_ID"; + break; + case EMPTY_KEYSET_ID_ENG_1: *os << "EMPTY_KEYSET_ID_ENG_1"; + break; + case EMPTY_KEYSET_ID_ENG_2: *os << "EMPTY_KEYSET_ID_ENG_2"; + break; + case EMPTY_KEYSET_ID_ENG_3: *os << "EMPTY_KEYSET_ID_ENG_3"; + break; + case EMPTY_KEYSET_ID_ENG_4: *os << "EMPTY_KEYSET_ID_ENG_4"; + break; + case EMPTY_LICENSE_REQUEST: *os << "EMPTY_LICENSE_REQUEST"; + break; + case EMPTY_LICENSE_RESPONSE_1: *os << "EMPTY_LICENSE_RESPONSE_1"; + break; + case EMPTY_LICENSE_RESPONSE_2: *os << "EMPTY_LICENSE_RESPONSE_2"; + break; + case EMPTY_PROVISIONING_CERTIFICATE: *os << "EMPTY_PROVISIONING_CERTIFICATE"; + break; + case EMPTY_PROVISIONING_RESPONSE: *os << "EMPTY_PROVISIONING_RESPONSE"; + break; + case EMPTY_SESSION_ID: *os << "EMPTY_SESSION_ID"; + break; + case GENERATE_DERIVED_KEYS_ERROR: *os << "GENERATE_DERIVED_KEYS_ERROR"; + break; + case GENERATE_NONCE_ERROR: *os << "GENERATE_NONCE_ERROR"; + break; + case GENERATE_USAGE_REPORT_ERROR: *os << "GENERATE_USAGE_REPORT_ERROR"; + break; + case GET_LICENSE_ERROR: *os << "GET_LICENSE_ERROR"; + break; + case GET_RELEASED_LICENSE_ERROR: *os << "GET_RELEASED_LICENSE_ERROR"; + break; + case GET_USAGE_INFO_ERROR_1: *os << "GET_USAGE_INFO_ERROR_1"; + break; + case GET_USAGE_INFO_ERROR_2: *os << "GET_USAGE_INFO_ERROR_2"; + break; + case GET_USAGE_INFO_ERROR_3: *os << "GET_USAGE_INFO_ERROR_3"; + break; + case GET_USAGE_INFO_ERROR_4: *os << "GET_USAGE_INFO_ERROR_4"; + break; + case INIT_DATA_NOT_FOUND: *os << "INIT_DATA_NOT_FOUND"; + break; + case INVALID_CRYPTO_SESSION_1: *os << "INVALID_CRYPTO_SESSION_1"; + break; + case INVALID_CRYPTO_SESSION_2: *os << "INVALID_CRYPTO_SESSION_2"; + break; + case INVALID_CRYPTO_SESSION_3: *os << "INVALID_CRYPTO_SESSION_3"; + break; + case INVALID_CRYPTO_SESSION_4: *os << "INVALID_CRYPTO_SESSION_4"; + break; + case INVALID_CRYPTO_SESSION_5: *os << "INVALID_CRYPTO_SESSION_5"; + break; + case INVALID_DECRYPT_PARAMETERS_ENG_1: *os << "INVALID_DECRYPT_PARAMETERS_ENG_1"; + break; + case INVALID_DECRYPT_PARAMETERS_ENG_2: *os << "INVALID_DECRYPT_PARAMETERS_ENG_2"; + break; + case INVALID_DECRYPT_PARAMETERS_ENG_3: *os << "INVALID_DECRYPT_PARAMETERS_ENG_3"; + break; + case INVALID_DECRYPT_PARAMETERS_ENG_4: *os << "INVALID_DECRYPT_PARAMETERS_ENG_4"; + break; + case INVALID_DEVICE_CERTIFICATE_TYPE: *os << "INVALID_DEVICE_CERTIFICATE_TYPE"; + break; + case INVALID_KEY_SYSTEM: *os << "INVALID_KEY_SYSTEM"; + break; + case INVALID_LICENSE_RESPONSE: *os << "INVALID_LICENSE_RESPONSE"; + break; + case INVALID_LICENSE_TYPE: *os << "INVALID_LICENSE_TYPE"; + break; + case INVALID_PARAMETERS_ENG_1: *os << "INVALID_PARAMETERS_ENG_1"; + break; + case INVALID_PARAMETERS_ENG_2: *os << "INVALID_PARAMETERS_ENG_2"; + break; + case INVALID_PARAMETERS_ENG_3: *os << "INVALID_PARAMETERS_ENG_3"; + break; + case INVALID_PARAMETERS_ENG_4: *os << "INVALID_PARAMETERS_ENG_4"; + break; + case INVALID_PARAMETERS_LIC_1: *os << "INVALID_PARAMETERS_LIC_1"; + break; + case INVALID_PARAMETERS_LIC_2: *os << "INVALID_PARAMETERS_LIC_2"; + break; + case INVALID_PROVISIONING_PARAMETERS_1: *os << "INVALID_PROVISIONING_PARAMETERS_1"; + break; + case INVALID_PROVISIONING_PARAMETERS_2: *os << "INVALID_PROVISIONING_PARAMETERS_2"; + break; + case INVALID_PROVISIONING_REQUEST_PARAM_1: *os << "INVALID_PROVISIONING_REQUEST_PARAM_1"; + break; + case INVALID_PROVISIONING_REQUEST_PARAM_2: *os << "INVALID_PROVISIONING_REQUEST_PARAM_2"; + break; + case INVALID_QUERY_KEY: *os << "INVALID_QUERY_KEY"; + break; + case INVALID_SESSION_ID: *os << "INVALID_SESSION_ID"; + break; + case KEY_REQUEST_ERROR_1: *os << "KEY_REQUEST_ERROR_1"; + break; + case KEY_REQUEST_ERROR_2: *os << "KEY_REQUEST_ERROR_2"; + break; + case KEY_SIZE_ERROR: *os << "KEY_SIZE_ERROR"; + break; + case KEYSET_ID_NOT_FOUND_1: *os << "KEYSET_ID_NOT_FOUND_1"; + break; + case KEYSET_ID_NOT_FOUND_2: *os << "KEYSET_ID_NOT_FOUND_2"; + break; + case KEYSET_ID_NOT_FOUND_3: *os << "KEYSET_ID_NOT_FOUND_3"; + break; + case LICENSE_ID_NOT_FOUND: *os << "LICENSE_ID_NOT_FOUND"; + break; + case LICENSE_PARSER_INIT_ERROR: *os << "LICENSE_PARSER_INIT_ERROR"; + break; + case LICENSE_PARSER_NOT_INITIALIZED_1: *os << "LICENSE_PARSER_NOT_INITIALIZED_1"; + break; + case LICENSE_PARSER_NOT_INITIALIZED_2: *os << "LICENSE_PARSER_NOT_INITIALIZED_2"; + break; + case LICENSE_PARSER_NOT_INITIALIZED_3: *os << "LICENSE_PARSER_NOT_INITIALIZED_3"; + break; + case LICENSE_RESPONSE_NOT_SIGNED: *os << "LICENSE_RESPONSE_NOT_SIGNED"; + break; + break; + case LICENSE_RESPONSE_PARSE_ERROR_1: *os << "LICENSE_RESPONSE_PARSE_ERROR_1"; + break; + case LICENSE_RESPONSE_PARSE_ERROR_2: *os << "LICENSE_RESPONSE_PARSE_ERROR_2"; + break; + case LICENSE_RESPONSE_PARSE_ERROR_3: *os << "LICENSE_RESPONSE_PARSE_ERROR_3"; + break; + case LOAD_KEY_ERROR: *os << "LOAD_KEY_ERROR"; + break; + case NO_CONTENT_KEY: *os << "NO_CONTENT_KEY"; + break; + case REFRESH_KEYS_ERROR: *os << "REFRESH_KEYS_ERROR"; + break; + case RELEASE_ALL_USAGE_INFO_ERROR_1: *os << "RELEASE_ALL_USAGE_INFO_ERROR_1"; + break; + case RELEASE_ALL_USAGE_INFO_ERROR_2: *os << "RELEASE_ALL_USAGE_INFO_ERROR_2"; + break; + case RELEASE_KEY_ERROR: *os << "RELEASE_KEY_ERROR"; + break; + case RELEASE_KEY_REQUEST_ERROR: *os << "RELEASE_KEY_REQUEST_ERROR"; + break; + case RELEASE_LICENSE_ERROR_1: *os << "RELEASE_LICENSE_ERROR_1"; + break; + case RELEASE_LICENSE_ERROR_2: *os << "RELEASE_LICENSE_ERROR_2"; + break; + case RELEASE_USAGE_INFO_ERROR: *os << "RELEASE_USAGE_INFO_ERROR"; + break; + case RENEW_KEY_ERROR_1: *os << "RENEW_KEY_ERROR_1"; + break; + case RENEW_KEY_ERROR_2: *os << "RENEW_KEY_ERROR_2"; + break; + case RENEWAL_REQUEST_ERROR: *os << "RENEWAL_REQUEST_ERROR"; + break; + case RESTORE_OFFLINE_LICENSE_ERROR_1: *os << "RESTORE_OFFLINE_LICENSE_ERROR_1"; + break; + case RESTORE_OFFLINE_LICENSE_ERROR_2: *os << "RESTORE_OFFLINE_LICENSE_ERROR_2"; + break; + case SESSION_INIT_ERROR_1: *os << "SESSION_INIT_ERROR_1"; + break; + case SESSION_INIT_ERROR_2: *os << "SESSION_INIT_ERROR_2"; + break; + case SESSION_INIT_GET_KEYBOX_ERROR: *os << "SESSION_INIT_GET_KEYBOX_ERROR"; + break; + case SESSION_NOT_FOUND_1: *os << "SESSION_NOT_FOUND_1"; + break; + case SESSION_NOT_FOUND_2: *os << "SESSION_NOT_FOUND_2"; + break; + case SESSION_NOT_FOUND_3: *os << "SESSION_NOT_FOUND_3"; + break; + case SESSION_NOT_FOUND_4: *os << "SESSION_NOT_FOUND_4"; + break; + case SESSION_NOT_FOUND_5: *os << "SESSION_NOT_FOUND_5"; + break; + case SESSION_NOT_FOUND_6: *os << "SESSION_NOT_FOUND_6"; + break; + case SESSION_NOT_FOUND_7: *os << "SESSION_NOT_FOUND_7"; + break; + case SESSION_NOT_FOUND_8: *os << "SESSION_NOT_FOUND_8"; + break; + case SESSION_NOT_FOUND_9: *os << "SESSION_NOT_FOUND_9"; + break; + case SESSION_NOT_FOUND_10: *os << "SESSION_NOT_FOUND_10"; + break; + case SESSION_NOT_FOUND_FOR_DECRYPT: *os << "SESSION_NOT_FOUND_FOR_DECRYPT"; + break; + case SESSION_KEYS_NOT_FOUND: *os << "SESSION_KEYS_NOT_FOUND"; + break; + case SIGNATURE_NOT_FOUND: *os << "SIGNATURE_NOT_FOUND"; + break; + case STORE_LICENSE_ERROR_1: *os << "STORE_LICENSE_ERROR_1"; + break; + case STORE_LICENSE_ERROR_2: *os << "STORE_LICENSE_ERROR_2"; + break; + case STORE_LICENSE_ERROR_3: *os << "STORE_LICENSE_ERROR_3"; + break; + case STORE_USAGE_INFO_ERROR: *os << "STORE_USAGE_INFO_ERROR"; + break; + case UNPROVISION_ERROR_1: *os << "UNPROVISION_ERROR_1"; + break; + case UNPROVISION_ERROR_2: *os << "UNPROVISION_ERROR_2"; + break; + case UNPROVISION_ERROR_3: *os << "UNPROVISION_ERROR_3"; + break; + case UNPROVISION_ERROR_4: *os << "UNPROVISION_ERROR_4"; + break; + case UNSUPPORTED_INIT_DATA: *os << "UNSUPPORTED_INIT_DATA"; + break; + case USAGE_INFO_NOT_FOUND: *os << "USAGE_INFO_NOT_FOUND"; break; default: - *os << "Unknown CdmResponseType"; + *os << "Unknown CdmResponseType"; break; } } void PrintTo(const enum CdmLicenseType& value, ::std::ostream* os) { switch (value) { - case kLicenseTypeOffline: *os << "kLicenseTypeOffline"; + case kLicenseTypeOffline: *os << "kLicenseTypeOffline"; break; - case kLicenseTypeStreaming: *os << "kLicenseTypeStreaming"; + case kLicenseTypeStreaming: *os << "kLicenseTypeStreaming"; break; - case kLicenseTypeRelease: *os << "kLicenseTypeRelease"; + case kLicenseTypeRelease: *os << "kLicenseTypeRelease"; break; default: - *os << "Unknown CdmLicenseType"; + *os << "Unknown CdmLicenseType"; break; } }; void PrintTo(const enum CdmSecurityLevel& value, ::std::ostream* os) { switch (value) { - case kSecurityLevelUninitialized: *os << "kSecurityLevelUninitialized"; + case kSecurityLevelUninitialized: *os << "kSecurityLevelUninitialized"; break; - case kSecurityLevelL1: *os << "kSecurityLevelL1"; + case kSecurityLevelL1: *os << "kSecurityLevelL1"; break; - case kSecurityLevelL2: *os << "kSecurityLevelL2"; + case kSecurityLevelL2: *os << "kSecurityLevelL2"; break; - case kSecurityLevelL3: *os << "kSecurityLevelL3"; + case kSecurityLevelL3: *os << "kSecurityLevelL3"; break; - case kSecurityLevelUnknown: *os << "kSecurityLevelUnknown"; + case kSecurityLevelUnknown: *os << "kSecurityLevelUnknown"; break; default: - *os << "Unknown CdmSecurityLevel"; + *os << "Unknown CdmSecurityLevel"; break; } }; void PrintTo(const enum CdmCertificateType& value, ::std::ostream* os) { switch (value) { - case kCertificateWidevine: *os << "kCertificateWidevine"; + case kCertificateWidevine: *os << "kCertificateWidevine"; break; - case kCertificateX509: *os << "kCertificateX509"; + case kCertificateX509: *os << "kCertificateX509"; break; default: - *os << "Unknown CdmCertificateType"; + *os << "Unknown CdmCertificateType"; break; } }; diff --git a/libwvdrmengine/cdm/test/request_license_test.cpp b/libwvdrmengine/cdm/test/request_license_test.cpp index 37779787..2fb2207c 100644 --- a/libwvdrmengine/cdm/test/request_license_test.cpp +++ b/libwvdrmengine/cdm/test/request_license_test.cpp @@ -790,7 +790,7 @@ TEST_F(WvCdmRequestLicenseTest, ProvisioningRetryTest) { response = GetCertRequestResponse(g_config->provisioning_server_url()); EXPECT_NE(0, static_cast(response.size())); - EXPECT_EQ(wvcdm::UNKNOWN_ERROR, + EXPECT_EQ(wvcdm::EMPTY_PROVISIONING_CERTIFICATE, decryptor_.HandleProvisioningResponse(EMPTY_ORIGIN, response, &cert, &wrapped_key)); EXPECT_EQ(0, static_cast(cert.size())); @@ -1095,7 +1095,8 @@ TEST_F(WvCdmRequestLicenseTest, ReleaseRetryOfflineKeyTest) { session_id_.clear(); decryptor_.OpenSession(g_key_system, NULL, EMPTY_ORIGIN, NULL, &session_id_); - EXPECT_EQ(wvcdm::UNKNOWN_ERROR, decryptor_.RestoreKey(session_id_, key_set_id)); + EXPECT_EQ(wvcdm::GET_RELEASED_LICENSE_ERROR, + decryptor_.RestoreKey(session_id_, key_set_id)); decryptor_.CloseSession(session_id_); session_id_.clear(); @@ -1164,8 +1165,8 @@ TEST_F(WvCdmRequestLicenseTest, ReleaseRetryL3OfflineKeyTest) { session_id_.clear(); decryptor_.OpenSession(g_key_system, &property_set, EMPTY_ORIGIN, NULL, &session_id_); - EXPECT_EQ( - wvcdm::UNKNOWN_ERROR, decryptor_.RestoreKey(session_id_, key_set_id)); + EXPECT_EQ(wvcdm::GET_RELEASED_LICENSE_ERROR, + decryptor_.RestoreKey(session_id_, key_set_id)); decryptor_.CloseSession(session_id_); session_id_.clear(); diff --git a/libwvdrmengine/include/WVErrors.h b/libwvdrmengine/include/WVErrors.h index b05b2720..5f889f2b 100644 --- a/libwvdrmengine/include/WVErrors.h +++ b/libwvdrmengine/include/WVErrors.h @@ -13,18 +13,149 @@ using android::ERROR_DRM_VENDOR_MIN; using android::ERROR_DRM_VENDOR_MAX; enum { - kErrorIncorrectBufferSize = ERROR_DRM_VENDOR_MIN, - kErrorCDMGeneric = ERROR_DRM_VENDOR_MIN + 1, - kErrorUnsupportedCrypto = ERROR_DRM_VENDOR_MIN + 2, - kErrorExpectedUnencrypted = ERROR_DRM_VENDOR_MIN + 3, - kErrorSessionIsOpen = ERROR_DRM_VENDOR_MIN + 4, - kErrorTooManySessions = ERROR_DRM_VENDOR_MIN + 5, - kErrorInvalidKey = ERROR_DRM_VENDOR_MIN + 6, - kErrorNoOriginSpecified = ERROR_DRM_VENDOR_MIN + 7, - kErrorWVDrmMaxErrorUsed = ERROR_DRM_VENDOR_MIN + 7, + kErrorIncorrectBufferSize = ERROR_DRM_VENDOR_MIN, + kErrorCDMGeneric = ERROR_DRM_VENDOR_MIN + 1, + kErrorUnsupportedCrypto = ERROR_DRM_VENDOR_MIN + 2, + kErrorExpectedUnencrypted = ERROR_DRM_VENDOR_MIN + 3, + kErrorSessionIsOpen = ERROR_DRM_VENDOR_MIN + 4, + kErrorTooManySessions = ERROR_DRM_VENDOR_MIN + 5, + kErrorInvalidKey = ERROR_DRM_VENDOR_MIN + 6, + kErrorNoOriginSpecified = ERROR_DRM_VENDOR_MIN + 7, + kAddKeyError = ERROR_DRM_VENDOR_MIN + 8, + kCertProvisioningGetKeyboxError1 = ERROR_DRM_VENDOR_MIN + 9, + kCertProvisioningGetKeyboxError2 = ERROR_DRM_VENDOR_MIN + 10, + kCertProvisioningInvalidCertType = ERROR_DRM_VENDOR_MIN + 11, + kCertProvisioningRequestError1 = ERROR_DRM_VENDOR_MIN + 12, + kCertProvisioningRequestError2 = ERROR_DRM_VENDOR_MIN + 13, + kCertProvisioningRequestError3 = ERROR_DRM_VENDOR_MIN + 14, + kCertProvisioningRequestError4 = ERROR_DRM_VENDOR_MIN + 15, + kCertProvisioningResponseError1 = ERROR_DRM_VENDOR_MIN + 16, + kCertProvisioningResponseError2 = ERROR_DRM_VENDOR_MIN + 17, + kCertProvisioningResponseError3 = ERROR_DRM_VENDOR_MIN + 18, + kCertProvisioningResponseError4 = ERROR_DRM_VENDOR_MIN + 19, + kCertProvisioningResponseError5 = ERROR_DRM_VENDOR_MIN + 20, + kCertProvisioningResponseError6 = ERROR_DRM_VENDOR_MIN + 21, + kCertProvisioningResponseError7 = ERROR_DRM_VENDOR_MIN + 22, + kCertProvisioningResponseError8 = ERROR_DRM_VENDOR_MIN + 23, + kCryptoSessionOpenError1 = ERROR_DRM_VENDOR_MIN + 24, + kCryptoSessionOpenError2 = ERROR_DRM_VENDOR_MIN + 25, + kCryptoSessionOpenError3 = ERROR_DRM_VENDOR_MIN + 26, + kCryptoSessionOpenError4 = ERROR_DRM_VENDOR_MIN + 27, + kCryptoSessionOpenError5 = ERROR_DRM_VENDOR_MIN + 28, + kDecyrptNotReady = ERROR_DRM_VENDOR_MIN + 29, + kDeviceCertificateError1 = ERROR_DRM_VENDOR_MIN + 30, + kDeviceCertificateError2 = ERROR_DRM_VENDOR_MIN + 31, + kDeviceCertificateError3 = ERROR_DRM_VENDOR_MIN + 32, + kDeviceCertificateError4 = ERROR_DRM_VENDOR_MIN + 33, + kEmptyKeyData1 = ERROR_DRM_VENDOR_MIN + 34, + kEmptyKeyData2 = ERROR_DRM_VENDOR_MIN + 35, + kEmptyKeySetId = ERROR_DRM_VENDOR_MIN + 36, + kEmptyKeySetIdEng1 = ERROR_DRM_VENDOR_MIN + 37, + kEmptyKeySetIdEng2 = ERROR_DRM_VENDOR_MIN + 38, + kEmptyKeySetIdEng3 = ERROR_DRM_VENDOR_MIN + 39, + kEmptyKeySetIdEng4 = ERROR_DRM_VENDOR_MIN + 40, + kEmptyLicenseRequest = ERROR_DRM_VENDOR_MIN + 41, + kEmptyLicenseResponse1 = ERROR_DRM_VENDOR_MIN + 42, + kEmptyLicenseResponse2 = ERROR_DRM_VENDOR_MIN + 43, + kEmptyProvisioningCertificate = ERROR_DRM_VENDOR_MIN + 44, + kEmptyProvisioningResponse = ERROR_DRM_VENDOR_MIN + 45, + kEmptySessionId = ERROR_DRM_VENDOR_MIN + 46, + kGenerateDerivedKeysError = ERROR_DRM_VENDOR_MIN + 47, + kGenerateNonceError = ERROR_DRM_VENDOR_MIN + 48, + kGenerateUsageReportError = ERROR_DRM_VENDOR_MIN + 49, + kGetLicenseError = ERROR_DRM_VENDOR_MIN + 50, + kGetReleasedLicenseError = ERROR_DRM_VENDOR_MIN + 51, + kGetUsageInfoError1 = ERROR_DRM_VENDOR_MIN + 52, + kGetUsageInfoError2 = ERROR_DRM_VENDOR_MIN + 53, + kGetUsageInfoError3 = ERROR_DRM_VENDOR_MIN + 54, + kGetUsageInfoError4 = ERROR_DRM_VENDOR_MIN + 55, + kInitDataNotFound = ERROR_DRM_VENDOR_MIN + 56, + kInvalidCryptoSession1 = ERROR_DRM_VENDOR_MIN + 57, + kInvalidCryptoSession2 = ERROR_DRM_VENDOR_MIN + 58, + kInvalidCryptoSession3 = ERROR_DRM_VENDOR_MIN + 59, + kInvalidCryptoSession4 = ERROR_DRM_VENDOR_MIN + 60, + kInvalidCryptoSession5 = ERROR_DRM_VENDOR_MIN + 61, + kInvalidDecryptParametersEng1 = ERROR_DRM_VENDOR_MIN + 62, + kInvalidDecryptParametersEng2 = ERROR_DRM_VENDOR_MIN + 63, + kInvalidDecryptParametersEng3 = ERROR_DRM_VENDOR_MIN + 64, + kInvalidDecryptParametersEng4 = ERROR_DRM_VENDOR_MIN + 65, + kInvalidDeviceCertificateType = ERROR_DRM_VENDOR_MIN + 66, + kInvalidKeySystem = ERROR_DRM_VENDOR_MIN + 67, + kInvalidLicenseResponse = ERROR_DRM_VENDOR_MIN + 68, + kInvalidLicenseType = ERROR_DRM_VENDOR_MIN + 69, + kInvalidParametersEng1 = ERROR_DRM_VENDOR_MIN + 70, + kInvalidParametersEng2 = ERROR_DRM_VENDOR_MIN + 71, + kInvalidParametersEng3 = ERROR_DRM_VENDOR_MIN + 72, + kInvalidParametersEng4 = ERROR_DRM_VENDOR_MIN + 73, + kInvalidParametersLic1 = ERROR_DRM_VENDOR_MIN + 74, + kInvalidParametersLic2 = ERROR_DRM_VENDOR_MIN + 75, + kInvalidProvisioningParam1 = ERROR_DRM_VENDOR_MIN + 76, + kInvalidProvisioningParam2 = ERROR_DRM_VENDOR_MIN + 77, + kInvalidProvisioningReqParam1 = ERROR_DRM_VENDOR_MIN + 78, + kInvalidProvisioningReqParam2 = ERROR_DRM_VENDOR_MIN + 79, + kInvalidQueryKey = ERROR_DRM_VENDOR_MIN + 80, + kInvalidSessionId = ERROR_DRM_VENDOR_MIN + 81, + kKeyRequestError1 = ERROR_DRM_VENDOR_MIN + 82, + kKeyRequestError2 = ERROR_DRM_VENDOR_MIN + 83, + kKeySizeError = ERROR_DRM_VENDOR_MIN + 84, + kKeySetIdNotFound1 = ERROR_DRM_VENDOR_MIN + 85, + kKeySetIdNotFound2 = ERROR_DRM_VENDOR_MIN + 86, + kKeySetIdNotFound3 = ERROR_DRM_VENDOR_MIN + 87, + kLicenseIdNotFound = ERROR_DRM_VENDOR_MIN + 88, + kLicenseParserInitError = ERROR_DRM_VENDOR_MIN + 89, + kLicenseParserNotInitialized1 = ERROR_DRM_VENDOR_MIN + 90, + kLicenseParserNotInitialized2 = ERROR_DRM_VENDOR_MIN + 91, + kLicenseParserNotInitialized3 = ERROR_DRM_VENDOR_MIN + 92, + kLicenseResponseNotSigned = ERROR_DRM_VENDOR_MIN + 93, + kLicenseResponseParseError1 = ERROR_DRM_VENDOR_MIN + 94, + kLicenseResponseParseError2 = ERROR_DRM_VENDOR_MIN + 95, + kLicenseResponseParseError3 = ERROR_DRM_VENDOR_MIN + 96, + kLoadKeyError = ERROR_DRM_VENDOR_MIN + 97, + kNoContentKey = ERROR_DRM_VENDOR_MIN + 98, + kProvisioningGetKeyboxError = ERROR_DRM_VENDOR_MIN + 99, + kRefreshKeysError = ERROR_DRM_VENDOR_MIN + 100, + kReleaseAllUsageInfoError1 = ERROR_DRM_VENDOR_MIN + 101, + kReleaseAllUsageInfoError2 = ERROR_DRM_VENDOR_MIN + 102, + kReleaseKeyError = ERROR_DRM_VENDOR_MIN + 103, + kReleaseKeyRequestError = ERROR_DRM_VENDOR_MIN + 104, + kReleaseLicenseError1 = ERROR_DRM_VENDOR_MIN + 105, + kReleaseLicenseError2 = ERROR_DRM_VENDOR_MIN + 106, + kReleaseUsageInfoError = ERROR_DRM_VENDOR_MIN + 107, + kRenewKeyError1 = ERROR_DRM_VENDOR_MIN + 108, + kRenewKeyError2 = ERROR_DRM_VENDOR_MIN + 109, + kRenewalRequestError = ERROR_DRM_VENDOR_MIN + 110, + kRestoreOfflineLicenseError1 = ERROR_DRM_VENDOR_MIN + 111, + kRestoreOfflineLicenseError2 = ERROR_DRM_VENDOR_MIN + 112, + kSessionInitError1 = ERROR_DRM_VENDOR_MIN + 113, + kSessionInitError2 = ERROR_DRM_VENDOR_MIN + 114, + kSessionInitGetKeyboxError = ERROR_DRM_VENDOR_MIN + 115, + kSessionNotFound1 = ERROR_DRM_VENDOR_MIN + 116, + kSessionNotFound2 = ERROR_DRM_VENDOR_MIN + 117, + kSessionNotFound3 = ERROR_DRM_VENDOR_MIN + 118, + kSessionNotFound4 = ERROR_DRM_VENDOR_MIN + 119, + kSessionNotFound5 = ERROR_DRM_VENDOR_MIN + 120, + kSessionNotFound6 = ERROR_DRM_VENDOR_MIN + 121, + kSessionNotFound7 = ERROR_DRM_VENDOR_MIN + 122, + kSessionNotFound8 = ERROR_DRM_VENDOR_MIN + 123, + kSessionNotFound9 = ERROR_DRM_VENDOR_MIN + 124, + kSessionNotFound10 = ERROR_DRM_VENDOR_MIN + 125, + kSessionKeysNotFound = ERROR_DRM_VENDOR_MIN + 126, + kSessionNotFoundForDecrypt = ERROR_DRM_VENDOR_MIN + 127, + kSignatureNotFound = ERROR_DRM_VENDOR_MIN + 128, + kStoreLicenseError1 = ERROR_DRM_VENDOR_MIN + 129, + kStoreLicenseError2 = ERROR_DRM_VENDOR_MIN + 130, + kStoreLicenseError3 = ERROR_DRM_VENDOR_MIN + 131, + kStoreUsageInfoError = ERROR_DRM_VENDOR_MIN + 132, + kUnprovisioningError1 = ERROR_DRM_VENDOR_MIN + 133, + kUnprovisioningError2 = ERROR_DRM_VENDOR_MIN + 134, + kUnprovisioningError3 = ERROR_DRM_VENDOR_MIN + 135, + kUnprovisioningError4 = ERROR_DRM_VENDOR_MIN + 136, + kUnsupportedInitData = ERROR_DRM_VENDOR_MIN + 137, + kUsageInfoNotFound = ERROR_DRM_VENDOR_MIN + 138, + kErrorWVDrmMaxErrorUsed = ERROR_DRM_VENDOR_MIN + 138, // Used by crypto test mode - kErrorTestMode = ERROR_DRM_VENDOR_MAX, + kErrorTestMode = ERROR_DRM_VENDOR_MAX, }; static_assert(static_cast(kErrorWVDrmMaxErrorUsed) <= diff --git a/libwvdrmengine/include/mapErrors-inl.h b/libwvdrmengine/include/mapErrors-inl.h index 9c0084ef..491affb3 100644 --- a/libwvdrmengine/include/mapErrors-inl.h +++ b/libwvdrmengine/include/mapErrors-inl.h @@ -29,6 +29,266 @@ static android::status_t mapCdmResponseType(wvcdm::CdmResponseType res) { return android::ERROR_DRM_DEVICE_REVOKED; case wvcdm::INSUFFICIENT_CRYPTO_RESOURCES: return android::ERROR_DRM_RESOURCE_BUSY; + case wvcdm::ADD_KEY_ERROR: + return kAddKeyError; + case wvcdm::CERT_PROVISIONING_GET_KEYBOX_ERROR_1: + return kCertProvisioningGetKeyboxError1; + case wvcdm::CERT_PROVISIONING_GET_KEYBOX_ERROR_2: + return kCertProvisioningGetKeyboxError2; + case wvcdm::CERT_PROVISIONING_INVALID_CERT_TYPE: + return kCertProvisioningInvalidCertType; + case wvcdm::CERT_PROVISIONING_REQUEST_ERROR_1: + return kCertProvisioningRequestError1; + case wvcdm::CERT_PROVISIONING_REQUEST_ERROR_2: + return kCertProvisioningRequestError2; + case wvcdm::CERT_PROVISIONING_REQUEST_ERROR_3: + return kCertProvisioningRequestError3; + case wvcdm::CERT_PROVISIONING_REQUEST_ERROR_4: + return kCertProvisioningRequestError4; + case wvcdm::CERT_PROVISIONING_RESPONSE_ERROR_1: + return kCertProvisioningResponseError1; + case wvcdm::CERT_PROVISIONING_RESPONSE_ERROR_2: + return kCertProvisioningResponseError2; + case wvcdm::CERT_PROVISIONING_RESPONSE_ERROR_3: + return kCertProvisioningResponseError3; + case wvcdm::CERT_PROVISIONING_RESPONSE_ERROR_4: + return kCertProvisioningResponseError4; + case wvcdm::CERT_PROVISIONING_RESPONSE_ERROR_5: + return kCertProvisioningResponseError5; + case wvcdm::CERT_PROVISIONING_RESPONSE_ERROR_6: + return kCertProvisioningResponseError6; + case wvcdm::CERT_PROVISIONING_RESPONSE_ERROR_7: + return kCertProvisioningResponseError7; + case wvcdm::CERT_PROVISIONING_RESPONSE_ERROR_8: + return kCertProvisioningResponseError8; + case wvcdm::CRYPTO_SESSION_OPEN_ERROR_1: + return kCryptoSessionOpenError1; + case wvcdm::CRYPTO_SESSION_OPEN_ERROR_2: + return kCryptoSessionOpenError2; + case wvcdm::CRYPTO_SESSION_OPEN_ERROR_3: + return kCryptoSessionOpenError3; + case wvcdm::CRYPTO_SESSION_OPEN_ERROR_4: + return kCryptoSessionOpenError4; + case wvcdm::CRYPTO_SESSION_OPEN_ERROR_5: + return kCryptoSessionOpenError5; + case wvcdm::DECRYPT_NOT_READY: + return kDecyrptNotReady; + case wvcdm::DEVICE_CERTIFICATE_ERROR_1: + return kDeviceCertificateError1; + case wvcdm::DEVICE_CERTIFICATE_ERROR_2: + return kDeviceCertificateError2; + case wvcdm::DEVICE_CERTIFICATE_ERROR_3: + return kDeviceCertificateError3; + case wvcdm::DEVICE_CERTIFICATE_ERROR_4: + return kDeviceCertificateError4; + case wvcdm::EMPTY_KEY_DATA_1: + return kEmptyKeyData1; + case wvcdm::EMPTY_KEY_DATA_2: + return kEmptyKeyData2; + case wvcdm::EMPTY_KEYSET_ID: + return kEmptyKeySetId; + case wvcdm::EMPTY_KEYSET_ID_ENG_1: + return kEmptyKeySetIdEng1; + case wvcdm::EMPTY_KEYSET_ID_ENG_2: + return kEmptyKeySetIdEng2; + case wvcdm::EMPTY_KEYSET_ID_ENG_3: + return kEmptyKeySetIdEng3; + case wvcdm::EMPTY_KEYSET_ID_ENG_4: + return kEmptyKeySetIdEng4; + case wvcdm::EMPTY_LICENSE_REQUEST: + return kEmptyLicenseRequest; + case wvcdm::EMPTY_LICENSE_RESPONSE_1: + return kEmptyLicenseResponse1; + case wvcdm::EMPTY_LICENSE_RESPONSE_2: + return kEmptyLicenseResponse2; + case wvcdm::EMPTY_PROVISIONING_CERTIFICATE: + return kEmptyProvisioningCertificate; + case wvcdm::EMPTY_PROVISIONING_RESPONSE: + return kEmptyProvisioningResponse; + case wvcdm::EMPTY_SESSION_ID: + return kEmptySessionId; + case wvcdm::GENERATE_DERIVED_KEYS_ERROR: + return kGenerateDerivedKeysError; + case wvcdm::GENERATE_NONCE_ERROR: + return kGenerateNonceError; + case wvcdm::GENERATE_USAGE_REPORT_ERROR: + return kGenerateUsageReportError; + case wvcdm::GET_LICENSE_ERROR: + return kGetLicenseError; + case wvcdm::GET_RELEASED_LICENSE_ERROR: + return kGetReleasedLicenseError; + case wvcdm::GET_USAGE_INFO_ERROR_1: + return kGetUsageInfoError1; + case wvcdm::GET_USAGE_INFO_ERROR_2: + return kGetUsageInfoError2; + case wvcdm::GET_USAGE_INFO_ERROR_3: + return kGetUsageInfoError3; + case wvcdm::GET_USAGE_INFO_ERROR_4: + return kGetUsageInfoError4; + case wvcdm::INIT_DATA_NOT_FOUND: + return kInitDataNotFound; + case wvcdm::INVALID_CRYPTO_SESSION_1: + return kInvalidCryptoSession1; + case wvcdm::INVALID_CRYPTO_SESSION_2: + return kInvalidCryptoSession2; + case wvcdm::INVALID_CRYPTO_SESSION_3: + return kInvalidCryptoSession3; + case wvcdm::INVALID_CRYPTO_SESSION_4: + return kInvalidCryptoSession4; + case wvcdm::INVALID_CRYPTO_SESSION_5: + return kInvalidCryptoSession5; + case wvcdm::INVALID_DECRYPT_PARAMETERS_ENG_1: + return kInvalidDecryptParametersEng1; + case wvcdm::INVALID_DECRYPT_PARAMETERS_ENG_2: + return kInvalidDecryptParametersEng2; + case wvcdm::INVALID_DECRYPT_PARAMETERS_ENG_3: + return kInvalidDecryptParametersEng3; + case wvcdm::INVALID_DECRYPT_PARAMETERS_ENG_4: + return kInvalidDecryptParametersEng4; + case wvcdm::SESSION_NOT_FOUND_FOR_DECRYPT: + return kSessionNotFoundForDecrypt; + case wvcdm::INVALID_DEVICE_CERTIFICATE_TYPE: + return kInvalidDeviceCertificateType; + case wvcdm::INVALID_KEY_SYSTEM: + return kInvalidKeySystem; + case wvcdm::INVALID_LICENSE_RESPONSE: + return kInvalidLicenseResponse; + case wvcdm::INVALID_LICENSE_TYPE: + return kInvalidLicenseType; + case wvcdm::INVALID_PARAMETERS_ENG_1: + return kInvalidParametersEng1; + case wvcdm::INVALID_PARAMETERS_ENG_2: + return kInvalidParametersEng2; + case wvcdm::INVALID_PARAMETERS_ENG_3: + return kInvalidParametersEng3; + case wvcdm::INVALID_PARAMETERS_ENG_4: + return kInvalidParametersEng4; + case wvcdm::INVALID_PARAMETERS_LIC_1: + return kInvalidParametersLic1; + case wvcdm::INVALID_PARAMETERS_LIC_2: + return kInvalidParametersLic2; + case wvcdm::INVALID_PROVISIONING_PARAMETERS_1: + return kInvalidProvisioningParam1; + case wvcdm::INVALID_PROVISIONING_PARAMETERS_2: + return kInvalidProvisioningParam2; + case wvcdm::INVALID_PROVISIONING_REQUEST_PARAM_1: + return kInvalidProvisioningReqParam1; + case wvcdm::INVALID_PROVISIONING_REQUEST_PARAM_2: + return kInvalidProvisioningReqParam2; + case wvcdm::INVALID_QUERY_KEY: + return kInvalidQueryKey; + case wvcdm::INVALID_SESSION_ID: + return kInvalidSessionId; + case wvcdm::KEY_REQUEST_ERROR_1: + return kKeyRequestError1; + case wvcdm::KEY_REQUEST_ERROR_2: + return kKeyRequestError2; + case wvcdm::KEY_SIZE_ERROR: + return kKeySizeError; + case wvcdm::KEYSET_ID_NOT_FOUND_1: + return kKeySetIdNotFound1; + case wvcdm::KEYSET_ID_NOT_FOUND_2: + return kKeySetIdNotFound2; + case wvcdm::KEYSET_ID_NOT_FOUND_3: + return kKeySetIdNotFound3; + case wvcdm::LICENSE_ID_NOT_FOUND: + return kLicenseIdNotFound; + case wvcdm::LICENSE_PARSER_INIT_ERROR: + return kLicenseParserInitError; + case wvcdm::LICENSE_PARSER_NOT_INITIALIZED_1: + return kLicenseParserNotInitialized1; + case wvcdm::LICENSE_PARSER_NOT_INITIALIZED_2: + return kLicenseParserNotInitialized2; + case wvcdm::LICENSE_PARSER_NOT_INITIALIZED_3: + return kLicenseParserNotInitialized3; + case wvcdm::LICENSE_RESPONSE_NOT_SIGNED: + return kLicenseResponseNotSigned; + case wvcdm::LICENSE_RESPONSE_PARSE_ERROR_1: + return kLicenseResponseParseError1; + case wvcdm::LICENSE_RESPONSE_PARSE_ERROR_2: + return kLicenseResponseParseError2; + case wvcdm::LICENSE_RESPONSE_PARSE_ERROR_3: + return kLicenseResponseParseError3; + case wvcdm::LOAD_KEY_ERROR: + return kLoadKeyError; + case wvcdm::NO_CONTENT_KEY: + return kNoContentKey; + case wvcdm::REFRESH_KEYS_ERROR: + return kRefreshKeysError; + case wvcdm::RELEASE_ALL_USAGE_INFO_ERROR_1: + return kReleaseAllUsageInfoError1; + case wvcdm::RELEASE_ALL_USAGE_INFO_ERROR_2: + return kReleaseAllUsageInfoError2; + case wvcdm::RELEASE_KEY_ERROR: + return kReleaseKeyError; + case wvcdm::RELEASE_KEY_REQUEST_ERROR: + return kReleaseKeyRequestError; + case wvcdm::RELEASE_LICENSE_ERROR_1: + return kReleaseLicenseError1; + case wvcdm::RELEASE_LICENSE_ERROR_2: + return kReleaseLicenseError2; + case wvcdm::RELEASE_USAGE_INFO_ERROR: + return kReleaseUsageInfoError; + case wvcdm::RENEW_KEY_ERROR_1: + return kRenewKeyError1; + case wvcdm::RENEW_KEY_ERROR_2: + return kRenewKeyError2; + case wvcdm::RENEWAL_REQUEST_ERROR: + return kRenewalRequestError; + case wvcdm::RESTORE_OFFLINE_LICENSE_ERROR_1: + return kRestoreOfflineLicenseError1; + case wvcdm::RESTORE_OFFLINE_LICENSE_ERROR_2: + return kRestoreOfflineLicenseError2; + case wvcdm::SESSION_INIT_ERROR_1: + return kSessionInitError1; + case wvcdm::SESSION_INIT_ERROR_2: + return kSessionInitError2; + case wvcdm::SESSION_INIT_GET_KEYBOX_ERROR: + return kSessionInitGetKeyboxError; + case wvcdm::SESSION_NOT_FOUND_1: + return kSessionNotFound1; + case wvcdm::SESSION_NOT_FOUND_2: + return kSessionNotFound2; + case wvcdm::SESSION_NOT_FOUND_3: + return kSessionNotFound3; + case wvcdm::SESSION_NOT_FOUND_4: + return kSessionNotFound4; + case wvcdm::SESSION_NOT_FOUND_5: + return kSessionNotFound5; + case wvcdm::SESSION_NOT_FOUND_6: + return kSessionNotFound6; + case wvcdm::SESSION_NOT_FOUND_7: + return kSessionNotFound7; + case wvcdm::SESSION_NOT_FOUND_8: + return kSessionNotFound8; + case wvcdm::SESSION_NOT_FOUND_9: + return kSessionNotFound9; + case wvcdm::SESSION_NOT_FOUND_10: + return kSessionNotFound10; + case wvcdm::SESSION_KEYS_NOT_FOUND: + return kSessionKeysNotFound; + case wvcdm::SIGNATURE_NOT_FOUND: + return kSignatureNotFound; + case wvcdm::STORE_LICENSE_ERROR_1: + return kStoreLicenseError1; + case wvcdm::STORE_LICENSE_ERROR_2: + return kStoreLicenseError2; + case wvcdm::STORE_LICENSE_ERROR_3: + return kStoreLicenseError3; + case wvcdm::STORE_USAGE_INFO_ERROR: + return kStoreUsageInfoError; + case wvcdm::UNPROVISION_ERROR_1: + return kUnprovisioningError1; + case wvcdm::UNPROVISION_ERROR_2: + return kUnprovisioningError2; + case wvcdm::UNPROVISION_ERROR_3: + return kUnprovisioningError3; + case wvcdm::UNPROVISION_ERROR_4: + return kUnprovisioningError4; + case wvcdm::UNSUPPORTED_INIT_DATA: + return kUnsupportedInitData; + case wvcdm::USAGE_INFO_NOT_FOUND: + return kUsageInfoNotFound; case wvcdm::KEY_ERROR: // KEY_ERROR is used by the CDM to mean just about any kind of error, not // just license errors, so it is mapped to the generic response.