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

Renaming of Usage Table related variables and types.

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

This CL makes major changes to the names of variables and types that
are related to the usage table, header, entries, entry indexes, and
other related data.

The renaming followed these rules:
1)  "Usage table header" will exclusively refer to the header blob
    that is OEMCrypto specific.  The CDM class "UsageTableHeader"
    is the CDM-layer's abstraction around the "usage table" concept.
    The name has been updated to reflect that.
2)  The "Cdm" prefix is only used for the CDM-specific data types for
    the usage table and entry info.  It has been removed from
    OEMCrypto-specific types.
    - UsageTableHeader -> CdmUsageTable
    - CdmUsageTableHeader -> UsageTableHeader
    - CdmUsageEntry -> UsageEntry
3)  The "usage_" prefix has been removed from variables when the usage
    table or usage entries are the subject of the function or class.
4)  UsageEntryIndex is the type for entry indexes, instead of directly
    using uint32_t.  This matches how we wrap other types in
    "wv_cdm_types.h"
5)  Changed entry "number" to entry "index".
6)  Vectors of elements have been renamed to be either pluralized or
    have a suffix "_list".
7)  "Usage info" was occasionally being used to refer to the usage
    table or entries generally, rather than specifically secure-stop.
    - CryptoSession::HasUsageInfoSupport() -> HasUsageTableSupport()

The most major change is that the files "usage_table_header*" have
been renamed to be "cdm_usage_table*".

