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

Return error codes when storing or retrieving licenses

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

This allows error codes from device files to be added as sub-errors when
errors such as GET_LICENSE_ERROR are encountered.

Bug: 112357085
Bug: 115382201
Test: WV unit/integration tests

Change-Id: I505a87086ce584efc7e482984c0f132ac5329e16
This commit is contained in:
Rahul Frias
2019-01-14 19:09:37 -08:00
parent cfe7221d9e
commit 8b61a03b5f
6 changed files with 206 additions and 90 deletions
Download Patch File Download Diff File Expand all files Collapse all files

38
libwvdrmengine/cdm/core/include/device_files.h
View File

@@ -30,6 +30,26 @@ class DeviceFiles {
kLicenseStateUnknown,
} LicenseState;
enum ResponseType {
kNoError = 0,
kObjectNotInitialized = 1,
kParameterNull = 2,
kBasePathUnavailable = 3,
kFileNotFound = 4,
kFileOpenFailed = 5,
kFileWriteError = 6,
kFileReadError = 7,
kInvalidFileSize = 8,
kHashComputationFailed = 9,
kFileHashMismatch = 10,
kFileParseError1 = 11,
kFileParseError2 = 12,
kUnknownLicenseState = 13,
kIncorrectFileType = 14,
kIncorrectFileVersion = 15,
kLicenseNotPresent = 16,
};
struct CdmUsageData {
std::string provider_session_token;
CdmKeyMessage license_request;
@@ -69,7 +89,8 @@ class DeviceFiles {
int64_t grace_period_end_time,
const CdmAppParameterMap& app_parameters,
const CdmUsageEntry& usage_entry,
uint32_t usage_entry_number);
uint32_t usage_entry_number,
ResponseType* result);
virtual bool RetrieveLicense(
const std::string& key_set_id, LicenseState* state,
CdmInitData* pssh_data, CdmKeyMessage* key_request,
@@ -77,7 +98,8 @@ class DeviceFiles {
CdmKeyResponse* key_renewal_response, std::string* release_server_url,
int64_t* playback_start_time, int64_t* last_playback_time,
int64_t* grace_period_end_time, CdmAppParameterMap* app_parameters,
CdmUsageEntry* usage_entry, uint32_t* usage_entry_number);
CdmUsageEntry* usage_entry, uint32_t* usage_entry_number,
ResponseType* result);
virtual bool DeleteLicense(const std::string& key_set_id);
virtual bool ListLicenses(std::vector<std::string>* key_set_ids);
virtual bool DeleteAllFiles();
@@ -197,12 +219,12 @@ class DeviceFiles {
// Helpers that wrap the File interface and automatically handle hashing, as
// well as adding the device files base path to to the file name.
bool StoreFileWithHash(const std::string& name,
const std::string& serialized_file);
bool StoreFileRaw(const std::string& name,
const std::string& serialized_file);
bool RetrieveHashedFile(const std::string& name,
video_widevine_client::sdk::File* file);
ResponseType StoreFileWithHash(const std::string& name,
const std::string& serialized_file);
ResponseType StoreFileRaw(const std::string& name,
const std::string& serialized_file);
ResponseType RetrieveHashedFile(const std::string& name,
video_widevine_client::sdk::File* file);
bool FileExists(const std::string& name);
bool ListFiles(std::vector<std::string>* names);
bool RemoveFile(const std::string& name);

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

@@ -208,17 +208,19 @@ CdmResponseType CdmSession::RestoreOfflineSession(
int64_t playback_start_time;
int64_t last_playback_time;
int64_t grace_period_end_time;
DeviceFiles::ResponseType sub_error_code = DeviceFiles::kNoError;
if (!file_handle_->RetrieveLicense(
key_set_id, &license_state, &offline_init_data_, &key_request_,
&key_response_, &offline_key_renewal_request_,
&offline_key_renewal_response_, &offline_release_server_url_,
&playback_start_time, &last_playback_time, &grace_period_end_time,
&app_parameters_, &usage_entry_, &usage_entry_number_)) {
&app_parameters_, &usage_entry_, &usage_entry_number_,
&sub_error_code)) {
LOGE(
"CdmSession::RestoreOfflineSession: failed to retrieve license. "
"key set id = %s",
key_set_id.c_str());
"sub error: %d, key set id = %s",
sub_error_code, key_set_id.c_str());
return GET_LICENSE_ERROR;
}
@@ -863,13 +865,14 @@ CdmResponseType CdmSession::StoreLicense() {
}
bool CdmSession::StoreLicense(DeviceFiles::LicenseState state) {
DeviceFiles::ResponseType sub_error_code = DeviceFiles::kNoError;
return file_handle_->StoreLicense(
key_set_id_, state, offline_init_data_, key_request_, key_response_,
offline_key_renewal_request_, offline_key_renewal_response_,
offline_release_server_url_, policy_engine_->GetPlaybackStartTime(),
policy_engine_->GetLastPlaybackTime(),
policy_engine_->GetGracePeriodEndTime(), app_parameters_, usage_entry_,
usage_entry_number_);
usage_entry_number_, &sub_error_code);
}
CdmResponseType CdmSession::RemoveKeys() {

168
libwvdrmengine/cdm/core/src/device_files.cpp
View File

@@ -49,6 +49,13 @@ using video_widevine_client::sdk::
using video_widevine::SignedDrmDeviceCertificate;
using video_widevine::DrmDeviceCertificate;
#define RETURN_FALSE_IF_NULL(PARAM) \
if (PARAM == nullptr) { \
LOGE("|PARAM| not provided"); \
*result = kParameterNull; \
return false; \
}
namespace {
const char kCertificateFileName[] = "cert.bin";
@@ -121,7 +128,8 @@ bool DeviceFiles::StoreCertificate(const std::string& certificate,
std::string serialized_file;
file.SerializeToString(&serialized_file);
return StoreFileWithHash(GetCertificateFileName(), serialized_file);
return
StoreFileWithHash(GetCertificateFileName(), serialized_file) == kNoError;
}
bool DeviceFiles::RetrieveCertificate(std::string* certificate,
@@ -134,7 +142,8 @@ bool DeviceFiles::RetrieveCertificate(std::string* certificate,
}
video_widevine_client::sdk::File file;
if (!RetrieveHashedFile(GetCertificateFileName(), &file)) {
if (RetrieveHashedFile(GetCertificateFileName(), &file) != kNoError) {
LOGW("DeviceFiles::RetrieveCertificate: unable to retrieve file");
return false;
}
@@ -223,9 +232,18 @@ bool DeviceFiles::StoreLicense(
int64_t last_playback_time, int64_t grace_period_end_time,
const CdmAppParameterMap& app_parameters,
const CdmUsageEntry& usage_entry,
const uint32_t usage_entry_number) {
const uint32_t usage_entry_number,
ResponseType* result) {
if (result == nullptr) {
LOGE("DeviceFiles::StoreLicense: |result| not provided");
return false;
}
*result = kNoError;
if (!initialized_) {
LOGW("DeviceFiles::StoreLicense: not initialized");
*result = kObjectNotInitialized;
return false;
}
@@ -245,6 +263,7 @@ bool DeviceFiles::StoreLicense(
break;
default:
LOGW("DeviceFiles::StoreLicense: Unknown license state: %u", state);
*result = kUnknownLicenseState;
return false;
break;
}
@@ -271,7 +290,9 @@ bool DeviceFiles::StoreLicense(
file.SerializeToString(&serialized_file);
reserved_license_ids_.erase(key_set_id);
return StoreFileWithHash(key_set_id + kLicenseFileNameExt, serialized_file);
*result =
StoreFileWithHash(key_set_id + kLicenseFileNameExt, serialized_file);
return *result == kNoError;
}
bool DeviceFiles::RetrieveLicense(
@@ -281,29 +302,54 @@ bool DeviceFiles::RetrieveLicense(
std::string* release_server_url, int64_t* playback_start_time,
int64_t* last_playback_time, int64_t* grace_period_end_time,
CdmAppParameterMap* app_parameters, CdmUsageEntry* usage_entry,
uint32_t* usage_entry_number) {
if (!initialized_) {
LOGW("DeviceFiles::RetrieveLicense: not initialized");
uint32_t* usage_entry_number, ResponseType* result) {
if (result == nullptr) {
LOGE("DeviceFiles::RetrieveLicense: |result| not provided");
return false;
}
if (!initialized_) {
LOGW("DeviceFiles::RetrieveLicense: not initialized");
*result = kObjectNotInitialized;
return false;
}
RETURN_FALSE_IF_NULL(state);
RETURN_FALSE_IF_NULL(pssh_data);
RETURN_FALSE_IF_NULL(license_request);
RETURN_FALSE_IF_NULL(license_message);
RETURN_FALSE_IF_NULL(license_renewal_request);
RETURN_FALSE_IF_NULL(license_renewal);
RETURN_FALSE_IF_NULL(release_server_url);
RETURN_FALSE_IF_NULL(playback_start_time);
RETURN_FALSE_IF_NULL(last_playback_time);
RETURN_FALSE_IF_NULL(grace_period_end_time);
RETURN_FALSE_IF_NULL(app_parameters);
RETURN_FALSE_IF_NULL(usage_entry);
RETURN_FALSE_IF_NULL(usage_entry_number);
video_widevine_client::sdk::File file;
if (!RetrieveHashedFile(key_set_id + kLicenseFileNameExt, &file)) {
*result = RetrieveHashedFile(key_set_id + kLicenseFileNameExt, &file);
if (*result != kNoError) {
LOGW("DeviceFiles::RetrieveLicense: unable to retrieve file: %d", *result);
return false;
}
if (file.type() != video_widevine_client::sdk::File::LICENSE) {
LOGW("DeviceFiles::RetrieveLicense: Incorrect file type");
*result = kIncorrectFileType;
return false;
}
if (file.version() != video_widevine_client::sdk::File::VERSION_1) {
LOGW("DeviceFiles::RetrieveLicense: Incorrect file version");
*result = kIncorrectFileVersion;
return false;
}
if (!file.has_license()) {
LOGW("DeviceFiles::RetrieveLicense: License not present");
*result = kLicenseNotPresent;
return false;
}
@@ -444,8 +490,8 @@ bool DeviceFiles::StoreUsageInfo(const std::string& provider_session_token,
file.set_type(video_widevine_client::sdk::File::USAGE_INFO);
file.set_version(video_widevine_client::sdk::File::VERSION_1);
} else {
if (!RetrieveHashedFile(usage_info_file_name, &file)) {
LOGW("DeviceFiles::StoreUsageInfo: Unable to parse file");
if (RetrieveHashedFile(usage_info_file_name, &file) != kNoError) {
LOGW("DeviceFiles::StoreUsageInfo: Unable to retrieve file");
return false;
}
}
@@ -463,7 +509,7 @@ bool DeviceFiles::StoreUsageInfo(const std::string& provider_session_token,
std::string serialized_file;
file.SerializeToString(&serialized_file);
return StoreFileWithHash(usage_info_file_name, serialized_file);
return StoreFileWithHash(usage_info_file_name, serialized_file) == kNoError;
}
bool DeviceFiles::ListUsageIds(
@@ -489,8 +535,8 @@ bool DeviceFiles::ListUsageIds(
}
video_widevine_client::sdk::File file;
if (!RetrieveHashedFile(file_name, &file)) {
LOGW("DeviceFiles::ListUsageRecords: Unable to parse file");
if (RetrieveHashedFile(file_name, &file) != kNoError) {
LOGW("DeviceFiles::ListUsageRecords: Unable to retrieve file");
return false;
}
@@ -531,8 +577,8 @@ bool DeviceFiles::GetProviderSessionToken(const std::string& app_id,
}
video_widevine_client::sdk::File file;
if (!RetrieveHashedFile(file_name, &file)) {
LOGW("DeviceFiles::GetProviderSessionToken: unable to parse file");
if (RetrieveHashedFile(file_name, &file) != kNoError) {
LOGW("DeviceFiles::GetProviderSessionToken: unable to retrieve file");
return false;
}
@@ -553,7 +599,10 @@ bool DeviceFiles::DeleteUsageInfo(const std::string& usage_info_file_name,
return false;
}
video_widevine_client::sdk::File file;
if (!RetrieveHashedFile(usage_info_file_name, &file)) return false;
if (RetrieveHashedFile(usage_info_file_name, &file) != kNoError) {
LOGW("DeviceFiles::DeleteUsageInfo: Unable to retrieve file");
return false;
}
UsageInfo* usage_info = file.mutable_usage_info();
int index = 0;
@@ -582,7 +631,7 @@ bool DeviceFiles::DeleteUsageInfo(const std::string& usage_info_file_name,
std::string serialized_file;
file.SerializeToString(&serialized_file);
return StoreFileWithHash(usage_info_file_name, serialized_file);
return StoreFileWithHash(usage_info_file_name, serialized_file) == kNoError;
}
bool DeviceFiles::DeleteAllUsageInfoForApp(
@@ -601,7 +650,7 @@ bool DeviceFiles::DeleteAllUsageInfoForApp(
if (!FileExists(usage_info_file_name)) return true;
video_widevine_client::sdk::File file;
if (RetrieveHashedFile(usage_info_file_name, &file)) {
if (RetrieveHashedFile(usage_info_file_name, &file) == kNoError) {
for (int i = 0; i < file.usage_info().sessions_size(); ++i) {
provider_session_tokens->push_back(file.usage_info().sessions(i).token());
}
@@ -642,8 +691,8 @@ bool DeviceFiles::RetrieveUsageInfo(
}
video_widevine_client::sdk::File file;
if (!RetrieveHashedFile(usage_info_file_name, &file)) {
LOGW("DeviceFiles::RetrieveUsageInfo: Unable to parse file");
if (RetrieveHashedFile(usage_info_file_name, &file) != kNoError) {
LOGW("DeviceFiles::RetrieveUsageInfo: Unable to retrieve file");
return false;
}
@@ -669,7 +718,8 @@ bool DeviceFiles::RetrieveUsageInfo(const std::string& usage_info_file_name,
}
video_widevine_client::sdk::File file;
if (!RetrieveHashedFile(usage_info_file_name, &file)) {
if (RetrieveHashedFile(usage_info_file_name, &file) != kNoError) {
LOGW("DeviceFiles::RetrieveUsageInfo: unable to retrieve file");
return false;
}
@@ -702,7 +752,8 @@ bool DeviceFiles::RetrieveUsageInfoByKeySetId(
}
video_widevine_client::sdk::File file;
if (!RetrieveHashedFile(usage_info_file_name, &file)) {
if (RetrieveHashedFile(usage_info_file_name, &file) != kNoError) {
LOGW("DeviceFiles::RetrieveUsageInfoByKeySetId: unable to retrieve file");
return false;
}
@@ -751,7 +802,7 @@ bool DeviceFiles::StoreUsageInfo(const std::string& usage_info_file_name,
std::string serialized_file;
file.SerializeToString(&serialized_file);
return StoreFileWithHash(usage_info_file_name, serialized_file);
return StoreFileWithHash(usage_info_file_name, serialized_file) == kNoError;
}
bool DeviceFiles::UpdateUsageInfo(const std::string& usage_info_file_name,
@@ -769,8 +820,8 @@ bool DeviceFiles::UpdateUsageInfo(const std::string& usage_info_file_name,
}
if (!RetrieveHashedFile(usage_info_file_name, &file)) {
LOGW("DeviceFiles::UpdateUsageInfo: Unable to parse file");
if (RetrieveHashedFile(usage_info_file_name, &file) != kNoError) {
LOGW("DeviceFiles::UpdateUsageInfo: Unable to retrieve file");
return false;
}
@@ -788,7 +839,8 @@ bool DeviceFiles::UpdateUsageInfo(const std::string& usage_info_file_name,
std::string serialized_file;
file.SerializeToString(&serialized_file);
return StoreFileWithHash(usage_info_file_name, serialized_file);
return
StoreFileWithHash(usage_info_file_name, serialized_file) == kNoError;
}
}
@@ -814,7 +866,8 @@ bool DeviceFiles::RetrieveUsageInfo(const std::string& usage_info_file_name,
}
video_widevine_client::sdk::File file;
if (!RetrieveHashedFile(usage_info_file_name, &file)) {
if (RetrieveHashedFile(usage_info_file_name, &file) != kNoError) {
LOGW("DeviceFiles::RetrieveUsageInfo: unable to retrieve file");
return false;
}
@@ -848,7 +901,8 @@ bool DeviceFiles::RetrieveUsageInfo(const std::string& usage_info_file_name,
}
video_widevine_client::sdk::File file;
if (!RetrieveHashedFile(usage_info_file_name, &file)) {
if (RetrieveHashedFile(usage_info_file_name, &file) != kNoError) {
LOGW("DeviceFiles::RetrieveUsageInfo: unable to retrieve file");
return false;
}
@@ -942,7 +996,7 @@ bool DeviceFiles::StoreHlsAttributes(
file.SerializeToString(&serialized_file);
return StoreFileWithHash(key_set_id + kHlsAttributesFileNameExt,
serialized_file);
serialized_file) == kNoError;
}
bool DeviceFiles::RetrieveHlsAttributes(
@@ -954,7 +1008,9 @@ bool DeviceFiles::RetrieveHlsAttributes(
}
video_widevine_client::sdk::File file;
if (!RetrieveHashedFile(key_set_id + kHlsAttributesFileNameExt, &file)) {
if (RetrieveHashedFile(key_set_id + kHlsAttributesFileNameExt, &file) !=
kNoError) {
LOGW("DeviceFiles::RetrieveHlsAttributes: unable to retrieve file");
return false;
}
@@ -1045,7 +1101,8 @@ bool DeviceFiles::StoreUsageTableInfo(
std::string serialized_file;
file.SerializeToString(&serialized_file);
return StoreFileWithHash(GetUsageTableFileName(), serialized_file);
return
StoreFileWithHash(GetUsageTableFileName(), serialized_file) == kNoError;
}
bool DeviceFiles::RetrieveUsageTableInfo(
@@ -1068,7 +1125,8 @@ bool DeviceFiles::RetrieveUsageTableInfo(
}
video_widevine_client::sdk::File file;
if (!RetrieveHashedFile(GetUsageTableFileName(), &file)) {
if (RetrieveHashedFile(GetUsageTableFileName(), &file) != kNoError) {
LOGW("DeviceFiles::RetrieveUsageTableInfo: unable to retrieve file");
return false;
}
@@ -1122,13 +1180,14 @@ bool DeviceFiles::DeleteUsageTableInfo() {
return RemoveFile(GetUsageTableFileName());
}
bool DeviceFiles::StoreFileWithHash(const std::string& name,
const std::string& serialized_file) {
DeviceFiles::ResponseType DeviceFiles::StoreFileWithHash(
const std::string& name,
const std::string& serialized_file) {
// calculate SHA hash
std::string hash;
if (!Hash(serialized_file, &hash)) {
LOGW("DeviceFiles::StoreFileWithHash: Hash computation failed");
return false;
return kHashComputationFailed;
}
// Fill in hashed file data
@@ -1142,12 +1201,13 @@ bool DeviceFiles::StoreFileWithHash(const std::string& name,
return StoreFileRaw(name, serialized_hash_file);
}
bool DeviceFiles::StoreFileRaw(const std::string& name,
const std::string& serialized_file) {
DeviceFiles::ResponseType DeviceFiles::StoreFileRaw(
const std::string& name,
const std::string& serialized_file) {
std::string path;
if (!Properties::GetDeviceFilesBasePath(security_level_, &path)) {
LOGW("DeviceFiles::StoreFileRaw: Unable to get base path");
return false;
return kBasePathUnavailable;
}
path += name;
@@ -1156,7 +1216,7 @@ bool DeviceFiles::StoreFileRaw(const std::string& name,
file_system_->Open(path, FileSystem::kCreate | FileSystem::kTruncate);
if (!file) {
LOGW("DeviceFiles::StoreFileRaw: File open failed: %s", path.c_str());
return false;
return kFileOpenFailed;
}
ssize_t bytes = file->Write(serialized_file.data(), serialized_file.size());
@@ -1166,35 +1226,35 @@ bool DeviceFiles::StoreFileRaw(const std::string& name,
"DeviceFiles::StoreFileRaw: write failed: (actual: %d, "
"expected: %d)",
bytes, serialized_file.size());
return false;
return kFileWriteError;
}
LOGV("DeviceFiles::StoreFileRaw: success: %s (%db)", path.c_str(),
serialized_file.size());
return true;
return kNoError;
}
bool DeviceFiles::RetrieveHashedFile(
DeviceFiles::ResponseType DeviceFiles::RetrieveHashedFile(
const std::string& name,
video_widevine_client::sdk::File* deserialized_file) {
std::string serialized_file;
if (!deserialized_file) {
LOGW("DeviceFiles::RetrieveHashedFile: Unspecified file parameter");
return false;
return kParameterNull;
}
std::string path;
if (!Properties::GetDeviceFilesBasePath(security_level_, &path)) {
LOGW("DeviceFiles::RetrieveHashedFile: Unable to get base path");
return false;
return kBasePathUnavailable;
}
path += name;
if (!file_system_->Exists(path)) {
LOGW("DeviceFiles::RetrieveHashedFile: %s does not exist", path.c_str());
return false;
return kFileNotFound;
}
ssize_t bytes = file_system_->FileSize(path);
@@ -1204,12 +1264,12 @@ bool DeviceFiles::RetrieveHashedFile(
// Remove the corrupted file so the caller will not get the same error
// when trying to access the file repeatedly, causing the system to stall.
file_system_->Remove(path);
return false;
return kInvalidFileSize;
}
auto file = file_system_->Open(path, FileSystem::kReadOnly);
if (!file) {
return false;
return kFileOpenFailed;
}
std::string serialized_hash_file;
@@ -1217,11 +1277,11 @@ bool DeviceFiles::RetrieveHashedFile(
bytes = file->Read(&serialized_hash_file[0], serialized_hash_file.size());
if (bytes != static_cast<ssize_t>(serialized_hash_file.size())) {
LOGW("DeviceFiles::RetrieveHashedFile: read failed");
LOGW("DeviceFiles::RetrieveHashedFile: read failed: %d", bytes);
// Remove the corrupted file so the caller will not get the same error
// when trying to access the file repeatedly, causing the system to stall.
file_system_->Remove(path);
return false;
return kFileReadError;
}
LOGV("DeviceFiles::RetrieveHashedFile: success: %s (%db)", path.c_str(),
@@ -1233,13 +1293,13 @@ bool DeviceFiles::RetrieveHashedFile(
// Remove the corrupted file so the caller will not get the same error
// when trying to access the file repeatedly, causing the system to stall.
file_system_->Remove(path);
return false;
return kFileParseError1;
}
std::string hash;
if (!Hash(hash_file.file(), &hash)) {
LOGW("DeviceFiles::RetrieveHashedFile: Hash computation failed");
return false;
return kHashComputationFailed;
}
if (hash != hash_file.hash()) {
@@ -1247,7 +1307,7 @@ bool DeviceFiles::RetrieveHashedFile(
// Remove the corrupted file so the caller will not get the same error
// when trying to access the file repeatedly, causing the system to stall.
file_system_->Remove(path);
return false;
return kFileHashMismatch;
}
if (!deserialized_file->ParseFromString(hash_file.file())) {
@@ -1255,9 +1315,9 @@ bool DeviceFiles::RetrieveHashedFile(
// Remove the corrupted file so the caller will not get the same error
// when trying to access the file repeatedly, causing the system to stall.
file_system_->Remove(path);
return false;
return kFileParseError2;
}
return true;
return kNoError;
}
bool DeviceFiles::FileExists(const std::string& name) {

26
libwvdrmengine/cdm/core/src/usage_table_header.cpp
View File

@@ -365,13 +365,15 @@ CdmResponseType UsageTableHeader::GetEntry(uint32_t usage_entry_number,
std::string key_renewal_response, release_server_url;
int64_t playback_start_time, last_playback_time, grace_period_end_time;
CdmAppParameterMap app_parameters;
DeviceFiles::ResponseType sub_error_code = DeviceFiles::kNoError;
if (!handle->RetrieveLicense(
usage_entry_info_[usage_entry_number].key_set_id, &license_state,
&init_data, &key_request, &key_response, &key_renewal_request,
&key_renewal_response, &release_server_url, &playback_start_time,
&last_playback_time, &grace_period_end_time, &app_parameters,
usage_entry, &entry_number)) {
LOGE("UsageTableHeader::GetEntry: Failed to retrieve license");
usage_entry, &entry_number, &sub_error_code)) {
LOGE("UsageTableHeader::GetEntry: Failed to retrieve license, %d",
sub_error_code);
return USAGE_GET_ENTRY_RETRIEVE_LICENSE_FAILED;
}
break;
@@ -422,13 +424,15 @@ CdmResponseType UsageTableHeader::StoreEntry(uint32_t usage_entry_number,
int64_t playback_start_time, last_playback_time, grace_period_end_time;
CdmAppParameterMap app_parameters;
CdmUsageEntry entry;
DeviceFiles::ResponseType sub_error_code = DeviceFiles::kNoError;
if (!handle->RetrieveLicense(
usage_entry_info_[usage_entry_number].key_set_id, &license_state,
&init_data, &key_request, &key_response, &key_renewal_request,
&key_renewal_response, &release_server_url, &playback_start_time,
&last_playback_time, &grace_period_end_time, &app_parameters,
&entry, &entry_number)) {
LOGE("UsageTableHeader::StoreEntry: Failed to retrieve license");
&entry, &entry_number, &sub_error_code)) {
LOGE("UsageTableHeader::StoreEntry: Failed to retrieve license, %d",
sub_error_code);
return USAGE_STORE_ENTRY_RETRIEVE_LICENSE_FAILED;
}
if (!handle->StoreLicense(
@@ -436,8 +440,9 @@ CdmResponseType UsageTableHeader::StoreEntry(uint32_t usage_entry_number,
init_data, key_request, key_response, key_renewal_request,
key_renewal_response, release_server_url, playback_start_time,
last_playback_time, grace_period_end_time, app_parameters,
usage_entry, usage_entry_number)) {
LOGE("UsageTableHeader::StoreEntry: Failed to store license");
usage_entry, usage_entry_number, &sub_error_code)) {
LOGE("UsageTableHeader::StoreEntry: Failed to store license, %d",
sub_error_code);
return USAGE_STORE_LICENSE_FAILED;
}
break;
@@ -553,15 +558,16 @@ bool UsageTableHeader::UpgradeLicensesFromUsageTable(
CdmAppParameterMap app_parameters;
CdmUsageEntry usage_entry;
uint32_t usage_entry_number;
DeviceFiles::ResponseType sub_error_code = DeviceFiles::kNoError;
if (!handle->RetrieveLicense(
key_set_ids[i], &license_state, &init_data, &key_request,
&key_response, &key_renewal_request, &key_renewal_response,
&release_server_url, &playback_start_time, &last_playback_time,
&grace_period_end_time, &app_parameters, &usage_entry,
&usage_entry_number)) {
&usage_entry_number, &sub_error_code)) {
LOGW(
"UsageTableHeader::UpgradeLicensesFromUsageTable: Failed to "
"retrieve license");
"retrieve license, %d", sub_error_code);
continue;
}
@@ -611,10 +617,10 @@ bool UsageTableHeader::UpgradeLicensesFromUsageTable(
key_set_ids[i], license_state, init_data, key_request, key_response,
key_renewal_request, key_renewal_response, release_server_url,
playback_start_time, last_playback_time, grace_period_end_time,
app_parameters, usage_entry, usage_entry_number)) {
app_parameters, usage_entry, usage_entry_number, &sub_error_code)) {
LOGE(
"UsageTableHeader::UpgradeLicensesFromUsageTable: Failed to store "
"license");
"license, %d", sub_error_code);
continue;
}
}

24
libwvdrmengine/cdm/core/test/device_files_unittest.cpp
View File

@@ -2295,6 +2295,7 @@ TEST_P(DeviceFilesStoreTest, StoreLicense) {
.WillOnce(ReturnArg<1>());
EXPECT_CALL(*file, Read(_, _)).Times(0);
DeviceFiles::ResponseType sub_error_code;
DeviceFiles device_files(&file_system);
EXPECT_TRUE(device_files.Init(kSecurityLevelL1));
EXPECT_TRUE(device_files.StoreLicense(
@@ -2310,7 +2311,8 @@ TEST_P(DeviceFilesStoreTest, StoreLicense) {
license_test_data[license_num].last_playback_time,
license_test_data[license_num].grace_period_end_time, app_parameters,
license_test_data[license_num].usage_entry,
license_test_data[license_num].usage_entry_number));
license_test_data[license_num].usage_entry_number, &sub_error_code));
EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
}
INSTANTIATE_TEST_CASE_P(StoreLicense, DeviceFilesStoreTest, ::testing::Bool());
@@ -2344,6 +2346,7 @@ TEST_F(DeviceFilesTest, StoreLicenses) {
EXPECT_CALL(*file, Read(_, _)).Times(0);
}
DeviceFiles::ResponseType sub_error_code;
DeviceFiles device_files(&file_system);
EXPECT_TRUE(device_files.Init(kSecurityLevelL1));
for (size_t i = 0; i < kNumberOfLicenses; i++) {
@@ -2361,7 +2364,8 @@ TEST_F(DeviceFilesTest, StoreLicenses) {
license_test_data[i].last_playback_time,
license_test_data[i].grace_period_end_time, app_parameters,
license_test_data[i].usage_entry,
license_test_data[i].usage_entry_number));
license_test_data[i].usage_entry_number, &sub_error_code));
EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
}
}
@@ -2405,6 +2409,7 @@ TEST_F(DeviceFilesTest, RetrieveLicenses) {
CdmAppParameterMap app_parameters;
std::string usage_entry;
uint32_t usage_entry_number;
DeviceFiles::ResponseType sub_error_code;
for (size_t i = 0; i < kNumberOfLicenses; i++) {
DeviceFiles::LicenseState license_state;
@@ -2413,7 +2418,7 @@ TEST_F(DeviceFilesTest, RetrieveLicenses) {
&key_request, &key_response, &key_renewal_request,
&key_renewal_response, &release_server_url, &playback_start_time,
&last_playback_time, &grace_period_end_time, &app_parameters,
&usage_entry, &usage_entry_number));
&usage_entry, &usage_entry_number, &sub_error_code));
EXPECT_EQ(license_test_data[i].license_state, license_state);
EXPECT_EQ(license_test_data[i].pssh_data, pssh_data);
EXPECT_EQ(license_test_data[i].key_request, key_request);
@@ -2426,6 +2431,7 @@ TEST_F(DeviceFilesTest, RetrieveLicenses) {
grace_period_end_time);
EXPECT_EQ(license_test_data[i].usage_entry, usage_entry);
EXPECT_EQ(license_test_data[i].usage_entry_number, usage_entry_number);
EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
std::map<std::string, std::string>::iterator itr;
for (itr = app_parameters.begin(); itr != app_parameters.end(); ++itr) {
@@ -2475,13 +2481,14 @@ TEST_F(DeviceFilesTest, AppParametersBackwardCompatibility) {
CdmAppParameterMap app_parameters;
std::string usage_entry;
uint32_t usage_entry_number;
DeviceFiles::ResponseType sub_error_code;
EXPECT_TRUE(device_files.RetrieveLicense(
test_data->key_set_id, &license_state, &pssh_data, &key_request,
&key_response, &key_renewal_request, &key_renewal_response,
&release_server_url, &playback_start_time, &last_playback_time,
&grace_period_end_time, &app_parameters, &usage_entry,
&usage_entry_number));
&usage_entry_number, &sub_error_code));
EXPECT_EQ(test_data->license_state, license_state);
EXPECT_EQ(test_data->pssh_data, pssh_data);
EXPECT_EQ(test_data->key_request, key_request);
@@ -2494,6 +2501,7 @@ TEST_F(DeviceFilesTest, AppParametersBackwardCompatibility) {
EXPECT_EQ(0u, app_parameters.size());
EXPECT_EQ(test_data->usage_entry, usage_entry);
EXPECT_EQ(test_data->usage_entry_number, usage_entry_number);
EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
}
TEST_F(DeviceFilesTest, UpdateLicenseState) {
@@ -2515,6 +2523,7 @@ TEST_F(DeviceFilesTest, UpdateLicenseState) {
Eq(license_update_test_data[i].file_data.size())))
.WillOnce(ReturnArg<1>());
EXPECT_CALL(*file, Read(_, _)).Times(0);
DeviceFiles::ResponseType sub_error_code;
EXPECT_TRUE(device_files.StoreLicense(
license_update_test_data[0].key_set_id,
license_update_test_data[i].license_state,
@@ -2529,7 +2538,8 @@ TEST_F(DeviceFilesTest, UpdateLicenseState) {
license_update_test_data[0].grace_period_end_time,
GetAppParameters(license_test_data[0].app_parameters),
license_update_test_data[0].usage_entry,
license_update_test_data[0].usage_entry_number));
license_update_test_data[0].usage_entry_number, &sub_error_code));
EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
}
}
@@ -2572,13 +2582,14 @@ TEST_F(DeviceFilesTest, DeleteLicense) {
CdmAppParameterMap app_parameters;
std::string usage_entry;
uint32_t usage_entry_number;
DeviceFiles::ResponseType sub_error_code;
EXPECT_TRUE(device_files.RetrieveLicense(
license_test_data[0].key_set_id, &license_state, &pssh_data, &key_request,
&key_response, &key_renewal_request, &key_renewal_response,
&release_server_url, &playback_start_time, &last_playback_time,
&grace_period_end_time, &app_parameters, &usage_entry,
&usage_entry_number));
&usage_entry_number, &sub_error_code));
EXPECT_EQ(license_test_data[0].license_state, license_state);
EXPECT_EQ(license_test_data[0].pssh_data, pssh_data);
EXPECT_EQ(license_test_data[0].key_request, key_request);
@@ -2597,6 +2608,7 @@ TEST_F(DeviceFilesTest, DeleteLicense) {
}
EXPECT_EQ(license_test_data[0].usage_entry, usage_entry);
EXPECT_EQ(license_test_data[0].usage_entry_number, usage_entry_number);
EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
EXPECT_TRUE(device_files.DeleteLicense(license_test_data[0].key_set_id));
EXPECT_FALSE(device_files.LicenseExists(license_test_data[0].key_set_id));

29
libwvdrmengine/cdm/core/test/usage_table_header_unittest.cpp
View File

@@ -1361,6 +1361,7 @@ TEST_F(UsageTableHeaderTest,
uint32_t usage_entry_number_to_be_deleted =
usage_entry_info_vector.size() - 3; // kUsageEntryInfoOfflineLicense1
metrics::CryptoMetrics metrics;
DeviceFiles::ResponseType sub_error_code;
EXPECT_TRUE(device_files_->StoreLicense(
usage_entry_info_vector[usage_entry_info_vector.size() - 1].key_set_id,
@@ -1368,7 +1369,8 @@ TEST_F(UsageTableHeaderTest,
kKeyRenewalRequest, kKeyRenewalResponse, kReleaseServerUrl,
kPlaybackStartTime, kPlaybackStartTime + kPlaybackDuration,
kGracePeriodEndTime, kEmptyAppParameters, kUsageEntry,
usage_entry_info_vector.size() - 2));
usage_entry_info_vector.size() - 2, &sub_error_code));
EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
EXPECT_TRUE(device_files_->StoreLicense(
usage_entry_info_vector[usage_entry_info_vector.size() - 2].key_set_id,
@@ -1376,7 +1378,8 @@ TEST_F(UsageTableHeaderTest,
kKeyRenewalRequest, kKeyRenewalResponse, kReleaseServerUrl,
kPlaybackStartTime, kPlaybackStartTime + kPlaybackDuration,
kGracePeriodEndTime, kEmptyAppParameters, kUsageEntry,
usage_entry_info_vector.size() - 3));
usage_entry_info_vector.size() - 3, &sub_error_code));
EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR));
EXPECT_CALL(
@@ -1567,13 +1570,15 @@ TEST_F(UsageTableHeaderTest,
usage_entry_info_vector.size() - 1; // kUsageEntryInfoOfflineLicense3
metrics::CryptoMetrics metrics;
DeviceFiles::ResponseType sub_error_code;
EXPECT_TRUE(device_files_->StoreLicense(
usage_entry_info_vector[last_usage_entry_number].key_set_id,
kActiveLicenseState, kPsshData, kKeyRequest, kKeyResponse,
kKeyRenewalRequest, kKeyRenewalResponse, kReleaseServerUrl,
kPlaybackStartTime, kPlaybackStartTime + kPlaybackDuration,
kGracePeriodEndTime, kEmptyAppParameters, kUsageEntry,
last_usage_entry_number));
last_usage_entry_number, &sub_error_code));
EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR));
EXPECT_CALL(*crypto_session_,
@@ -1713,13 +1718,15 @@ TEST_F(UsageTableHeaderTest,
usage_entry_info_vector.size() - 3; // kUsageEntryInfoOfflineLicense3
metrics::CryptoMetrics metrics;
DeviceFiles::ResponseType sub_error_code;
EXPECT_TRUE(device_files_->StoreLicense(
usage_entry_info_vector[last_valid_usage_entry_number].key_set_id,
kActiveLicenseState, kPsshData, kKeyRequest, kKeyResponse,
kKeyRenewalRequest, kKeyRenewalResponse, kReleaseServerUrl,
kPlaybackStartTime, kPlaybackStartTime + kPlaybackDuration,
kGracePeriodEndTime, kEmptyAppParameters, kUsageEntry,
last_valid_usage_entry_number));
last_valid_usage_entry_number, &sub_error_code));
EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
EXPECT_CALL(*crypto_session_, Open(kLevelDefault))
.Times(2)
@@ -1869,13 +1876,15 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastEntryIsOffline) {
usage_entry_info_vector.size() - 1; // kUsageEntryInfoOfflineLicense3
metrics::CryptoMetrics metrics;
DeviceFiles::ResponseType sub_error_code;
EXPECT_TRUE(device_files_->StoreLicense(
usage_entry_info_vector[last_usage_entry_number].key_set_id,
kActiveLicenseState, kPsshData, kKeyRequest, kKeyResponse,
kKeyRenewalRequest, kKeyRenewalResponse, kReleaseServerUrl,
kPlaybackStartTime, kPlaybackStartTime + kPlaybackDuration,
kGracePeriodEndTime, kEmptyAppParameters, kUsageEntry,
last_usage_entry_number));
last_usage_entry_number, &sub_error_code));
EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
EXPECT_CALL(*crypto_session_, Open(kLevelDefault))
.Times(2)
@@ -1936,7 +1945,7 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastEntryIsOffline) {
&key_request, &key_response, &key_renewal_request, &key_renewal_response,
&release_server_url, &playback_start_time, &last_playback_time,
&grace_period_end_time, &app_parameters, &usage_entry,
&usage_entry_number));
&usage_entry_number, &sub_error_code));
EXPECT_EQ(kActiveLicenseState, license_state);
EXPECT_EQ(kPsshData, pssh_data);
EXPECT_EQ(kKeyRequest, key_request);
@@ -1950,6 +1959,7 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastEntryIsOffline) {
EXPECT_EQ(kEmptyAppParameters.size(), app_parameters.size());
EXPECT_EQ(kAnotherUsageEntry, usage_entry);
EXPECT_EQ(usage_entry_number_to_be_deleted, usage_entry_number);
EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
}
// Initial Test state:
@@ -2089,13 +2099,15 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastEntriesAreOfflineAndUnknknown) {
usage_entry_info_vector.size() - 3; // kUsageEntryInfoOfflineLicense3
metrics::CryptoMetrics metrics;
DeviceFiles::ResponseType sub_error_code;
EXPECT_TRUE(device_files_->StoreLicense(
usage_entry_info_vector[last_valid_usage_entry_number].key_set_id,
kActiveLicenseState, kPsshData, kKeyRequest, kKeyResponse,
kKeyRenewalRequest, kKeyRenewalResponse, kReleaseServerUrl,
kPlaybackStartTime, kPlaybackStartTime + kPlaybackDuration,
kGracePeriodEndTime, kEmptyAppParameters, kUsageEntry,
last_valid_usage_entry_number));
last_valid_usage_entry_number, &sub_error_code));
EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
EXPECT_CALL(*crypto_session_, Open(kLevelDefault))
.Times(2)
@@ -2157,7 +2169,7 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastEntriesAreOfflineAndUnknknown) {
&key_request, &key_response, &key_renewal_request, &key_renewal_response,
&release_server_url, &playback_start_time, &last_playback_time,
&grace_period_end_time, &app_parameters, &usage_entry,
&usage_entry_number));
&usage_entry_number, &sub_error_code));
EXPECT_EQ(kActiveLicenseState, license_state);
EXPECT_EQ(kPsshData, pssh_data);
EXPECT_EQ(kKeyRequest, key_request);
@@ -2171,6 +2183,7 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastEntriesAreOfflineAndUnknknown) {
EXPECT_EQ(kEmptyAppParameters.size(), app_parameters.size());
EXPECT_EQ(kAnotherUsageEntry, usage_entry);
EXPECT_EQ(usage_entry_number_to_be_deleted, usage_entry_number);
EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
}
// Initial Test state: