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

Modified return values for Restore operations

Browse Source 
[ Merge of http://go/wvgerrit/70543 ]

RestoreOfflineLicense and RestoreLicenseForRelease now return
CdmResponseType errors rather than a boolean. These error codes
can now be used when gathering metrics.

Bug: 115517916
Test: WV unit/integration tests
Change-Id: If4784d2cdd9825948c5dec31d3e60058ea06b61d
This commit is contained in:
Rahul Frias
2019-01-17 00:09:38 -08:00
parent cfe7221d9e
commit 675b934406
8 changed files with 159 additions and 43 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
libwvdrmengine/cdm/core/include/license.h
View File

@@ -57,14 +57,15 @@ class CdmLicense {
virtual CdmResponseType HandleEmbeddedKeyData(
const InitializationData& init_data);
virtual bool RestoreOfflineLicense(
virtual CdmResponseType RestoreOfflineLicense(
const CdmKeyMessage& license_request,
const CdmKeyResponse& license_response,
const CdmKeyResponse& license_renewal_response,
int64_t playback_start_time, int64_t last_playback_time,
int64_t grace_period_end_time, CdmSession* cdm_session);
virtual bool RestoreLicenseForRelease(const CdmKeyMessage& license_request,
const CdmKeyResponse& license_response);
virtual CdmResponseType RestoreLicenseForRelease(
const CdmKeyMessage& license_request,
const CdmKeyResponse& license_response);
virtual bool HasInitData() { return stored_init_data_.get(); }
virtual bool IsKeyLoaded(const KeyId& key_id);

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

@@ -342,6 +342,19 @@ enum CdmResponseType {
GET_DECRYPT_HASH_ERROR = 297,
SESSION_NOT_FOUND_20 = 298,
INVALID_DECRYPT_HASH_FORMAT = 299,
EMPTY_LICENSE_REQUEST_2 = 300,
EMPTY_LICENSE_REQUEST_3 = 301,
EMPTY_LICENSE_RESPONSE_3 = 302,
EMPTY_LICENSE_RESPONSE_4 = 303,
PARSE_REQUEST_ERROR_1 = 304,
PARSE_REQUEST_ERROR_2 = 305,
INVALID_LICENSE_REQUEST_TYPE_1 = 306,
INVALID_LICENSE_REQUEST_TYPE_2 = 307,
LICENSE_RESPONSE_PARSE_ERROR_4 = 308,
LICENSE_RESPONSE_PARSE_ERROR_5 = 309,
INVALID_LICENSE_TYPE_2 = 310,
SIGNATURE_NOT_FOUND_2 = 311,
SESSION_KEYS_NOT_FOUND_2 = 312,
// Don't forget to add new values to ../test/test_printers.cpp.
};

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

@@ -258,16 +258,19 @@ CdmResponseType CdmSession::RestoreOfflineSession(
}
}
CdmResponseType result;
if (license_type == kLicenseTypeRelease) {
if (!license_parser_->RestoreLicenseForRelease(key_request_,
key_response_)) {
result =
license_parser_->RestoreLicenseForRelease(key_request_, key_response_);
if (result != NO_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, grace_period_end_time,
this)) {
result = license_parser_->RestoreOfflineLicense(
key_request_, key_response_, offline_key_renewal_response_,
playback_start_time, last_playback_time, grace_period_end_time, this);
if (result != NO_ERROR) {
return RESTORE_OFFLINE_LICENSE_ERROR_2;
}
}
@@ -312,9 +315,10 @@ CdmResponseType CdmSession::RestoreUsageSession(
usage_entry_number_ = usage_data.usage_entry_number;
usage_provider_session_token_ = usage_data.provider_session_token;
CdmResponseType sts = NO_ERROR;
if (usage_support_type_ == kUsageEntrySupport &&
usage_table_header_ != NULL) {
CdmResponseType sts = usage_table_header_->LoadEntry(
sts = usage_table_header_->LoadEntry(
crypto_session_.get(), usage_entry_, usage_entry_number_);
if (sts != NO_ERROR) {
LOGE("CdmSession::RestoreUsageSession: failed to load usage entry = %d",
@@ -323,13 +327,15 @@ CdmResponseType CdmSession::RestoreUsageSession(
}
}
if (!license_parser_->RestoreLicenseForRelease(key_request_, key_response_)) {
sts = license_parser_->RestoreLicenseForRelease(key_request_, key_response_);
if (sts != NO_ERROR) {
return RELEASE_LICENSE_ERROR_2;
}
if (usage_support_type_ == kUsageEntrySupport &&
usage_table_header_ != NULL) {
CdmResponseType sts =
sts =
usage_table_header_->UpdateEntry(crypto_session_.get(), &usage_entry_);
if (sts != NO_ERROR) {
LOGE("CdmSession::RestoreUsageSession: failed to update usage entry: %d",

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

@@ -700,24 +700,26 @@ CdmResponseType CdmLicense::HandleEmbeddedKeyData(
return HandleNewEntitledKeys(init_data.ExtractWrappedKeys());
}
bool CdmLicense::RestoreOfflineLicense(
CdmResponseType CdmLicense::RestoreOfflineLicense(
const CdmKeyMessage& license_request,
const CdmKeyResponse& license_response,
const CdmKeyResponse& license_renewal_response, int64_t playback_start_time,
int64_t last_playback_time, int64_t grace_period_end_time,
CdmSession* cdm_session) {
if (license_request.empty() || license_response.empty()) {
LOGE(
"CdmLicense::RestoreOfflineLicense: key_request or response empty: "
"%u %u",
license_request.size(), license_response.size());
return false;
if (license_request.empty()) {
LOGE("CdmLicense::RestoreOfflineLicense: empty |license_request|");
return EMPTY_LICENSE_REQUEST_2;
}
if (license_response.empty()) {
LOGE("CdmLicense::RestoreOfflineLicense: empty |license_response|");
return EMPTY_LICENSE_RESPONSE_3;
}
SignedMessage signed_request;
if (!signed_request.ParseFromString(license_request)) {
LOGE("CdmLicense::RestoreOfflineLicense: license_request parse failed");
return false;
LOGE("CdmLicense::RestoreOfflineLicense: |license_request| parse failed");
return PARSE_REQUEST_ERROR_1;
}
if (signed_request.type() != SignedMessage::LICENSE_REQUEST) {
@@ -725,26 +727,26 @@ bool CdmLicense::RestoreOfflineLicense(
"CdmLicense::RestoreOfflineLicense: license request type: expected = "
"%d, actual = %d",
SignedMessage::LICENSE_REQUEST, signed_request.type());
return false;
return INVALID_LICENSE_REQUEST_TYPE_1;
}
key_request_ = signed_request.msg();
CdmResponseType sts = HandleKeyResponse(license_response);
if (sts != KEY_ADDED) return false;
if (sts != KEY_ADDED) return sts;
if (!license_renewal_response.empty()) {
sts = HandleKeyUpdateResponse(true, license_renewal_response);
if (sts != KEY_ADDED) return false;
if (sts != KEY_ADDED) return sts;
}
if (!provider_session_token_.empty()) {
if (cdm_session &&
cdm_session->get_usage_support_type() == kUsageEntrySupport) {
CdmResponseType status = cdm_session->UpdateUsageEntryInformation();
if (NO_ERROR != status) return false;
if (NO_ERROR != status) return sts;
}
std::string usage_report;
@@ -778,24 +780,26 @@ bool CdmLicense::RestoreOfflineLicense(
policy_engine_->RestorePlaybackTimes(playback_start_time, last_playback_time,
grace_period_end_time);
return true;
return NO_ERROR;
}
bool CdmLicense::RestoreLicenseForRelease(
CdmResponseType CdmLicense::RestoreLicenseForRelease(
const CdmKeyMessage& license_request,
const CdmKeyResponse& license_response) {
if (license_request.empty() || license_response.empty()) {
LOGE(
"CdmLicense::RestoreLicenseForRelease: key_request or response empty:"
" %u %u",
license_request.size(), license_response.size());
return false;
if (license_request.empty()) {
LOGE("CdmLicense::RestoreLicenseForRelease: empty |license_request|");
return EMPTY_LICENSE_REQUEST_3;
}
if (license_response.empty()) {
LOGE("CdmLicense::RestoreLicenseForRelease: empty |license_response|");
return EMPTY_LICENSE_RESPONSE_4;
}
SignedMessage signed_request;
if (!signed_request.ParseFromString(license_request)) {
LOGE("CdmLicense::RestoreLicenseForRelease: license_request parse failed");
return false;
return PARSE_REQUEST_ERROR_2;
}
if (signed_request.type() != SignedMessage::LICENSE_REQUEST) {
@@ -804,7 +808,7 @@ bool CdmLicense::RestoreLicenseForRelease(
"expected "
"= %d, actual = %d",
SignedMessage::LICENSE_REQUEST, signed_request.type());
return false;
return INVALID_LICENSE_REQUEST_TYPE_2;
}
key_request_ = signed_request.msg();
@@ -814,7 +818,7 @@ bool CdmLicense::RestoreLicenseForRelease(
LOGE(
"CdmLicense::RestoreLicenseForRelease: unable to parse signed license"
" response");
return false;
return LICENSE_RESPONSE_PARSE_ERROR_4;
}
if (SignedMessage::LICENSE != signed_response.type()) {
@@ -822,14 +826,14 @@ bool CdmLicense::RestoreLicenseForRelease(
"CdmLicense::RestoreLicenseForRelease: unrecognized signed message "
"type: %d",
signed_response.type());
return false;
return INVALID_LICENSE_TYPE_2;
}
if (!signed_response.has_signature()) {
LOGE(
"CdmLicense::RestoreLicenseForRelease: license response is not"
" signed");
return false;
return SIGNATURE_NOT_FOUND_2;
}
License license;
@@ -837,7 +841,7 @@ bool CdmLicense::RestoreLicenseForRelease(
LOGE(
"CdmLicense::RestoreLicenseForRelease: unable to parse license"
" response");
return false;
return LICENSE_RESPONSE_PARSE_ERROR_5;
}
if (license.id().has_provider_session_token())
@@ -848,11 +852,12 @@ bool CdmLicense::RestoreLicenseForRelease(
if (!signed_response.has_session_key()) {
LOGE("CdmLicense::RestoreLicenseForRelease: no session keys present");
return false;
return SESSION_KEYS_NOT_FOUND_2;
}
if (!license.id().has_provider_session_token()) {
return KEY_ADDED == HandleKeyResponse(license_response);
CdmResponseType result = HandleKeyResponse(license_response);
return result == KEY_ADDED ? NO_ERROR : result;
}
if (license.policy().has_renewal_server_url())
@@ -861,7 +866,7 @@ bool CdmLicense::RestoreLicenseForRelease(
// If the policy engine already has keys, they will now expire.
// If the policy engine does not already have keys, this will not add any.
policy_engine_->SetLicenseForRelease(license);
return true;
return NO_ERROR;
}
bool CdmLicense::IsKeyLoaded(const KeyId& key_id) {

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

@@ -787,6 +787,45 @@ void PrintTo(const enum CdmResponseType& value, ::std::ostream* os) {
case INVALID_DECRYPT_HASH_FORMAT:
*os << "INVALID_DECRYPT_HASH_FORMAT";
break;
case EMPTY_LICENSE_REQUEST_2:
*os << "EMPTY_LICENSE_REQUEST_2";
break;
case EMPTY_LICENSE_REQUEST_3:
*os << "EMPTY_LICENSE_REQUEST_3";
break;
case EMPTY_LICENSE_RESPONSE_3:
*os << "EMPTY_LICENSE_RESPONSE_3";
break;
case EMPTY_LICENSE_RESPONSE_4:
*os << "EMPTY_LICENSE_RESPONSE_4";
break;
case PARSE_REQUEST_ERROR_1:
*os << "PARSE_REQUEST_ERROR_1";
break;
case PARSE_REQUEST_ERROR_2:
*os << "PARSE_REQUEST_ERROR_2";
break;
case INVALID_LICENSE_REQUEST_TYPE_1:
*os << "INVALID_LICENSE_REQUEST_TYPE_1";
break;
case INVALID_LICENSE_REQUEST_TYPE_2:
*os << "INVALID_LICENSE_REQUEST_TYPE_2";
break;
case LICENSE_RESPONSE_PARSE_ERROR_4:
*os << "LICENSE_RESPONSE_PARSE_ERROR_4";
break;
case LICENSE_RESPONSE_PARSE_ERROR_5:
*os << "LICENSE_RESPONSE_PARSE_ERROR_5";
break;
case INVALID_LICENSE_TYPE_2:
*os << "INVALID_LICENSE_TYPE_2";
break;
case SIGNATURE_NOT_FOUND_2:
*os << "SIGNATURE_NOT_FOUND_2";
break;
case SESSION_KEYS_NOT_FOUND_2:
*os << "SESSION_KEYS_NOT_FOUND_2";
break;
default:
*os << "Unknown CdmResponseType";
break;

15
libwvdrmengine/include/WVErrors.h
View File

@@ -273,10 +273,23 @@ enum {
kSetDecryptHashError = ERROR_DRM_VENDOR_MIN + 283,
kGetDecryptHashError = ERROR_DRM_VENDOR_MIN + 284,
kInvalidDecryptHashFormat = ERROR_DRM_VENDOR_MIN + 285,
kEmptyLicenseRequest2 = ERROR_DRM_VENDOR_MIN + 286,
kEmptyLicenseRequest3 = ERROR_DRM_VENDOR_MIN + 287,
kEmptyLicenseResponse3 = ERROR_DRM_VENDOR_MIN + 288,
kEmptyLicenseResponse4 = ERROR_DRM_VENDOR_MIN + 289,
kParseRequestError1 = ERROR_DRM_VENDOR_MIN + 290,
kParseRequestError2 = ERROR_DRM_VENDOR_MIN + 291,
kInvalidLicenseRequestType1 = ERROR_DRM_VENDOR_MIN + 292,
kInvalidLicenseRequestType2 = ERROR_DRM_VENDOR_MIN + 293,
kLicenseResponseParseError4 = ERROR_DRM_VENDOR_MIN + 294,
kLicenseResponseParseError5 = ERROR_DRM_VENDOR_MIN + 295,
kInvalidLicenseType2 = ERROR_DRM_VENDOR_MIN + 296,
kSignatureNotFound2 = ERROR_DRM_VENDOR_MIN + 297,
kSessionKeysNotFound2 = ERROR_DRM_VENDOR_MIN + 298,
// This should always follow the last error code.
// The offset value should be updated each time a new error code is added.
kErrorWVDrmMaxErrorUsed = ERROR_DRM_VENDOR_MIN + 285,
kErrorWVDrmMaxErrorUsed = ERROR_DRM_VENDOR_MIN + 298,
// Used by crypto test mode
kErrorTestMode = ERROR_DRM_VENDOR_MAX,

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

@@ -531,6 +531,32 @@ static android::status_t mapCdmResponseType(wvcdm::CdmResponseType res) {
return kGetDecryptHashError;
case wvcdm::INVALID_DECRYPT_HASH_FORMAT:
return kInvalidDecryptHashFormat;
case wvcdm::EMPTY_LICENSE_REQUEST_2:
return kEmptyLicenseRequest2;
case wvcdm::EMPTY_LICENSE_REQUEST_3:
return kEmptyLicenseRequest3;
case wvcdm::EMPTY_LICENSE_RESPONSE_3:
return kEmptyLicenseResponse3;
case wvcdm::EMPTY_LICENSE_RESPONSE_4:
return kEmptyLicenseResponse4;
case wvcdm::PARSE_REQUEST_ERROR_1:
return kParseRequestError1;
case wvcdm::PARSE_REQUEST_ERROR_2:
return kParseRequestError2;
case wvcdm::INVALID_LICENSE_REQUEST_TYPE_1:
return kInvalidLicenseRequestType1;
case wvcdm::INVALID_LICENSE_REQUEST_TYPE_2:
return kInvalidLicenseRequestType2;
case wvcdm::LICENSE_RESPONSE_PARSE_ERROR_4:
return kLicenseResponseParseError4;
case wvcdm::LICENSE_RESPONSE_PARSE_ERROR_5:
return kLicenseResponseParseError5;
case wvcdm::INVALID_LICENSE_TYPE_2:
return kInvalidLicenseType2;
case wvcdm::SIGNATURE_NOT_FOUND_2:
return kSignatureNotFound2;
case wvcdm::SESSION_KEYS_NOT_FOUND_2:
return kSessionKeysNotFound2;
}
// Return here instead of as a default case so that the compiler will warn

13
libwvdrmengine/include_hidl/mapErrors-inl.h
View File

@@ -308,6 +308,19 @@ static Status mapCdmResponseType(wvcdm::CdmResponseType res) {
case wvcdm::SET_DECRYPT_HASH_ERROR:
case wvcdm::GET_DECRYPT_HASH_ERROR:
case wvcdm::INVALID_DECRYPT_HASH_FORMAT:
case wvcdm::EMPTY_LICENSE_REQUEST_2:
case wvcdm::EMPTY_LICENSE_REQUEST_3:
case wvcdm::EMPTY_LICENSE_RESPONSE_3:
case wvcdm::EMPTY_LICENSE_RESPONSE_4:
case wvcdm::PARSE_REQUEST_ERROR_1:
case wvcdm::PARSE_REQUEST_ERROR_2:
case wvcdm::INVALID_LICENSE_REQUEST_TYPE_1:
case wvcdm::INVALID_LICENSE_REQUEST_TYPE_2:
case wvcdm::LICENSE_RESPONSE_PARSE_ERROR_4:
case wvcdm::LICENSE_RESPONSE_PARSE_ERROR_5:
case wvcdm::INVALID_LICENSE_TYPE_2:
case wvcdm::SIGNATURE_NOT_FOUND_2:
case wvcdm::SESSION_KEYS_NOT_FOUND_2:
ALOGW("Returns UNKNOWN error for legacy status: %d", res);
return Status::ERROR_DRM_UNKNOWN;