Bug: 242914226
Test: run_x86_64_tests and request_license_test
Change-Id: Iee98446b71f4f2934d3c9e0fb949eb05b84d1f8c
This commit is contained in:
Alex Dale
2022-12-20 15:21:10 -08:00
parent 0080d04579
commit 1603ba127f
24 changed files with 1321 additions and 1382 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -13,13 +13,13 @@
#include "cdm_engine.h"
#include "cdm_random.h"
#include "cdm_usage_table.h"
#include "clock.h"
#include "crypto_wrapped_key.h"
#include "file_store.h"
#include "log.h"
#include "properties.h"
#include "string_conversions.h"
#include "usage_table_header.h"
#include "wv_cdm_constants.h"
#include "wv_cdm_event_listener.h"
@@ -81,8 +81,6 @@ CdmSession::CdmSession(wvutil::FileSystem* file_system,
requested_security_level_(kLevelDefault),
is_initial_usage_update_(true),
is_usage_update_needed_(false),
usage_table_header_(nullptr),
usage_entry_number_(0),
mock_license_parser_in_use_(false),
mock_policy_engine_in_use_(false) {
assert(metrics_); // metrics_ must not be null.
@@ -92,7 +90,7 @@ CdmSession::CdmSession(wvutil::FileSystem* file_system,
}
CdmSession::~CdmSession() {
if (has_provider_session_token() && supports_usage_info() && !is_release_) {
if (has_provider_session_token() && SupportsUsageTable() && !is_release_) {
UpdateUsageEntryInformation();
}
@@ -149,8 +147,8 @@ CdmResponseType CdmSession::Init(CdmClientPropertySet* cdm_client_property_set,
}
bool has_support = false;
if (crypto_session_->HasUsageInfoSupport(&has_support) && has_support) {
usage_table_header_ = crypto_session_->GetUsageTableHeader();
if (crypto_session_->HasUsageTableSupport(&has_support) && has_support) {
usage_table_ = crypto_session_->GetUsageTable();
}
if (cdm_client_property_set != nullptr)
@@ -247,7 +245,7 @@ CdmResponseType CdmSession::RestoreOfflineSession(const CdmKeySetId& key_set_id,
offline_release_server_url_ = std::move(license_data.release_server_url);
app_parameters_ = std::move(license_data.app_parameters);
usage_entry_ = std::move(license_data.usage_entry);
usage_entry_number_ = license_data.usage_entry_number;
usage_entry_index_ = license_data.usage_entry_index;
CdmResponseType result = LoadPrivateOrLegacyKey(
license_data.drm_certificate, license_data.wrapped_private_key);
@@ -273,7 +271,7 @@ CdmResponseType CdmSession::RestoreOfflineSession(const CdmKeySetId& key_set_id,
std::string provider_session_token;
bool sign_fake_request = false; // TODO(b/169483174): remove this variable.
if (supports_usage_info()) {
if (SupportsUsageTable()) {
if (!license_parser_->ExtractProviderSessionToken(
key_response_, &provider_session_token)) {
provider_session_token.clear();
@@ -282,8 +280,8 @@ CdmResponseType CdmSession::RestoreOfflineSession(const CdmKeySetId& key_set_id,
LOGE("License usage entry is invalid, cannot restore");
return CdmResponseType(LICENSE_USAGE_ENTRY_MISSING);
} else {
CdmResponseType sts = usage_table_header_->LoadEntry(
crypto_session_.get(), usage_entry_, usage_entry_number_);
CdmResponseType sts = usage_table_->LoadEntry(
crypto_session_.get(), usage_entry_, usage_entry_index_);
crypto_metrics_->usage_table_header_load_entry_.Increment(sts);
if (sts == LOAD_USAGE_ENTRY_INVALID_SESSION) {
LOGE("License loaded in different session: key_set_id = %s",
@@ -340,9 +338,9 @@ CdmResponseType CdmSession::RestoreOfflineSession(const CdmKeySetId& key_set_id,
}
}
if (!provider_session_token.empty() && supports_usage_info()) {
CdmResponseType sts = usage_table_header_->UpdateEntry(
usage_entry_number_, crypto_session_.get(), &usage_entry_);
if (!provider_session_token.empty() && SupportsUsageTable()) {
CdmResponseType sts = usage_table_->UpdateEntry(
usage_entry_index_, crypto_session_.get(), &usage_entry_);
if (sts != NO_ERROR) {
LOGE("Failed to update usage entry: status = %d", static_cast<int>(sts));
return sts;
@@ -372,7 +370,7 @@ CdmResponseType CdmSession::RestoreUsageSession(
key_request_ = usage_data.license_request;
key_response_ = usage_data.license;
usage_entry_ = usage_data.usage_entry;
usage_entry_number_ = usage_data.usage_entry_number;
usage_entry_index_ = usage_data.usage_entry_index;
usage_provider_session_token_ = usage_data.provider_session_token;
CdmResponseType status = LoadPrivateOrLegacyKey(
@@ -380,9 +378,9 @@ CdmResponseType CdmSession::RestoreUsageSession(
if (status != NO_ERROR) return status;
CdmResponseType sts(NO_ERROR);
if (supports_usage_info()) {
sts = usage_table_header_->LoadEntry(crypto_session_.get(), usage_entry_,
usage_entry_number_);
if (SupportsUsageTable()) {
sts = usage_table_->LoadEntry(crypto_session_.get(), usage_entry_,
usage_entry_index_);
crypto_metrics_->usage_table_header_load_entry_.Increment(sts);
if (sts != NO_ERROR) {
LOGE("Failed to load usage entry: status = %d", static_cast<int>(sts));
@@ -398,9 +396,9 @@ CdmResponseType CdmSession::RestoreUsageSession(
return CdmResponseType(RELEASE_LICENSE_ERROR_2);
}
if (supports_usage_info()) {
sts = usage_table_header_->UpdateEntry(
usage_entry_number_, crypto_session_.get(), &usage_entry_);
if (SupportsUsageTable()) {
sts = usage_table_->UpdateEntry(usage_entry_index_, crypto_session_.get(),
&usage_entry_);
if (sts != NO_ERROR) {
LOGE("Failed to update usage entry: status = %d", static_cast<int>(sts));
return sts;
@@ -541,16 +539,16 @@ CdmResponseType CdmSession::AddKeyInternal(const CdmKeyResponse& key_response) {
// to be created.
CdmResponseType sts;
std::string provider_session_token;
if (supports_usage_info()) {
if (SupportsUsageTable()) {
if (license_parser_->ExtractProviderSessionToken(key_response,
&provider_session_token) &&
!provider_session_token.empty()) {
std::string app_id;
GetApplicationId(&app_id);
sts = usage_table_header_->AddEntry(
crypto_session_.get(), is_offline_, key_set_id_,
DeviceFiles::GetUsageInfoFileName(app_id), key_response,
&usage_entry_number_);
sts = usage_table_->AddEntry(crypto_session_.get(), is_offline_,
key_set_id_,
DeviceFiles::GetUsageInfoFileName(app_id),
key_response, &usage_entry_index_);
crypto_metrics_->usage_table_header_add_entry_.Increment(sts);
if (sts != NO_ERROR) return sts;
}
@@ -565,11 +563,10 @@ CdmResponseType CdmSession::AddKeyInternal(const CdmKeyResponse& key_response) {
version_info.license_service_version());
// Update or invalidate entry if usage table header+entries are supported
if (!provider_session_token.empty() && supports_usage_info()) {
if (!provider_session_token.empty() && SupportsUsageTable()) {
if (sts != KEY_ADDED) {
const CdmResponseType invalidate_sts =
usage_table_header_->InvalidateEntry(
usage_entry_number_, true, file_handle_.get(), crypto_metrics_);
const CdmResponseType invalidate_sts = usage_table_->InvalidateEntry(
usage_entry_index_, true, file_handle_.get(), crypto_metrics_);
crypto_metrics_->usage_table_header_delete_entry_.Increment(
invalidate_sts);
if (invalidate_sts != NO_ERROR) {
@@ -590,9 +587,9 @@ CdmResponseType CdmSession::AddKeyInternal(const CdmKeyResponse& key_response) {
license_parser_->provider_session_token().size());
if ((is_offline_ || has_provider_session_token()) && !is_temporary_) {
if (has_provider_session_token() && supports_usage_info()) {
usage_table_header_->UpdateEntry(usage_entry_number_,
crypto_session_.get(), &usage_entry_);
if (has_provider_session_token() && SupportsUsageTable()) {
usage_table_->UpdateEntry(usage_entry_index_, crypto_session_.get(),
&usage_entry_);
}
if (!is_offline_)
@@ -790,16 +787,16 @@ CdmResponseType CdmSession::GenerateReleaseRequest(CdmKeyRequest* key_request) {
is_release_ = true;
license_request_latency_.Clear();
CdmResponseType status = license_parser_->PrepareKeyUpdateRequest(
false, app_parameters_, usage_table_header_ == nullptr ? nullptr : this,
false, app_parameters_, usage_table_ == nullptr ? nullptr : this,
&key_request->message, &key_request->url);
key_request->type = kKeyRequestTypeRelease;
if (KEY_MESSAGE != status) return status;
if (has_provider_session_token() && supports_usage_info()) {
status = usage_table_header_->UpdateEntry(
usage_entry_number_, crypto_session_.get(), &usage_entry_);
if (has_provider_session_token() && SupportsUsageTable()) {
status = usage_table_->UpdateEntry(usage_entry_index_,
crypto_session_.get(), &usage_entry_);
if (status != NO_ERROR) {
LOGE("Update usage entry failed: status = %d", static_cast<int>(status));
@@ -811,7 +808,7 @@ CdmResponseType CdmSession::GenerateReleaseRequest(CdmKeyRequest* key_request) {
if (!StoreLicense(kLicenseStateReleasing, nullptr))
return CdmResponseType(RELEASE_KEY_REQUEST_ERROR);
} else if (!usage_provider_session_token_.empty()) {
if (supports_usage_info()) {
if (SupportsUsageTable()) {
if (!UpdateUsageInfo()) return CdmResponseType(RELEASE_USAGE_INFO_FAILED);
}
}
@@ -840,12 +837,12 @@ CdmResponseType CdmSession::ReleaseKey(const CdmKeyResponse& key_response) {
return RemoveLicense();
}
CdmResponseType CdmSession::DeleteUsageEntry(uint32_t usage_entry_number) {
CdmResponseType CdmSession::DeleteUsageEntry(uint32_t usage_entry_index) {
if (!initialized_) {
LOGE("CDM session not initialized");
return CdmResponseType(NOT_INITIALIZED_ERROR);
}
if (!supports_usage_info()) {
if (!SupportsUsageTable()) {
LOGE("Cannot delete entry, usage table not supported");
return CdmResponseType(INCORRECT_USAGE_SUPPORT_TYPE_1);
}
@@ -860,19 +857,19 @@ CdmResponseType CdmSession::DeleteUsageEntry(uint32_t usage_entry_number) {
crypto_metrics_, crypto_session_open_, sts, requested_security_level_);
if (sts != NO_ERROR) return sts;
usage_table_header_ = nullptr;
usage_table_ = nullptr;
bool has_support = false;
if (crypto_session_->HasUsageInfoSupport(&has_support) && has_support) {
usage_table_header_ = crypto_session_->GetUsageTableHeader();
if (crypto_session_->HasUsageTableSupport(&has_support) && has_support) {
usage_table_ = crypto_session_->GetUsageTable();
}
if (usage_table_header_ == nullptr) {
if (usage_table_ == nullptr) {
LOGE("Usage table header unavailable");
return CdmResponseType(INCORRECT_USAGE_SUPPORT_TYPE_1);
}
sts = usage_table_header_->InvalidateEntry(
usage_entry_number, true, file_handle_.get(), crypto_metrics_);
sts = usage_table_->InvalidateEntry(usage_entry_index, true,
file_handle_.get(), crypto_metrics_);
crypto_metrics_->usage_table_header_delete_entry_.Increment(sts);
return sts;
}
@@ -954,11 +951,11 @@ CdmResponseType CdmSession::StoreLicense() {
if (!file_handle_->StoreUsageInfo(
provider_session_token, key_request_, key_response_,
DeviceFiles::GetUsageInfoFileName(app_id), key_set_id_, usage_entry_,
usage_entry_number_, drm_certificate_, wrapped_private_key_)) {
usage_entry_index_, drm_certificate_, wrapped_private_key_)) {
LOGE("Unable to store usage info");
// Usage info file is corrupt. Delete current usage entry and file.
if (supports_usage_info()) {
DeleteUsageEntry(usage_entry_number_);
if (SupportsUsageTable()) {
DeleteUsageEntry(usage_entry_index_);
} else {
LOGW("Cannot store, usage table not supported");
}
@@ -987,7 +984,7 @@ bool CdmSession::StoreLicense(CdmOfflineLicenseState state, int* error_detail) {
policy_engine_->GetGracePeriodEndTime(),
app_parameters_,
usage_entry_,
usage_entry_number_,
usage_entry_index_,
drm_certificate_,
wrapped_private_key_};
@@ -1011,8 +1008,8 @@ CdmResponseType CdmSession::RemoveKeys() {
CdmResponseType CdmSession::RemoveLicense() {
if (is_offline_ || has_provider_session_token()) {
if (has_provider_session_token() && supports_usage_info()) {
DeleteUsageEntry(usage_entry_number_);
if (has_provider_session_token() && SupportsUsageTable()) {
DeleteUsageEntry(usage_entry_index_);
}
DeleteLicenseFile();
}
@@ -1061,9 +1058,9 @@ void CdmSession::GetApplicationId(std::string* app_id) {
}
CdmResponseType CdmSession::UpdateUsageEntryInformation() {
if (!has_provider_session_token() || !supports_usage_info()) {
if (!has_provider_session_token() || !SupportsUsageTable()) {
LOGE("Unexpected state: usage_support = %s, PST present = %s, ",
supports_usage_info() ? "true" : "false",
SupportsUsageTable() ? "true" : "false",
has_provider_session_token() ? "yes" : "no");
return CdmResponseType(INCORRECT_USAGE_SUPPORT_TYPE_2);
}
@@ -1072,8 +1069,8 @@ CdmResponseType CdmSession::UpdateUsageEntryInformation() {
// TODO(blueeyes): Add measurements to all UpdateEntry calls in a way that
// allos us to isolate this particular use case within
// UpdateUsageEntryInformation.
M_TIME(sts = usage_table_header_->UpdateEntry(
usage_entry_number_, crypto_session_.get(), &usage_entry_),
M_TIME(sts = usage_table_->UpdateEntry(usage_entry_index_,
crypto_session_.get(), &usage_entry_),
crypto_metrics_, usage_table_header_update_entry_, sts);
if (sts != NO_ERROR) return sts;
@@ -1159,7 +1156,7 @@ bool CdmSession::UpdateUsageInfo() {
usage_data.license = key_response_;
usage_data.key_set_id = key_set_id_;
usage_data.usage_entry = usage_entry_;
usage_data.usage_entry_number = usage_entry_number_;
usage_data.usage_entry_index = usage_entry_index_;
return file_handle_->UpdateUsageInfo(
DeviceFiles::GetUsageInfoFileName(app_id), usage_provider_session_token_,
@@ -1178,15 +1175,15 @@ bool CdmSession::VerifyOfflineUsageEntry() {
// Check that the current license is the same as the expected
// entry in the usage table. It is possible that the license has
// been removed from the usage table but the license file remains.
if (usage_entry_number_ >= usage_table_header_->size()) {
LOGD("License usage entry does not exist: entry_number = %u, size = %zu",
usage_entry_number_, usage_table_header_->size());
if (usage_entry_index_ >= usage_table_->size()) {
LOGD("License usage entry does not exist: entry_index = %u, size = %zu",
usage_entry_index_, usage_table_->size());
return false;
}
const CdmUsageEntryInfo& usage_entry_info =
usage_table_header_->usage_entry_info().at(usage_entry_number_);
if (usage_entry_info.storage_type != kStorageLicense ||
usage_entry_info.key_set_id != key_set_id_) {
const CdmUsageEntryInfo& entry_info =
usage_table_->entry_info_list().at(usage_entry_index_);
if (entry_info.storage_type != kStorageLicense ||
entry_info.key_set_id != key_set_id_) {
LOGD("License usage entry does not match");
return false;
}