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

Merge "Renaming of Usage Table related variables and types."

Browse Source
This commit is contained in:
TreeHugger Robot
2023-01-10 02:43:26 +00:00
committed by Android (Google) Code Review
parent 609349c314 1603ba127f
commit d933e34824
24 changed files with 1321 additions and 1382 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
libwvdrmengine/build_all_unit_tests.sh
View File

@@ -36,6 +36,7 @@ WV_UNITTESTS="base64_test \
cdm_feature_test \
cdm_extended_duration_test \
cdm_session_unittest \
cdm_usage_table_unittest \
certificate_provisioning_unittest \
counter_metric_unittest \
crypto_session_unittest \
@@ -69,7 +70,6 @@ WV_UNITTESTS="base64_test \
service_certificate_unittest \
system_id_extractor_unittest \
timer_unittest \
usage_table_header_unittest \
value_metric_unittest \
wv_cdm_metrics_test"

2
libwvdrmengine/cdm/Android.bp
View File

@@ -45,6 +45,7 @@ cc_library_static {
CORE_SRC_DIR + "/cdm_engine_factory.cpp",
CORE_SRC_DIR + "/cdm_session.cpp",
CORE_SRC_DIR + "/cdm_session_map.cpp",
CORE_SRC_DIR + "/cdm_usage_table.cpp",
CORE_SRC_DIR + "/certificate_provisioning.cpp",
CORE_SRC_DIR + "/client_identification.cpp",
CORE_SRC_DIR + "/content_key_session.cpp",
@@ -66,7 +67,6 @@ cc_library_static {
CORE_SRC_DIR + "/privacy_crypto_boringssl.cpp",
CORE_SRC_DIR + "/service_certificate.cpp",
CORE_SRC_DIR + "/system_id_extractor.cpp",
CORE_SRC_DIR + "/usage_table_header.cpp",
CORE_SRC_DIR + "/wv_cdm_types.cpp",
SRC_DIR + "/wv_content_decryption_module.cpp",
METRICS_SRC_DIR + "/attribute_handler.cpp",

16
libwvdrmengine/cdm/core/include/cdm_session.h
View File

@@ -27,7 +27,7 @@ namespace wvcdm {
class CdmClientPropertySet;
class ServiceCertificate;
class WvCdmEventListener;
class UsageTableHeader;
class CdmUsageTable;
class CdmSession {
public:
@@ -129,7 +129,7 @@ class CdmSession {
// ReleaseKey() - Accept response and release key.
virtual CdmResponseType ReleaseKey(const CdmKeyResponse& key_response);
virtual CdmResponseType DeleteUsageEntry(uint32_t usage_entry_number);
virtual CdmResponseType DeleteUsageEntry(UsageEntryIndex entry_index);
virtual bool IsKeyLoaded(const KeyId& key_id);
virtual int64_t GetDurationRemaining();
@@ -164,9 +164,7 @@ class CdmSession {
license_parser_->provider_session_token().size() > 0);
}
virtual bool supports_usage_info() const {
return usage_table_header_ != nullptr;
}
virtual bool SupportsUsageTable() const { return usage_table_ != nullptr; }
// This method will remove keys by resetting crypto resources and
// policy information. This renders the session mostly useless and it is
@@ -307,11 +305,11 @@ class CdmSession {
// Usage related flags and data
bool is_initial_usage_update_;
bool is_usage_update_needed_;
// Only assign |usage_table_header_| if capable of supporting usage
// Only assign |usage_table_| if capable of supporting usage
// information.
UsageTableHeader* usage_table_header_ = nullptr;
uint32_t usage_entry_number_;
CdmUsageEntry usage_entry_;
CdmUsageTable* usage_table_ = nullptr;
UsageEntryIndex usage_entry_index_;
UsageEntry usage_entry_;
std::string usage_provider_session_token_;
// information useful for offline and usage scenarios

123
libwvdrmengine/cdm/core/include/usage_table_header.h → libwvdrmengine/cdm/core/include/cdm_usage_table.h
View File

@@ -2,8 +2,8 @@
// source code may only be used and distributed under the Widevine License
// Agreement.
#ifndef WVCDM_CORE_USAGE_TABLE_HEADER_H_
#define WVCDM_CORE_USAGE_TABLE_HEADER_H_
#ifndef WVCDM_CORE_CDM_USAGE_TABLE_H_
#define WVCDM_CORE_CDM_USAGE_TABLE_H_
#include <memory>
#include <mutex>
@@ -46,12 +46,12 @@ namespace wvcdm {
//
// Upgrades from a fixed size usage table (supported by previous
// versions of the OEMCrypto API v9-12) are handled by this class.
// |usage_entry| and |usage_entry_number|s need to be saved in the license
// |entry| and |entry_index|s need to be saved in the license
// and usage info records by the caller.
class UsageTableHeader {
class CdmUsageTable {
public:
UsageTableHeader();
virtual ~UsageTableHeader() {}
CdmUsageTable();
virtual ~CdmUsageTable() {}
// |crypto_session| is used to create or load a usage master table
// and not cached beyound this call.
@@ -65,36 +65,36 @@ class UsageTableHeader {
// Adds a new entry to the OEMCrypto usage table header, and associates
// the entry with the provided |crypto_session|. The index of the new
// usage entry will be returned by |usage_entry_number|.
// usage entry will be returned by |entry_index|.
//
// Type of entry depends on the value of |persistent_license|:
// false - usage info / secure stop record
// true - offline license
//
// Threading: Method takes exclusive use of |usage_table_header_lock_|.
// Threading: Method takes exclusive use of |lock_|.
virtual CdmResponseType AddEntry(CryptoSession* crypto_session,
bool persistent_license,
const CdmKeySetId& key_set_id,
const std::string& usage_info_filename,
const CdmKeyResponse& license_message,
uint32_t* usage_entry_number);
// Threading: Method takes exclusive use of |usage_table_header_lock_|.
UsageEntryIndex* entry_index);
// Threading: Method takes exclusive use of |lock_|.
virtual CdmResponseType LoadEntry(CryptoSession* crypto_session,
const CdmUsageEntry& usage_entry,
uint32_t usage_entry_number);
// Threading: Method takes exclusive use of |usage_table_header_lock_|.
virtual CdmResponseType UpdateEntry(uint32_t usage_entry_number,
const UsageEntry& entry,
UsageEntryIndex entry_index);
// Threading: Method takes exclusive use of |lock_|.
virtual CdmResponseType UpdateEntry(UsageEntryIndex entry_index,
CryptoSession* crypto_session,
CdmUsageEntry* usage_entry);
UsageEntry* entry);
// The licenses or usage info records specified by |usage_entry_number|
// The licenses or usage info records specified by |entry_index|
// should not be in use by any open CryptoSession objects when calls
// to InvalidateEntry and MoveEntry are made.
// If |defrag_table| is true, the table will be defragmented after
// the entry has been invalidated.
//
// Threading: Method takes exclusive use of |usage_table_header_lock_|.
virtual CdmResponseType InvalidateEntry(uint32_t usage_entry_number,
// Threading: Method takes exclusive use of |lock_|.
virtual CdmResponseType InvalidateEntry(UsageEntryIndex entry_index,
bool defrag_table,
DeviceFiles* device_files,
metrics::CryptoMetrics* metrics);
@@ -107,13 +107,13 @@ class UsageTableHeader {
// for the objects that InvalidateEntry depends on.
//
// Threading: Method requires care of caller for exclusive access.
void InvalidateEntryForTest(uint32_t usage_entry_number);
void InvalidateEntryForTest(UsageEntryIndex entry_index);
// == Table information methods ==
// Threading: None of the following are thread safe. Intended for
// testing or internal use.
size_t size() { return usage_entry_info_.size(); }
size_t size() { return entry_info_list_.size(); }
size_t potential_table_capacity() const { return potential_table_capacity_; }
@@ -128,8 +128,8 @@ class UsageTableHeader {
// are related to offline licenses.
size_t OfflineEntryCount() const;
const std::vector<CdmUsageEntryInfo>& usage_entry_info() const {
return usage_entry_info_;
const std::vector<CdmUsageEntryInfo>& entry_info_list() const {
return entry_info_list_;
}
// Set the reference clock used for the method GetCurrentTime().
@@ -141,10 +141,10 @@ class UsageTableHeader {
}
static bool DetermineLicenseToRemoveForTesting(
const std::vector<CdmUsageEntryInfo>& usage_entry_info_list,
const std::vector<CdmUsageEntryInfo>& entry_info_list,
int64_t current_time, size_t unexpired_threshold,
uint32_t* entry_to_remove) {
return DetermineLicenseToRemove(usage_entry_info_list, current_time,
UsageEntryIndex* entry_to_remove) {
return DetermineLicenseToRemove(entry_info_list, current_time,
unexpired_threshold, entry_to_remove);
}
@@ -155,13 +155,13 @@ class UsageTableHeader {
// Creates a new, empty usage table. Any existing usage table files
// will be deleted.
// Threading: Method takes exclusive use of |usage_table_header_lock_|
// Threading: Method takes exclusive use of |lock_|
// when required.
bool CreateNewTable(CryptoSession* const crypto_session);
// Attempts to restore the usage table from persistent storage, and
// loads the usage table header into OEMCrypto.
// Note: No other OEMCrypto session should be opened before calling.
// Threading: Method takes exclusive use of |usage_table_header_lock_|
// Threading: Method takes exclusive use of |lock_|
// when required.
bool RestoreTable(CryptoSession* const crypto_session);
@@ -173,76 +173,73 @@ class UsageTableHeader {
// one more entry if the table is at or near the reported capacity.
// If this check fails, a new usage table SHOULD be created.
// Threading: Method requires caller to take exclusive use of
// |usage_table_header_lock_|.
// |lock_|.
bool CapacityCheck(CryptoSession* const crypto_session);
// Attempts to determine the capacity of the OEMCrypto usage table.
// Sets the result to |potential_table_capacity_|.
// Threading: Method requires caller to take exclusive use of
// |usage_table_header_lock_|.
// |lock_|.
bool DetermineTableCapacity(CryptoSession* crypto_session);
// == Table operation methods ==
// Threading: All of the following methods require caller to take
// exclusive use of |usage_table_header_lock_|.
// exclusive use of |lock_|.
// Creates a new entry for the provided crypto session. If the
// entry is created successfully in OEMCrypto, then a new entry
// info is added to the table's vector of entry info.
CdmResponseType CreateEntry(CryptoSession* const crypto_session,
uint32_t* usage_entry_number);
UsageEntryIndex* entry_index);
// Attempts to relocate a newly created usage entry associated with
// the provided |crypto_session| to the lowest unoccupied position in
// the table.
// |usage_entry_number| is treated as both an input and output.
// |entry_index| is treated as both an input and output.
// Returns NO_ERROR so long as no internal operation fails,
// regardless of whether the entry was moved or not.
CdmResponseType RelocateNewEntry(CryptoSession* const crypto_session,
uint32_t* usage_entry_number);
UsageEntryIndex* entry_index);
// Checks if the specified |usage_entry_number| is known to be
// Checks if the specified |entry_index| is known to be
// unoccupied (released).
bool IsEntryUnoccupied(const uint32_t usage_entry_number) const;
bool IsEntryUnoccupied(const UsageEntryIndex entry_index) const;
// SetOfflineEntryInfo() and SetUsageInfoEntryInfo() populate the
// entry meta-data with the required information based on the type
// of entry.
void SetOfflineEntryInfo(const uint32_t usage_entry_number,
void SetOfflineEntryInfo(const UsageEntryIndex entry_index,
const std::string& key_set_id,
const CdmKeyResponse& license_message);
void SetUsageInfoEntryInfo(const uint32_t usage_entry_number,
void SetUsageInfoEntryInfo(const UsageEntryIndex entry_index,
const std::string& key_set_id,
const std::string& usage_info_file_name);
// Shrinks the table, removing all trailing unoccupied entries.
// |usage_entry_info_| will be resized appropriately.
// |entry_info_list_| will be resized appropriately.
// Caller must store the table after a successful call.
CdmResponseType RefitTable(CryptoSession* const crypto_session);
virtual CdmResponseType InvalidateEntryInternal(
uint32_t usage_entry_number, bool defrag_table, DeviceFiles* device_files,
UsageEntryIndex entry_index, bool defrag_table, DeviceFiles* device_files,
metrics::CryptoMetrics* metrics);
CdmResponseType MoveEntry(uint32_t from /* usage entry number */,
const CdmUsageEntry& from_usage_entry,
uint32_t to /* usage entry number */,
DeviceFiles* device_files,
CdmResponseType MoveEntry(UsageEntryIndex from, const UsageEntry& from_entry,
UsageEntryIndex to, DeviceFiles* device_files,
metrics::CryptoMetrics* metrics);
CdmResponseType GetEntry(uint32_t usage_entry_number,
CdmResponseType GetEntry(UsageEntryIndex entry_index,
DeviceFiles* device_files, UsageEntry* entry);
CdmResponseType StoreEntry(UsageEntryIndex entry_index,
DeviceFiles* device_files,
CdmUsageEntry* usage_entry);
CdmResponseType StoreEntry(uint32_t usage_entry_number,
DeviceFiles* device_files,
const CdmUsageEntry& usage_entry);
const UsageEntry& entry);
// Stores the usage table and it's info. This will increment
// |store_table_counter_| if successful.
bool StoreTable();
CdmResponseType Shrink(metrics::CryptoMetrics* metrics,
uint32_t number_of_usage_entries_to_delete);
uint32_t number_of_entries_to_delete);
// Must lock table before calling.
CdmResponseType DefragTable(DeviceFiles* device_files,
@@ -286,7 +283,7 @@ class UsageTableHeader {
// types.
//
// Parameters:
// [in] usage_entry_info_list: The complete list of known usage
// [in] entry_info_list: The complete list of known usage
// entries.
// [in] current_time: The current time to compare expiration times
// against.
@@ -301,20 +298,20 @@ class UsageTableHeader {
// |true| if an entry has been determined to be removed.
// Otherwise returns |false|.
static bool DetermineLicenseToRemove(
const std::vector<CdmUsageEntryInfo>& usage_entry_info_list,
const std::vector<CdmUsageEntryInfo>& entry_info_list,
int64_t current_time, size_t unexpired_threshold,
uint32_t* entry_to_remove);
UsageEntryIndex* entry_to_remove);
// This handle and file system is only to be used when accessing
// usage_table_header. Usage entries should use the file system provided
// header. Usage entries should use the file system provided
// by CdmSession.
std::unique_ptr<DeviceFiles> device_files_;
std::unique_ptr<wvutil::FileSystem> file_system_;
CdmSecurityLevel security_level_ = kSecurityLevelUninitialized;
RequestedSecurityLevel requested_security_level_ = kLevelDefault;
CdmUsageTableHeader usage_table_header_;
std::vector<CdmUsageEntryInfo> usage_entry_info_;
UsageTableHeader header_;
std::vector<CdmUsageEntryInfo> entry_info_list_;
// Table is sync with persistent storage and can be used by the CDM
// to interact with OEMCrypto.
@@ -322,7 +319,7 @@ class UsageTableHeader {
// Synchonizes access to the Usage Table Header and bookkeeping
// data-structures
mutable std::mutex usage_table_header_lock_;
mutable std::mutex lock_;
metrics::CryptoMetrics alternate_crypto_metrics_;
@@ -347,12 +344,12 @@ class UsageTableHeader {
#if defined(UNIT_TEST)
// Test related declarations
friend class UsageTableHeaderTest;
friend class CdmUsageTableTest;
FRIEND_TEST(UsageTableHeaderTest, Shrink_NoneOfTable);
FRIEND_TEST(UsageTableHeaderTest, Shrink_PartOfTable);
FRIEND_TEST(UsageTableHeaderTest, Shrink_AllOfTable);
FRIEND_TEST(UsageTableHeaderTest, Shrink_MoreThanTable);
FRIEND_TEST(CdmUsageTableTest, Shrink_NoneOfTable);
FRIEND_TEST(CdmUsageTableTest, Shrink_PartOfTable);
FRIEND_TEST(CdmUsageTableTest, Shrink_AllOfTable);
FRIEND_TEST(CdmUsageTableTest, Shrink_MoreThanTable);
#endif
// These setters are for testing only. Takes ownership of the pointers.
@@ -366,9 +363,9 @@ class UsageTableHeader {
// Test related data members
std::unique_ptr<CryptoSession> test_crypto_session_;
CORE_DISALLOW_COPY_AND_ASSIGN(UsageTableHeader);
CORE_DISALLOW_COPY_AND_ASSIGN(CdmUsageTable);
};
} // namespace wvcdm
#endif // WVCDM_CORE_USAGE_TABLE_HEADER_H_
#endif // WVCDM_CORE_CDM_USAGE_TABLE_H_

48
libwvdrmengine/cdm/core/include/crypto_session.h
View File

@@ -26,7 +26,7 @@ namespace wvcdm {
class CryptoKey;
class CryptoSessionFactory;
class OtaKeyboxProvisioner;
class UsageTableHeader;
class CdmUsageTable;
namespace okp {
class SystemFallbackPolicy;
@@ -273,12 +273,12 @@ class CryptoSession {
// Used to manipulate the CDM managed usage table header & entries,
// delegating calls to OEMCrypto.
// Determines whether the OEMCrypto library supports usage info.
// Determines whether the OEMCrypto library supports usage table.
// As of V16, the only valid type of support is usage table header +
// usage entries.
// The first method will use a cached value if present.
virtual bool HasUsageInfoSupport(bool* has_support);
virtual bool HasUsageInfoSupport(RequestedSecurityLevel security_level,
virtual bool HasUsageTableSupport(bool* has_support);
virtual bool HasUsageTableSupport(RequestedSecurityLevel security_level,
bool* has_support);
// Usage report.
@@ -290,30 +290,28 @@ class CryptoSession {
int64_t* seconds_since_started, int64_t* seconds_since_last_played);
// Usage table header.
virtual UsageTableHeader* GetUsageTableHeader() {
return usage_table_header_;
}
virtual CdmUsageTable* GetUsageTable() { return usage_table_; }
// The following crypto methods do not require an open session to
// complete the operations.
virtual CdmResponseType CreateUsageTableHeader(
RequestedSecurityLevel requested_security_level,
CdmUsageTableHeader* usage_table_header);
UsageTableHeader* usage_table_header);
virtual CdmResponseType LoadUsageTableHeader(
RequestedSecurityLevel requested_security_level,
const CdmUsageTableHeader& usage_table_header);
const UsageTableHeader& usage_table_header);
virtual CdmResponseType ShrinkUsageTableHeader(
RequestedSecurityLevel requested_security_level, uint32_t new_entry_count,
CdmUsageTableHeader* usage_table_header);
UsageTableHeader* usage_table_header);
// Usage entry.
virtual CdmResponseType CreateUsageEntry(uint32_t* entry_number);
virtual CdmResponseType LoadUsageEntry(uint32_t entry_number,
const CdmUsageEntry& usage_entry);
virtual CdmResponseType UpdateUsageEntry(
CdmUsageTableHeader* usage_table_header, CdmUsageEntry* usage_entry);
virtual CdmResponseType CreateUsageEntry(UsageEntryIndex* entry_index);
virtual CdmResponseType LoadUsageEntry(UsageEntryIndex entry_index,
const UsageEntry& usage_entry);
virtual CdmResponseType UpdateUsageEntry(UsageTableHeader* usage_table_header,
UsageEntry* usage_entry);
// Adjust usage entries in usage table header.
virtual CdmResponseType MoveUsageEntry(uint32_t new_entry_number);
virtual CdmResponseType MoveUsageEntry(UsageEntryIndex new_entry_index);
virtual bool GetAnalogOutputCapabilities(bool* can_support_output,
bool* can_disable_output,
@@ -384,11 +382,11 @@ class CryptoSession {
void Init();
// Will set up the UsageTableHeader for this session. This may require
// creating a new UsageTableHeader if the global instance has not
// Will set up the CdmUsageTable for this session. This may require
// creating a new CdmUsageTable if the global instance has not
// been initialized.
// Note: This function will lock the global static field lock in write mode.
bool SetUpUsageTableHeader(RequestedSecurityLevel requested_security_level);
bool SetUpUsageTable(RequestedSecurityLevel requested_security_level);
CdmResponseType GenerateRsaSignature(const std::string& message,
std::string* signature);
@@ -399,10 +397,10 @@ class CryptoSession {
CdmResponseType SelectKey(const std::string& key_id,
CdmCipherMode cipher_mode);
// Retrieves the OEMCrypto usage info support for the specified
// Retrieves the OEMCrypto usage table support for the specified
// |requested_security_level|.
// Caller should acquire the OEMCrypto read lock before calling.
bool HasUsageInfoSupportInternal(
bool HasUsageTableSupportInternal(
RequestedSecurityLevel requested_security_level, bool* has_support);
// These methods fall back into each other in the order given, depending on
@@ -526,12 +524,12 @@ class CryptoSession {
RequestedSecurityLevel requested_security_level_;
// Open session-cached result of OEMCrypto_SupportsUsageTable().
CachedBooleanProperty has_usage_info_support_ = kBooleanUnset;
UsageTableHeader* usage_table_header_ = nullptr;
CachedBooleanProperty has_usage_table_support_ = kBooleanUnset;
CdmUsageTable* usage_table_ = nullptr;
// These fields are protected by |usage_table_mutex_| and not
// |static_field_mutex_|.
static std::unique_ptr<UsageTableHeader> usage_table_header_l1_;
static std::unique_ptr<UsageTableHeader> usage_table_header_l3_;
static std::unique_ptr<CdmUsageTable> usage_table_l1_;
static std::unique_ptr<CdmUsageTable> usage_table_l3_;
std::string request_id_;
static std::atomic<uint64_t> request_id_index_source_;

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

@@ -97,8 +97,8 @@ class DeviceFiles {
// App parameters.
CdmAppParameterMap app_parameters;
// Usage entry and index.
CdmUsageEntry usage_entry;
uint32_t usage_entry_number;
UsageEntry usage_entry;
UsageEntryIndex usage_entry_index;
std::string drm_certificate;
CryptoWrappedKey wrapped_private_key;
};
@@ -108,8 +108,8 @@ class DeviceFiles {
CdmKeyMessage license_request;
CdmKeyResponse license;
std::string key_set_id;
CdmUsageEntry usage_entry;
uint32_t usage_entry_number;
UsageEntry usage_entry;
UsageEntryIndex usage_entry_index;
std::string drm_certificate;
CryptoWrappedKey wrapped_private_key;
};
@@ -183,7 +183,7 @@ class DeviceFiles {
const std::string& provider_session_token,
const CdmKeyMessage& key_request, const CdmKeyResponse& key_response,
const std::string& usage_info_file_name, const std::string& key_set_id,
const CdmUsageEntry& usage_entry, uint32_t usage_entry_number,
const UsageEntry& usage_entry, UsageEntryIndex usage_entry_index,
const std::string& drm_certificate, const CryptoWrappedKey& wrapped_key);
// Retrieve usage identifying information stored on the file system.
@@ -236,8 +236,8 @@ class DeviceFiles {
const std::string& provider_session_token,
CdmKeyMessage* license_request,
CdmKeyResponse* license_response,
CdmUsageEntry* usage_entry,
uint32_t* usage_entry_number,
UsageEntry* usage_entry,
UsageEntryIndex* usage_entry_index,
std::string* drm_certificate,
CryptoWrappedKey* wrapped_key);
// Retrieve the usage info entry specified by |key_set_id|.
@@ -245,8 +245,8 @@ class DeviceFiles {
virtual bool RetrieveUsageInfoByKeySetId(
const std::string& usage_info_file_name, const std::string& key_set_id,
std::string* provider_session_token, CdmKeyMessage* license_request,
CdmKeyResponse* license_response, CdmUsageEntry* usage_entry,
uint32_t* usage_entry_number, std::string* drm_certificate,
CdmKeyResponse* license_response, UsageEntry* usage_entry,
UsageEntryIndex* usage_entry_index, std::string* drm_certificate,
CryptoWrappedKey* wrapped_key);
// These APIs support upgrading from usage tables to usage tabler header +
@@ -274,15 +274,15 @@ class DeviceFiles {
virtual bool DeleteHlsAttributes(const std::string& key_set_id);
virtual bool StoreUsageTableInfo(
const CdmUsageTableHeader& usage_table_header,
const std::vector<CdmUsageEntryInfo>& usage_entry_info);
const UsageTableHeader& usage_table_header,
const std::vector<CdmUsageEntryInfo>& usage_entry_info_list);
// When retrieving usage table information from the file system; any
// table that has yet to be updated for the LRU attributes will be
// indicated by |lru_upgrade|.
virtual bool RetrieveUsageTableInfo(
CdmUsageTableHeader* usage_table_header,
std::vector<CdmUsageEntryInfo>* usage_entry_info, bool* lru_upgrade);
UsageTableHeader* usage_table_header,
std::vector<CdmUsageEntryInfo>* usage_entry_info_list, bool* lru_upgrade);
virtual bool DeleteUsageTableInfo();

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

@@ -25,7 +25,6 @@ using CdmSecureStopId = std::string;
using CdmSessionId = std::string;
using CdmKeySetId = std::string;
using RequestId = std::string;
using CryptoResult = uint32_t;
using CryptoSessionId = uint32_t;
using EntitledKeySessionId = uint32_t;
using CdmAppParameterMap = std::map<std::string, std::string>;
@@ -34,8 +33,11 @@ using CdmUsageInfo = std::vector<std::string>;
using CdmUsageInfoReleaseMessage = std::string;
using CdmProvisioningRequest = std::string;
using CdmProvisioningResponse = std::string;
using CdmUsageTableHeader = std::string;
using CdmUsageEntry = std::string;
// OEMCrypto's usage table information.
using UsageTableHeader = std::string;
using UsageEntry = std::string;
using UsageEntryIndex = uint32_t;
enum CdmKeyRequestType : uint32_t {
kKeyRequestTypeUnknown,

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

@@ -607,11 +607,11 @@ CdmResponseType CdmEngine::QueryStatus(RequestedSecurityLevel security_level,
}
if (query_token == QUERY_KEY_USAGE_SUPPORT) {
bool supports_usage_reporting;
const bool got_info = crypto_session->HasUsageInfoSupport(
const bool got_info = crypto_session->HasUsageTableSupport(
security_level, &supports_usage_reporting);
if (!got_info) {
LOGW("HasUsageInfoSupport failed");
LOGW("HasUsageTableSupport failed");
metrics_->GetCryptoMetrics()
->crypto_session_usage_information_support_.SetError(got_info);
return CdmResponseType(UNKNOWN_ERROR);
@@ -1661,7 +1661,7 @@ CdmResponseType CdmEngine::RemoveAllUsageInfo(
usage_session_.reset(new CdmSession(file_system_, metrics_->AddSession()));
usage_session_->Init(usage_property_set_.get());
if (usage_session_->supports_usage_info()) {
if (usage_session_->SupportsUsageTable()) {
std::vector<DeviceFiles::CdmUsageData> usage_data;
// Retrieve all usage information but delete only one before
// refetching. This is because deleting the usage entry
@@ -1676,7 +1676,7 @@ CdmResponseType CdmEngine::RemoveAllUsageInfo(
if (usage_data.empty()) break;
CdmResponseType res =
usage_session_->DeleteUsageEntry(usage_data[0].usage_entry_number);
usage_session_->DeleteUsageEntry(usage_data[0].usage_entry_index);
if (res != NO_ERROR) {
LOGW("Failed to delete usage entry: status = %d",
@@ -1739,21 +1739,21 @@ CdmResponseType CdmEngine::RemoveUsageInfo(
CdmKeyMessage license_request;
CdmKeyResponse license_response;
CdmUsageEntry usage_entry;
uint32_t usage_entry_number;
UsageEntry usage_entry;
UsageEntryIndex usage_entry_index;
std::string drm_certificate;
CryptoWrappedKey wrapped_private_key;
if (!handle.RetrieveUsageInfo(
DeviceFiles::GetUsageInfoFileName(app_id), provider_session_token,
&license_request, &license_response, &usage_entry,
&usage_entry_number, &drm_certificate, &wrapped_private_key)) {
&usage_entry_index, &drm_certificate, &wrapped_private_key)) {
// Try other security level
continue;
}
if (usage_session_->supports_usage_info()) {
status = usage_session_->DeleteUsageEntry(usage_entry_number);
if (usage_session_->SupportsUsageTable()) {
status = usage_session_->DeleteUsageEntry(usage_entry_index);
if (!handle.DeleteUsageInfo(DeviceFiles::GetUsageInfoFileName(app_id),
provider_session_token)) {
status = CdmResponseType(REMOVE_USAGE_INFO_ERROR_1);
@@ -1820,7 +1820,7 @@ CdmResponseType CdmEngine::LoadUsageSession(const CdmKeySetId& key_set_id,
DeviceFiles::GetUsageInfoFileName(app_id), key_set_id,
&(usage_data.provider_session_token), &(usage_data.license_request),
&(usage_data.license), &(usage_data.usage_entry),
&(usage_data.usage_entry_number), &(usage_data.drm_certificate),
&(usage_data.usage_entry_index), &(usage_data.drm_certificate),
&(usage_data.wrapped_private_key))) {
LOGE("Unable to find usage information");
return CdmResponseType(LOAD_USAGE_INFO_MISSING);
@@ -2149,7 +2149,7 @@ void CdmEngine::OnTimerEvent() {
for (CdmSessionList::iterator iter = sessions.begin();
iter != sessions.end(); ++iter) {
(*iter)->reset_usage_flags();
if ((*iter)->supports_usage_info() &&
if ((*iter)->SupportsUsageTable() &&
(*iter)->has_provider_session_token()) {
(*iter)->UpdateUsageEntryInformation();
}

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

709
libwvdrmengine/cdm/core/src/usage_table_header.cpp → libwvdrmengine/cdm/core/src/cdm_usage_table.cpp
View File

File diff suppressed because it is too large Load Diff

6
libwvdrmengine/cdm/core/src/client_identification.cpp
View File

@@ -229,9 +229,9 @@ CdmResponseType ClientIdentification::Prepare(
client_capabilities->set_client_token(true);
if (is_license_request_) {
bool supports_usage_information;
if (crypto_session_->HasUsageInfoSupport(&supports_usage_information)) {
client_capabilities->set_session_token(supports_usage_information);
bool supports_usage_table;
if (crypto_session_->HasUsageTableSupport(&supports_usage_table)) {
client_capabilities->set_session_token(supports_usage_table);
}
client_capabilities->set_anti_rollback_usage_table(

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

@@ -17,6 +17,7 @@
#include "advance_iv_ctr.h"
#include "arraysize.h"
#include "cdm_random.h"
#include "cdm_usage_table.h"
#include "content_key_session.h"
#include "crypto_key.h"
#include "entitlement_key_session.h"
@@ -28,7 +29,6 @@
#include "properties.h"
#include "pst_report.h"
#include "string_conversions.h"
#include "usage_table_header.h"
#include "wv_cdm_constants.h"
// Stringify turns macro arguments into static C strings.
@@ -211,8 +211,8 @@ bool CryptoSession::initialized_ = false;
bool CryptoSession::needs_keybox_provisioning_ = false;
int CryptoSession::session_count_ = 0;
int CryptoSession::termination_counter_ = 0;
std::unique_ptr<UsageTableHeader> CryptoSession::usage_table_header_l1_;
std::unique_ptr<UsageTableHeader> CryptoSession::usage_table_header_l3_;
std::unique_ptr<CdmUsageTable> CryptoSession::usage_table_l1_;
std::unique_ptr<CdmUsageTable> CryptoSession::usage_table_l3_;
std::recursive_mutex CryptoSession::usage_table_mutex_;
std::atomic<uint64_t> CryptoSession::request_id_index_source_(0);
std::unique_ptr<okp::SystemFallbackPolicy>
@@ -400,8 +400,8 @@ void CryptoSession::ReinitializeForTest() {
}
initialized_ = false;
// Tables will be reinitialized by tests when needed.
usage_table_header_l1_.reset();
usage_table_header_l3_.reset();
usage_table_l1_.reset();
usage_table_l3_.reset();
}
// Give up if we cannot initialize at all.
const OEMCryptoResult status = OEMCrypto_Initialize();
@@ -479,8 +479,8 @@ bool CryptoSession::TryTerminate() {
});
if (terminated) {
UsageTableLock lock(usage_table_mutex_);
usage_table_header_l1_.reset();
usage_table_header_l3_.reset();
usage_table_l1_.reset();
usage_table_l3_.reset();
}
return terminated;
}
@@ -491,9 +491,9 @@ void CryptoSession::DisableDelayedTermination() {
[&] { termination_counter_ = 0; });
}
bool CryptoSession::SetUpUsageTableHeader(
bool CryptoSession::SetUpUsageTable(
RequestedSecurityLevel requested_security_level) {
if (usage_table_header_ != nullptr) {
if (usage_table_ != nullptr) {
LOGE("Usage table is already set up for the current crypto session");
return false;
}
@@ -508,7 +508,7 @@ bool CryptoSession::SetUpUsageTableHeader(
// Check if usage support is available.
bool supports_usage_table = false;
if (!HasUsageInfoSupport(requested_security_level, &supports_usage_table)) {
if (!HasUsageTableSupport(requested_security_level, &supports_usage_table)) {
metrics_->oemcrypto_usage_table_support_.SetError(
USAGE_INFORMATION_SUPPORT_FAILED);
return false;
@@ -519,30 +519,28 @@ bool CryptoSession::SetUpUsageTableHeader(
return false;
}
LOGV("Usage table lock: SetUpUsageTableHeader()");
LOGV("Usage table lock: SetUpUsageTable()");
UsageTableLock auto_lock(usage_table_mutex_);
// TODO(b/141350978): Prevent any recursive logic.
// Manipulate only the usage table for the requested security level.
std::unique_ptr<UsageTableHeader>& header = security_level == kSecurityLevelL1
? usage_table_header_l1_
: usage_table_header_l3_;
if (!header) {
std::unique_ptr<CdmUsageTable>& table =
security_level == kSecurityLevelL1 ? usage_table_l1_ : usage_table_l3_;
if (!table) {
// This may be called twice within the same thread when the table
// is initialized. On the second call |header| will not be null,
// causing this block to be skipped.
header.reset(new UsageTableHeader());
if (!header->Init(security_level, this)) {
table.reset(new CdmUsageTable());
if (!table->Init(security_level, this)) {
LOGE("Failed to initialize and sync usage usage table");
// Must be cleared globally to prevent the next session to be
// opened from using the invalid UsageTableHeader.
header.reset();
// opened from using the invalid CdmUsageTable.
table.reset();
return false;
}
}
usage_table_header_ = header.get();
metrics_->usage_table_header_initial_size_.Record(
usage_table_header_->size());
usage_table_ = table.get();
metrics_->usage_table_header_initial_size_.Record(usage_table_->size());
return true;
}
@@ -890,7 +888,7 @@ CdmResponseType CryptoSession::Open(
RETURN_IF_UNINITIALIZED(CRYPTO_SESSION_NOT_INITIALIZED);
if (open_) return CdmResponseType(NO_ERROR);
if (!SetUpUsageTableHeader(requested_security_level)) {
if (!SetUpUsageTable(requested_security_level)) {
// Ignore errors since we do not know when a session is opened,
// if it is intended to be used for offline/usage session related
// or otherwise.
@@ -962,7 +960,7 @@ void CryptoSession::Close() {
metrics_->oemcrypto_close_session_.Increment(close_sts);
// Clear cached values.
has_usage_info_support_ = kBooleanUnset;
has_usage_table_support_ = kBooleanUnset;
oem_token_.clear();
system_id_ = NULL_SYSTEM_ID;
pre_provision_token_type_ = kClientTokenUninitialized;
@@ -975,7 +973,7 @@ void CryptoSession::Close() {
case OEMCrypto_SUCCESS:
case OEMCrypto_ERROR_INVALID_SESSION:
case OEMCrypto_ERROR_SYSTEM_INVALIDATED:
usage_table_header_ = nullptr;
usage_table_ = nullptr;
open_ = false;
break;
case OEMCrypto_ERROR_CLOSE_SESSION_FAILED:
@@ -1837,38 +1835,38 @@ CdmResponseType CryptoSession::Decrypt(
}
}
bool CryptoSession::HasUsageInfoSupport(bool* has_support) {
bool CryptoSession::HasUsageTableSupport(bool* has_support) {
RETURN_IF_NOT_OPEN(false);
RETURN_IF_NULL(has_support, false);
return WithOecReadLock("HasUsageInfoSupport", [&] {
return WithOecReadLock("HasUsageTableSupport", [&] {
// Use cached value if set.
if (has_usage_info_support_ != kBooleanUnset) {
*has_support = (has_usage_info_support_ == kBooleanTrue);
if (has_usage_table_support_ != kBooleanUnset) {
*has_support = (has_usage_table_support_ == kBooleanTrue);
return true;
}
if (!HasUsageInfoSupportInternal(requested_security_level_, has_support)) {
if (!HasUsageTableSupportInternal(requested_security_level_, has_support)) {
return false;
}
// Cache result if successful.
has_usage_info_support_ = (*has_support ? kBooleanTrue : kBooleanFalse);
has_usage_table_support_ = (*has_support ? kBooleanTrue : kBooleanFalse);
return true;
});
}
bool CryptoSession::HasUsageInfoSupport(
bool CryptoSession::HasUsageTableSupport(
RequestedSecurityLevel requested_security_level, bool* has_support) {
RETURN_IF_UNINITIALIZED(false);
RETURN_IF_NULL(has_support, false);
return WithOecReadLock("HasUsageInfoSupport", [&] {
return HasUsageInfoSupportInternal(requested_security_level, has_support);
return WithOecReadLock("HasUsageTableSupport", [&] {
return HasUsageTableSupportInternal(requested_security_level, has_support);
});
}
bool CryptoSession::HasUsageInfoSupportInternal(
bool CryptoSession::HasUsageTableSupportInternal(
RequestedSecurityLevel requested_security_level, bool* has_support) {
LOGV("requested_security_level = %s",
RequestedSecurityLevelToString(requested_security_level));
*has_support = WithOecReadLock("HasUsageInfoSupport", [&] {
*has_support = WithOecReadLock("HasUsageTableSupport", [&] {
return OEMCrypto_SupportsUsageTable(requested_security_level);
});
return true;
@@ -2646,7 +2644,7 @@ CdmResponseType CryptoSession::GenericVerify(const std::string& message,
CdmResponseType CryptoSession::CreateUsageTableHeader(
RequestedSecurityLevel requested_security_level,
CdmUsageTableHeader* usage_table_header) {
UsageTableHeader* usage_table_header) {
LOGV("Creating usage table header: requested_security_level = %s",
RequestedSecurityLevelToString(requested_security_level));
RETURN_IF_NULL(usage_table_header, PARAMETER_NULL);
@@ -2687,7 +2685,7 @@ CdmResponseType CryptoSession::CreateUsageTableHeader(
CdmResponseType CryptoSession::LoadUsageTableHeader(
RequestedSecurityLevel requested_security_level,
const CdmUsageTableHeader& usage_table_header) {
const UsageTableHeader& usage_table_header) {
LOGV("Loading usage table header: requested_security_level = %s",
RequestedSecurityLevelToString(requested_security_level));
@@ -2728,7 +2726,7 @@ CdmResponseType CryptoSession::LoadUsageTableHeader(
CdmResponseType CryptoSession::ShrinkUsageTableHeader(
RequestedSecurityLevel requested_security_level, uint32_t new_entry_count,
CdmUsageTableHeader* usage_table_header) {
UsageTableHeader* usage_table_header) {
LOGV("Shrinking usage table header: requested_security_level = %s",
RequestedSecurityLevelToString(requested_security_level));
RETURN_IF_NULL(usage_table_header, PARAMETER_NULL);
@@ -2766,14 +2764,14 @@ CdmResponseType CryptoSession::ShrinkUsageTableHeader(
}
}
CdmResponseType CryptoSession::CreateUsageEntry(uint32_t* entry_number) {
CdmResponseType CryptoSession::CreateUsageEntry(UsageEntryIndex* entry_index) {
LOGV("Creating usage entry: id = %u", oec_session_id_);
RETURN_IF_NULL(entry_number, PARAMETER_NULL);
RETURN_IF_NULL(entry_index, PARAMETER_NULL);
OEMCryptoResult result;
WithOecWriteLock("CreateUsageEntry", [&] {
result = OEMCrypto_CreateNewUsageEntry(oec_session_id_, entry_number);
result = OEMCrypto_CreateNewUsageEntry(oec_session_id_, entry_index);
metrics_->oemcrypto_create_new_usage_entry_.Increment(result);
});
@@ -2796,14 +2794,14 @@ CdmResponseType CryptoSession::CreateUsageEntry(uint32_t* entry_number) {
}
}
CdmResponseType CryptoSession::LoadUsageEntry(
uint32_t entry_number, const CdmUsageEntry& usage_entry) {
CdmResponseType CryptoSession::LoadUsageEntry(UsageEntryIndex entry_index,
const UsageEntry& usage_entry) {
LOGV("Loading usage entry: id = %u", oec_session_id_);
OEMCryptoResult result;
WithOecWriteLock("LoadUsageEntry", [&] {
result = OEMCrypto_LoadUsageEntry(
oec_session_id_, entry_number,
oec_session_id_, entry_index,
reinterpret_cast<const uint8_t*>(usage_entry.data()),
usage_entry.size());
metrics_->oemcrypto_load_usage_entry_.Increment(result);
@@ -2839,7 +2837,7 @@ CdmResponseType CryptoSession::LoadUsageEntry(
}
CdmResponseType CryptoSession::UpdateUsageEntry(
CdmUsageTableHeader* usage_table_header, CdmUsageEntry* usage_entry) {
UsageTableHeader* usage_table_header, UsageEntry* usage_entry) {
LOGV("Updating usage entry: id = %u", oec_session_id_);
RETURN_IF_NULL(usage_table_header, PARAMETER_NULL);
@@ -2880,19 +2878,19 @@ CdmResponseType CryptoSession::UpdateUsageEntry(
"UpdateUsageEntry");
}
CdmResponseType CryptoSession::MoveUsageEntry(uint32_t new_entry_number) {
CdmResponseType CryptoSession::MoveUsageEntry(UsageEntryIndex new_entry_index) {
LOGV("Moving usage entry: id = %u", oec_session_id_);
OEMCryptoResult result;
WithOecWriteLock("MoveUsageEntry", [&] {
result = OEMCrypto_MoveEntry(oec_session_id_, new_entry_number);
result = OEMCrypto_MoveEntry(oec_session_id_, new_entry_index);
metrics_->oemcrypto_move_entry_.Increment(result);
});
switch (result) {
case OEMCrypto_ERROR_ENTRY_IN_USE:
LOGW("OEMCrypto_MoveEntry failed: Destination index in use: index = %u",
new_entry_number);
new_entry_index);
return CRYPTO_ERROR(MOVE_USAGE_ENTRY_DESTINATION_IN_USE, result);
default:
return MapOEMCryptoResult(result, MOVE_USAGE_ENTRY_UNKNOWN_ERROR,

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

@@ -838,7 +838,7 @@ bool DeviceFiles::StoreLicense(const CdmLicenseData& license_data,
app_params->set_value(iter->second);
}
license->set_usage_entry(license_data.usage_entry);
license->set_usage_entry_number(license_data.usage_entry_number);
license->set_usage_entry_index(license_data.usage_entry_index);
if (!license_data.drm_certificate.empty()) {
DeviceCertificate* device_certificate = license->mutable_drm_certificate();
if (!SetDeviceCertificate(license_data.drm_certificate,
@@ -929,8 +929,8 @@ bool DeviceFiles::RetrieveLicense(const std::string& key_set_id,
license.app_parameters(i).value();
}
license_data->usage_entry = license.usage_entry();
license_data->usage_entry_number =
static_cast<uint32_t>(license.usage_entry_number());
license_data->usage_entry_index =
static_cast<uint32_t>(license.usage_entry_index());
if (!license.has_drm_certificate()) {
license_data->drm_certificate.clear();
@@ -1015,8 +1015,8 @@ bool DeviceFiles::UnreserveLicenseId(const std::string& key_set_id) {
bool DeviceFiles::StoreUsageInfo(
const std::string& provider_session_token, const CdmKeyMessage& key_request,
const CdmKeyResponse& key_response, const std::string& usage_info_file_name,
const std::string& key_set_id, const std::string& usage_entry,
uint32_t usage_entry_number, const std::string& drm_certificate,
const std::string& key_set_id, const UsageEntry& usage_entry,
UsageEntryIndex usage_entry_index, const std::string& drm_certificate,
const CryptoWrappedKey& wrapped_private_key) {
RETURN_FALSE_IF_UNINITIALIZED();
video_widevine_client::sdk::File file;
@@ -1039,7 +1039,7 @@ bool DeviceFiles::StoreUsageInfo(
provider_session->set_license(key_response.data(), key_response.size());
provider_session->set_key_set_id(key_set_id.data(), key_set_id.size());
provider_session->set_usage_entry(usage_entry);
provider_session->set_usage_entry_number(usage_entry_number);
provider_session->set_usage_entry_index(usage_entry_index);
if (drm_certificate.size() > 0) {
uint32_t drm_certificate_id;
@@ -1240,15 +1240,15 @@ bool DeviceFiles::RetrieveUsageInfo(const std::string& usage_info_file_name,
const std::string& provider_session_token,
CdmKeyMessage* license_request,
CdmKeyResponse* license,
std::string* usage_entry,
uint32_t* usage_entry_number,
UsageEntry* usage_entry,
UsageEntryIndex* usage_entry_index,
std::string* drm_certificate,
CryptoWrappedKey* wrapped_private_key) {
RETURN_FALSE_IF_UNINITIALIZED();
RETURN_FALSE_IF_NULL(license_request);
RETURN_FALSE_IF_NULL(license);
RETURN_FALSE_IF_NULL(usage_entry);
RETURN_FALSE_IF_NULL(usage_entry_number);
RETURN_FALSE_IF_NULL(usage_entry_index);
RETURN_FALSE_IF_NULL(drm_certificate);
RETURN_FALSE_IF_NULL(wrapped_private_key);
@@ -1264,8 +1264,8 @@ bool DeviceFiles::RetrieveUsageInfo(const std::string& usage_info_file_name,
*license_request = file.usage_info().sessions(index).license_request();
*license = file.usage_info().sessions(index).license();
*usage_entry = file.usage_info().sessions(index).usage_entry();
*usage_entry_number = static_cast<uint32_t>(
file.usage_info().sessions(index).usage_entry_number());
*usage_entry_index = static_cast<UsageEntryIndex>(
file.usage_info().sessions(index).usage_entry_index());
if (!file.usage_info().sessions(index).has_drm_certificate_id()) {
drm_certificate->clear();
@@ -1290,14 +1290,14 @@ bool DeviceFiles::RetrieveUsageInfo(const std::string& usage_info_file_name,
bool DeviceFiles::RetrieveUsageInfoByKeySetId(
const std::string& usage_info_file_name, const std::string& key_set_id,
std::string* provider_session_token, CdmKeyMessage* license_request,
CdmKeyResponse* license, std::string* usage_entry,
uint32_t* usage_entry_number, std::string* drm_certificate,
CdmKeyResponse* license, UsageEntry* usage_entry,
UsageEntryIndex* usage_entry_index, std::string* drm_certificate,
CryptoWrappedKey* wrapped_private_key) {
RETURN_FALSE_IF_UNINITIALIZED();
RETURN_FALSE_IF_NULL(license_request);
RETURN_FALSE_IF_NULL(license);
RETURN_FALSE_IF_NULL(usage_entry);
RETURN_FALSE_IF_NULL(usage_entry_number);
RETURN_FALSE_IF_NULL(usage_entry_index);
RETURN_FALSE_IF_NULL(drm_certificate);
RETURN_FALSE_IF_NULL(wrapped_private_key);
@@ -1314,8 +1314,8 @@ bool DeviceFiles::RetrieveUsageInfoByKeySetId(
*license_request = file.usage_info().sessions(index).license_request();
*license = file.usage_info().sessions(index).license();
*usage_entry = file.usage_info().sessions(index).usage_entry();
*usage_entry_number = static_cast<uint32_t>(
file.usage_info().sessions(index).usage_entry_number());
*usage_entry_index = static_cast<UsageEntryIndex>(
file.usage_info().sessions(index).usage_entry_index());
if (!file.usage_info().sessions(index).has_drm_certificate_id()) {
drm_certificate->clear();
@@ -1359,7 +1359,7 @@ bool DeviceFiles::StoreUsageInfo(const std::string& usage_info_file_name,
provider_session->set_key_set_id(usage_data[i].key_set_id.data(),
usage_data[i].key_set_id.size());
provider_session->set_usage_entry(usage_data[i].usage_entry);
provider_session->set_usage_entry_number(usage_data[i].usage_entry_number);
provider_session->set_usage_entry_index(usage_data[i].usage_entry_index);
if (usage_data[i].drm_certificate.size() > 0) {
uint32_t drm_certificate_id;
@@ -1404,7 +1404,7 @@ bool DeviceFiles::UpdateUsageInfo(const std::string& usage_info_file_name,
provider_session->set_license(usage_data.license);
provider_session->set_key_set_id(usage_data.key_set_id);
provider_session->set_usage_entry(usage_data.usage_entry);
provider_session->set_usage_entry_number(usage_data.usage_entry_number);
provider_session->set_usage_entry_index(usage_data.usage_entry_index);
if (usage_data.drm_certificate.size() > 0) {
uint32_t drm_certificate_id;
@@ -1453,8 +1453,8 @@ bool DeviceFiles::RetrieveUsageInfo(const std::string& usage_info_file_name,
(*usage_data)[i].license = file.usage_info().sessions(i).license();
(*usage_data)[i].key_set_id = file.usage_info().sessions(i).key_set_id();
(*usage_data)[i].usage_entry = file.usage_info().sessions(i).usage_entry();
(*usage_data)[i].usage_entry_number = static_cast<uint32_t>(
file.usage_info().sessions(i).usage_entry_number());
(*usage_data)[i].usage_entry_index = static_cast<uint32_t>(
file.usage_info().sessions(i).usage_entry_index());
if (!file.usage_info().sessions(i).has_drm_certificate_id()) {
(*usage_data)[i].drm_certificate.clear();
@@ -1495,8 +1495,8 @@ bool DeviceFiles::RetrieveUsageInfo(const std::string& usage_info_file_name,
usage_data->license = file.usage_info().sessions(index).license();
usage_data->key_set_id = file.usage_info().sessions(index).key_set_id();
usage_data->usage_entry = file.usage_info().sessions(index).usage_entry();
usage_data->usage_entry_number = static_cast<uint32_t>(
file.usage_info().sessions(index).usage_entry_number());
usage_data->usage_entry_index = static_cast<uint32_t>(
file.usage_info().sessions(index).usage_entry_index());
if (!file.usage_info().sessions(index).has_drm_certificate_id()) {
usage_data->drm_certificate.clear();
@@ -1634,8 +1634,8 @@ bool DeviceFiles::DeleteHlsAttributes(const std::string& key_set_id) {
}
bool DeviceFiles::StoreUsageTableInfo(
const CdmUsageTableHeader& usage_table_header,
const std::vector<CdmUsageEntryInfo>& usage_entry_info) {
const UsageTableHeader& table_header,
const std::vector<CdmUsageEntryInfo>& entry_info_list) {
RETURN_FALSE_IF_UNINITIALIZED();
// Fill in file information
@@ -1645,25 +1645,24 @@ bool DeviceFiles::StoreUsageTableInfo(
file.set_version(video_widevine_client::sdk::File::VERSION_1);
UsageTableInfo* usage_table_info = file.mutable_usage_table_info();
usage_table_info->set_usage_table_header(usage_table_header);
for (size_t i = 0; i < usage_entry_info.size(); ++i) {
usage_table_info->set_table_header(table_header);
for (size_t i = 0; i < entry_info_list.size(); ++i) {
UsageTableInfo_UsageEntryInfo* info =
usage_table_info->add_usage_entry_info();
info->set_key_set_id(usage_entry_info[i].key_set_id);
switch (usage_entry_info[i].storage_type) {
usage_table_info->add_entry_info_list();
info->set_key_set_id(entry_info_list[i].key_set_id);
switch (entry_info_list[i].storage_type) {
case kStorageLicense:
info->set_storage(
UsageTableInfo_UsageEntryInfo_UsageEntryStorage_LICENSE);
info->set_last_use_time(usage_entry_info[i].last_use_time);
info->set_last_use_time(entry_info_list[i].last_use_time);
info->set_offline_license_expiry_time(
usage_entry_info[i].offline_license_expiry_time);
entry_info_list[i].offline_license_expiry_time);
break;
case kStorageUsageInfo:
info->set_storage(
UsageTableInfo_UsageEntryInfo_UsageEntryStorage_USAGE_INFO);
info->set_usage_info_file_name(
usage_entry_info[i].usage_info_file_name);
info->set_last_use_time(usage_entry_info[i].last_use_time);
info->set_usage_info_file_name(entry_info_list[i].usage_info_file_name);
info->set_last_use_time(entry_info_list[i].last_use_time);
break;
case kStorageTypeUnknown:
default:
@@ -1682,11 +1681,11 @@ bool DeviceFiles::StoreUsageTableInfo(
}
bool DeviceFiles::RetrieveUsageTableInfo(
CdmUsageTableHeader* usage_table_header,
std::vector<CdmUsageEntryInfo>* usage_entry_info, bool* lru_upgrade) {
UsageTableHeader* table_header,
std::vector<CdmUsageEntryInfo>* entry_info_list, bool* lru_upgrade) {
RETURN_FALSE_IF_UNINITIALIZED();
RETURN_FALSE_IF_NULL(usage_table_header);
RETURN_FALSE_IF_NULL(usage_entry_info);
RETURN_FALSE_IF_NULL(table_header);
RETURN_FALSE_IF_NULL(entry_info_list);
RETURN_FALSE_IF_NULL(lru_upgrade);
video_widevine_client::sdk::File file;
@@ -1718,28 +1717,28 @@ bool DeviceFiles::RetrieveUsageTableInfo(
*lru_upgrade = !usage_table_info.use_lru();
*usage_table_header = usage_table_info.usage_table_header();
usage_entry_info->resize(usage_table_info.usage_entry_info_size());
for (int i = 0; i < usage_table_info.usage_entry_info_size(); ++i) {
*table_header = usage_table_info.table_header();
entry_info_list->resize(usage_table_info.entry_info_list_size());
for (int i = 0; i < usage_table_info.entry_info_list_size(); ++i) {
const UsageTableInfo_UsageEntryInfo& info =
usage_table_info.usage_entry_info(i);
(*usage_entry_info)[i].key_set_id = info.key_set_id();
usage_table_info.entry_info_list(i);
(*entry_info_list)[i].key_set_id = info.key_set_id();
switch (info.storage()) {
case UsageTableInfo_UsageEntryInfo_UsageEntryStorage_LICENSE:
(*usage_entry_info)[i].storage_type = kStorageLicense;
(*usage_entry_info)[i].last_use_time = info.last_use_time();
(*usage_entry_info)[i].offline_license_expiry_time =
(*entry_info_list)[i].storage_type = kStorageLicense;
(*entry_info_list)[i].last_use_time = info.last_use_time();
(*entry_info_list)[i].offline_license_expiry_time =
info.offline_license_expiry_time();
break;
case UsageTableInfo_UsageEntryInfo_UsageEntryStorage_USAGE_INFO:
(*usage_entry_info)[i].storage_type = kStorageUsageInfo;
(*usage_entry_info)[i].usage_info_file_name =
(*entry_info_list)[i].storage_type = kStorageUsageInfo;
(*entry_info_list)[i].usage_info_file_name =
info.usage_info_file_name();
(*usage_entry_info)[i].last_use_time = info.last_use_time();
(*entry_info_list)[i].last_use_time = info.last_use_time();
break;
case UsageTableInfo_UsageEntryInfo_UsageEntryStorage_UNKNOWN:
default:
(*usage_entry_info)[i].storage_type = kStorageTypeUnknown;
(*entry_info_list)[i].storage_type = kStorageTypeUnknown;
break;
}
}

8
libwvdrmengine/cdm/core/src/device_files.proto
View File

@@ -75,7 +75,7 @@ message License {
// ignored if there is no grace period.
optional int64 grace_period_end_time = 11 [default = 0];
optional bytes usage_entry = 12;
optional int64 usage_entry_number = 13;
optional int64 usage_entry_index = 13;
optional DeviceCertificate drm_certificate = 14;
}
@@ -88,7 +88,7 @@ message UsageInfo {
optional bytes license = 3;
optional bytes key_set_id = 4;
optional bytes usage_entry = 5;
optional int64 usage_entry_number = 6;
optional int64 usage_entry_index = 6;
// If not present, use the legacy DRM certificate rather than
// one in DrmDeviceCertificate
optional uint32 drm_certificate_id = 7;
@@ -131,8 +131,8 @@ message UsageTableInfo {
optional int64 offline_license_expiry_time = 5 [default = 0];
}
optional bytes usage_table_header = 1;
repeated UsageEntryInfo usage_entry_info = 2;
optional bytes table_header = 1;
repeated UsageEntryInfo entry_info_list = 2;
optional bool use_lru = 3 [default = false];
}

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

@@ -466,7 +466,7 @@ CdmResponseType CdmLicense::PrepareKeyUpdateRequest(
}
// TODO(rfrias): Refactor to avoid needing to call CdmSession
if (cdm_session && cdm_session->supports_usage_info()) {
if (cdm_session && cdm_session->SupportsUsageTable()) {
const CdmResponseType status = cdm_session->UpdateUsageEntryInformation();
if (NO_ERROR != status) return status;
}
@@ -822,7 +822,7 @@ CdmResponseType CdmLicense::RestoreOfflineLicense(
}
if (!provider_session_token_.empty()) {
if (cdm_session && cdm_session->supports_usage_info()) {
if (cdm_session && cdm_session->SupportsUsageTable()) {
const CdmResponseType status = cdm_session->UpdateUsageEntryInformation();
if (NO_ERROR != status) return sts;
}

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

@@ -9,6 +9,7 @@
#include <memory>
#include "cdm_usage_table.h"
#include "crypto_key.h"
#include "crypto_wrapped_key.h"
#include "properties.h"
@@ -16,7 +17,6 @@
#include "string_conversions.h"
#include "test_base.h"
#include "test_printers.h"
#include "usage_table_header.h"
#include "wv_cdm_constants.h"
#include "wv_metrics.pb.h"
@@ -123,13 +123,13 @@ class MockDeviceFiles : public DeviceFiles {
MOCK_METHOD(bool, HasCertificate, (bool), (override));
};
class MockUsageTableHeader : public UsageTableHeader {
class MockCdmUsageTable : public CdmUsageTable {
public:
MockUsageTableHeader() : UsageTableHeader() {}
MockCdmUsageTable() : CdmUsageTable() {}
MOCK_METHOD(CdmResponseType, UpdateEntry,
(uint32_t usage_entry_number, CryptoSession* crypto_session,
CdmUsageEntry* usage_entry),
(UsageEntryIndex usage_entry_index, CryptoSession* crypto_session,
UsageEntry* usage_entry),
(override));
};
@@ -137,10 +137,10 @@ class MockCryptoSession : public TestCryptoSession {
public:
MockCryptoSession(metrics::CryptoMetrics* crypto_metrics)
: TestCryptoSession(crypto_metrics) {
// By default, call the concrete implementation of HasUsageInfoSupport.
ON_CALL(*this, HasUsageInfoSupport(_))
// By default, call the concrete implementation of HasUsageTableSupport.
ON_CALL(*this, HasUsageTableSupport(_))
.WillByDefault(
Invoke(this, &MockCryptoSession::BaseHasUsageInfoSupport));
Invoke(this, &MockCryptoSession::BaseHasUsageTableSupport));
}
MOCK_METHOD(CdmResponseType, GetProvisioningToken,
(std::string*, std::string*), (override));
@@ -151,11 +151,11 @@ class MockCryptoSession : public TestCryptoSession {
(override));
MOCK_METHOD(CdmResponseType, LoadCertificatePrivateKey,
(const CryptoWrappedKey&), (override));
MOCK_METHOD(bool, HasUsageInfoSupport, (bool*), (override));
MOCK_METHOD(UsageTableHeader*, GetUsageTableHeader, (), (override));
MOCK_METHOD(bool, HasUsageTableSupport, (bool*), (override));
MOCK_METHOD(CdmUsageTable*, GetUsageTable, (), (override));
bool BaseHasUsageInfoSupport(bool* has_support) {
return CryptoSession::HasUsageInfoSupport(has_support);
bool BaseHasUsageTableSupport(bool* has_support) {
return CryptoSession::HasUsageTableSupport(has_support);
}
};
@@ -209,7 +209,7 @@ class CdmSessionTest : public WvCdmTestBase {
NiceMock<MockCryptoSession>* crypto_session_;
MockPolicyEngine* policy_engine_;
MockDeviceFiles* file_handle_;
MockUsageTableHeader usage_table_header_;
MockCdmUsageTable usage_table_;
};
TEST_F(CdmSessionTest, InitWithBuiltInCertificate) {
@@ -294,22 +294,22 @@ TEST_F(CdmSessionTest, UpdateUsageEntry) {
.WillOnce(Return(level));
EXPECT_CALL(*file_handle_, Init(Eq(level))).WillOnce(Return(true));
EXPECT_CALL(*file_handle_, HasCertificate(false)).WillOnce(Return(true));
EXPECT_CALL(*crypto_session_, GetUsageTableHeader())
.WillOnce(Return(&usage_table_header_));
EXPECT_CALL(*crypto_session_, GetUsageTable())
.WillOnce(Return(&usage_table_));
EXPECT_CALL(*license_parser_, Init(false, Eq(kEmptyString),
Eq(crypto_session_), Eq(policy_engine_)))
.WillOnce(Return(true));
// Set up mocks and expectations for the UpdateUsageEntryInformation call.
EXPECT_CALL(*crypto_session_, HasUsageInfoSupport(_))
EXPECT_CALL(*crypto_session_, HasUsageTableSupport(_))
.WillRepeatedly(DoAll(SetArgPointee<0>(true), Return(true)));
EXPECT_CALL(*license_parser_, provider_session_token())
.WillRepeatedly(Return("Mock provider session token"));
EXPECT_CALL(usage_table_header_, UpdateEntry(_, NotNull(), NotNull()))
EXPECT_CALL(usage_table_, UpdateEntry(_, NotNull(), NotNull()))
.WillRepeatedly(Return(CdmResponseType(NO_ERROR)));
EXPECT_EQ(NO_ERROR, cdm_session_->Init(nullptr));
EXPECT_TRUE(cdm_session_->supports_usage_info());
EXPECT_TRUE(cdm_session_->SupportsUsageTable());
EXPECT_EQ(NO_ERROR, cdm_session_->UpdateUsageEntryInformation());
// Verify the UsageEntry metric is set.

1269
libwvdrmengine/cdm/core/test/usage_table_header_unittest.cpp → libwvdrmengine/cdm/core/test/cdm_usage_table_unittest.cpp
View File

File diff suppressed because it is too large Load Diff

16
libwvdrmengine/cdm/core/test/certificate_provisioning_unittest.cpp
View File

@@ -63,21 +63,21 @@ class MockCryptoSession : public TestCryptoSession {
(override));
// Usage Table Header.
MOCK_METHOD(CdmResponseType, CreateUsageTableHeader,
(wvcdm::RequestedSecurityLevel, CdmUsageTableHeader*),
(override));
(wvcdm::RequestedSecurityLevel, UsageTableHeader*), (override));
MOCK_METHOD(CdmResponseType, LoadUsageTableHeader,
(wvcdm::RequestedSecurityLevel, const CdmUsageTableHeader&),
(wvcdm::RequestedSecurityLevel, const UsageTableHeader&),
(override));
MOCK_METHOD(CdmResponseType, ShrinkUsageTableHeader,
(wvcdm::RequestedSecurityLevel, uint32_t, CdmUsageTableHeader*),
(wvcdm::RequestedSecurityLevel, uint32_t, UsageTableHeader*),
(override));
// Usage Entry.
MOCK_METHOD(CdmResponseType, CreateUsageEntry, (uint32_t*), (override));
MOCK_METHOD(CdmResponseType, LoadUsageEntry, (uint32_t, const CdmUsageEntry&),
MOCK_METHOD(CdmResponseType, CreateUsageEntry, (UsageEntryIndex*),
(override));
MOCK_METHOD(CdmResponseType, LoadUsageEntry,
(UsageEntryIndex, const UsageEntry&), (override));
MOCK_METHOD(CdmResponseType, UpdateUsageEntry,
(CdmUsageTableHeader*, CdmUsageEntry*), (override));
MOCK_METHOD(CdmResponseType, MoveUsageEntry, (uint32_t), (override));
(UsageTableHeader*, UsageEntry*), (override));
MOCK_METHOD(CdmResponseType, MoveUsageEntry, (UsageEntryIndex), (override));
};
class TestStubCryptoSessionFactory : public CryptoSessionFactory {

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

@@ -62,7 +62,7 @@ TEST_F(CryptoSessionMetricsTest, OpenSessionValidMetrics) {
session->Open(wvcdm::kLevelDefault);
// Exercise a method that will touch a metric.
bool supports_usage_table;
ASSERT_TRUE(session->HasUsageInfoSupport(&supports_usage_table));
ASSERT_TRUE(session->HasUsageTableSupport(&supports_usage_table));
drm_metrics::WvCdmMetrics::CryptoMetrics metrics_proto;
crypto_metrics.Serialize(&metrics_proto);

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

@@ -1627,7 +1627,7 @@ struct LicenseInfo {
int64_t grace_period_end_time;
std::string app_parameters;
std::string usage_entry;
uint32_t usage_entry_number;
uint32_t usage_entry_index;
std::string drm_certificate;
CryptoWrappedKey::Type key_type;
std::string private_key;
@@ -3657,7 +3657,7 @@ const CdmUsageEntryInfo kUsageEntriesTestData[] = {
};
struct UsageTableTestInfo {
CdmUsageTableHeader usage_table_header;
UsageTableHeader usage_table_header;
std::string file_data;
};
@@ -4560,7 +4560,7 @@ TEST_P(DeviceFilesStoreTest, StoreLicense) {
kLicenseTestData[license_num].grace_period_end_time,
app_parameters,
kLicenseTestData[license_num].usage_entry,
kLicenseTestData[license_num].usage_entry_number,
kLicenseTestData[license_num].usage_entry_index,
kLicenseTestData[license_num].drm_certificate,
CryptoWrappedKey(kLicenseTestData[license_num].key_type,
kLicenseTestData[license_num].private_key)};
@@ -4629,7 +4629,7 @@ TEST_F(DeviceFilesTest, StoreLicenses) {
kLicenseTestData[i].grace_period_end_time,
app_parameters,
kLicenseTestData[i].usage_entry,
kLicenseTestData[i].usage_entry_number,
kLicenseTestData[i].usage_entry_index,
kLicenseTestData[i].drm_certificate,
CryptoWrappedKey(kLicenseTestData[i].key_type,
kLicenseTestData[i].private_key)};
@@ -4689,8 +4689,8 @@ TEST_F(DeviceFilesTest, RetrieveLicenses) {
EXPECT_EQ(kLicenseTestData[i].grace_period_end_time,
license_data.grace_period_end_time);
EXPECT_EQ(kLicenseTestData[i].usage_entry, license_data.usage_entry);
EXPECT_EQ(kLicenseTestData[i].usage_entry_number,
license_data.usage_entry_number);
EXPECT_EQ(kLicenseTestData[i].usage_entry_index,
license_data.usage_entry_index);
EXPECT_EQ(kLicenseTestData[i].drm_certificate,
license_data.drm_certificate);
EXPECT_EQ(kLicenseTestData[i].key_type,
@@ -4755,7 +4755,7 @@ TEST_F(DeviceFilesTest, AppParametersBackwardCompatibility) {
license_data.grace_period_end_time);
EXPECT_EQ(0u, license_data.app_parameters.size());
EXPECT_EQ(test_data->usage_entry, license_data.usage_entry);
EXPECT_EQ(test_data->usage_entry_number, license_data.usage_entry_number);
EXPECT_EQ(test_data->usage_entry_index, license_data.usage_entry_index);
EXPECT_EQ(test_data->drm_certificate, license_data.drm_certificate);
EXPECT_EQ(test_data->key_type, license_data.wrapped_private_key.type());
EXPECT_EQ(test_data->private_key, license_data.wrapped_private_key.key());
@@ -4794,7 +4794,7 @@ TEST_F(DeviceFilesTest, UpdateLicenseState) {
kLicenseUpdateTestData[0].grace_period_end_time,
GetAppParameters(kLicenseTestData[0].app_parameters),
kLicenseUpdateTestData[0].usage_entry,
kLicenseUpdateTestData[0].usage_entry_number,
kLicenseUpdateTestData[0].usage_entry_index,
kLicenseUpdateTestData[0].drm_certificate,
CryptoWrappedKey(kLicenseTestData[0].key_type,
kLicenseTestData[0].private_key)};
@@ -4860,8 +4860,8 @@ TEST_F(DeviceFilesTest, DeleteLicense) {
std::string::npos);
}
EXPECT_EQ(kLicenseTestData[0].usage_entry, license_data.usage_entry);
EXPECT_EQ(kLicenseTestData[0].usage_entry_number,
license_data.usage_entry_number);
EXPECT_EQ(kLicenseTestData[0].usage_entry_index,
license_data.usage_entry_index);
EXPECT_EQ(kLicenseTestData[0].drm_certificate, license_data.drm_certificate);
EXPECT_EQ(kLicenseTestData[0].key_type,
license_data.wrapped_private_key.type());
@@ -5408,8 +5408,8 @@ TEST_P(DeviceFilesUsageInfoTest, Retrieve) {
usage_data_list[i].key_set_id);
EXPECT_EQ(kUsageInfoTestData[j].usage_data.usage_entry,
usage_data_list[i].usage_entry);
EXPECT_EQ(kUsageInfoTestData[j].usage_data.usage_entry_number,
usage_data_list[i].usage_entry_number);
EXPECT_EQ(kUsageInfoTestData[j].usage_data.usage_entry_index,
usage_data_list[i].usage_entry_index);
EXPECT_EQ(kUsageInfoTestData[j].usage_data.drm_certificate,
usage_data_list[i].drm_certificate);
EXPECT_EQ(kUsageInfoTestData[j].usage_data.wrapped_private_key.type(),
@@ -5581,8 +5581,8 @@ TEST_P(DeviceFilesUsageInfoTest, RetrieveByProviderSessionToken) {
usage_data.key_set_id);
EXPECT_EQ(kUsageInfoTestData[index].usage_data.usage_entry,
usage_data.usage_entry);
EXPECT_EQ(kUsageInfoTestData[index].usage_data.usage_entry_number,
usage_data.usage_entry_number);
EXPECT_EQ(kUsageInfoTestData[index].usage_data.usage_entry_index,
usage_data.usage_entry_index);
}
}
@@ -5813,7 +5813,7 @@ TEST_P(DeviceFilesUsageTableTest, Read) {
EXPECT_TRUE(device_files.Init(kSecurityLevelL1));
std::vector<CdmUsageEntryInfo> usage_entry_info;
CdmUsageTableHeader usage_table_header;
UsageTableHeader usage_table_header;
bool lru_upgrade;
ASSERT_TRUE(device_files.RetrieveUsageTableInfo(
&usage_table_header, &usage_entry_info, &lru_upgrade));
@@ -5861,7 +5861,7 @@ TEST_F(DeviceFilesUsageTableTest, ReadWithoutLruData) {
EXPECT_TRUE(device_files.Init(kSecurityLevelL1));
std::vector<CdmUsageEntryInfo> usage_entry_info;
CdmUsageTableHeader usage_table_header;
UsageTableHeader usage_table_header;
bool lru_upgrade;
ASSERT_TRUE(device_files.RetrieveUsageTableInfo(
&usage_table_header, &usage_entry_info, &lru_upgrade));

6
libwvdrmengine/cdm/core/test/license_unittest.cpp
View File

@@ -143,7 +143,7 @@ class MockCryptoSession : public TestCryptoSession {
: TestCryptoSession(crypto_metrics) {}
MOCK_METHOD(bool, IsOpen, (), (override));
MOCK_METHOD(const std::string&, request_id, (), (override));
MOCK_METHOD(bool, HasUsageInfoSupport, (bool*), (override));
MOCK_METHOD(bool, HasUsageTableSupport, (bool*), (override));
MOCK_METHOD(CdmResponseType, GetHdcpCapabilities,
(HdcpCapability*, HdcpCapability*), (override));
MOCK_METHOD(bool, GetSupportedCertificateTypes, (SupportedCertificateTypes*),
@@ -306,7 +306,7 @@ TEST_F(CdmLicenseTest, PrepareKeyRequestValidation) {
EXPECT_CALL(*crypto_session_, IsOpen()).WillOnce(Return(true));
EXPECT_CALL(*crypto_session_, request_id())
.WillOnce(ReturnRef(kCryptoRequestId));
EXPECT_CALL(*crypto_session_, HasUsageInfoSupport(NotNull()))
EXPECT_CALL(*crypto_session_, HasUsageTableSupport(NotNull()))
.WillOnce(
DoAll(SetArgPointee<0>(usage_information_support), Return(true)));
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
@@ -441,7 +441,7 @@ TEST_F(CdmLicenseTest, PrepareKeyRequestValidationV15) {
EXPECT_CALL(*crypto_session_, IsOpen()).WillOnce(Return(true));
EXPECT_CALL(*crypto_session_, request_id())
.WillOnce(ReturnRef(kCryptoRequestId));
EXPECT_CALL(*crypto_session_, HasUsageInfoSupport(NotNull()))
EXPECT_CALL(*crypto_session_, HasUsageTableSupport(NotNull()))
.WillOnce(
DoAll(SetArgPointee<0>(usage_information_support), Return(true)));
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))

10
libwvdrmengine/cdm/test/Android.mk
View File

@@ -45,6 +45,11 @@ test_src_dir := ../core/test
test_main := ../core/test/test_main.cpp
include $(LOCAL_PATH)/integration-test.mk
test_name := cdm_usage_table_unittest
test_src_dir := ../core/test
test_main := ../core/test/test_main.cpp
include $(LOCAL_PATH)/integration-test.mk
test_name := certificate_provisioning_unittest
test_src_dir := ../core/test
test_main := ../core/test/test_main.cpp
@@ -169,11 +174,6 @@ test_name := timer_unittest
test_src_dir := .
include $(LOCAL_PATH)/unit-test.mk
test_name := usage_table_header_unittest
test_src_dir := ../core/test
test_main := ../core/test/test_main.cpp
include $(LOCAL_PATH)/integration-test.mk
test_name := value_metric_unittest
test_src_dir := ../metrics/test
include $(LOCAL_PATH)/unit-test.mk

2
libwvdrmengine/run_all_unit_tests.sh
View File

@@ -99,6 +99,7 @@ adb_shell_run buffer_reader_test
adb_shell_run cdm_engine_metrics_decorator_unittest
adb_shell_run cdm_engine_test
adb_shell_run cdm_session_unittest
adb_shell_run cdm_usage_table_unittest
adb_shell_run certificate_provisioning_unittest
adb_shell_run counter_metric_unittest
adb_shell_run crypto_session_unittest
@@ -125,6 +126,5 @@ adb_shell_run rw_lock_test
adb_shell_run service_certificate_unittest
adb_shell_run system_id_extractor_unittest
adb_shell_run timer_unittest
adb_shell_run usage_table_header_unittest
adb_shell_run value_metric_unittest
adb_shell_run wv_cdm_metrics_test

2
tests/Android.mk
View File

@@ -19,6 +19,7 @@ WIDEVINE_TEST_MAKE_TARGETS += \
cdm_extended_duration_test \
cdm_feature_test \
cdm_session_unittest \
cdm_usage_table_unittest \
certificate_provisioning_unittest \
counter_metric_unittest \
crypto_session_unittest \
@@ -49,7 +50,6 @@ WIDEVINE_TEST_MAKE_TARGETS += \
rw_lock_test \
service_certificate_unittest \
timer_unittest \
usage_table_header_unittest \
value_metric_unittest \
wv_cdm_metrics_test \