widevine-partner/android
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add more CdmResponseType to help with debugging in the field.

Browse Source 
The errors in the range ERROR_DRM_VENDOR_MIN to ERROR_DRM_VENDOR_MAX are
reflected in the message that is reported to the app, which is
MediaDrmStateException.getDiagnosticInfo().

Many errors map to kErrorCDMGeneric, especially KEY_ERROR is used as a
generic error in CDM. This fix defines more specific error codes in the
CDM for places where KEY_ERROR is returned.

Merge from http://go/wvgerrit/14071

bug: 19244061
Change-Id: I688bf32828f997000fea041dd29567dde18ac677
This commit is contained in:
Edwin Wong
2015-04-15 11:44:06 -07:00
parent c5f576585b
commit 2eb013691c
11 changed files with 974 additions and 177 deletions
Download Patch File Download Diff File Expand all files Collapse all files

130
libwvdrmengine/cdm/core/include/wv_cdm_types.h
View File

@@ -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 {

110
libwvdrmengine/cdm/core/src/cdm_engine.cpp
View File

@@ -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<CdmSession> 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<CryptoSession> 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<std::pair<CdmKeyMessage, CdmKeyResponse> > 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);

86
libwvdrmengine/cdm/core/src/cdm_session.cpp
View File

@@ -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;
}

34
libwvdrmengine/cdm/core/src/certificate_provisioning.cpp
View File

@@ -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();

2
libwvdrmengine/cdm/core/src/crypto_session.cpp
View File

@@ -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;
}
}

58
libwvdrmengine/cdm/core/src/license.cpp
View File

@@ -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<CryptoKey> 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();

2
libwvdrmengine/cdm/core/test/cdm_session_unittest.cpp
View File

@@ -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) {

309
libwvdrmengine/cdm/core/test/test_printers.cpp
View File

@@ -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;
}
};

9
libwvdrmengine/cdm/test/request_license_test.cpp
View File

@@ -790,7 +790,7 @@ TEST_F(WvCdmRequestLicenseTest, ProvisioningRetryTest) {
response =
GetCertRequestResponse(g_config->provisioning_server_url());
EXPECT_NE(0, static_cast<int>(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<int>(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();

151
libwvdrmengine/include/WVErrors.h
View File

@@ -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<uint32_t>(kErrorWVDrmMaxErrorUsed) <=

260
libwvdrmengine/include/mapErrors-inl.h
View File

@@ -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.