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

Use aidl interface for Widevine service.

Browse Source 
The interface is defined in
hardware/interfaces/drm/aidl(http://go/ag/15329852).

Test: build
  m android.hardware.drm-service.widevine -j128

Test: build_and_run_all_unit_tests.sh
  for hidl tests

Test: atest VtsAidlHalDrmTargetTest

Test:   atest vts_treble_vintf_vendor_test:vts_treble_vintf_vendor_test.DeviceManifest/SingleManifestTest#ManifestAidlHalsServed/0 -- --abi x86_64

Bug: 200055138
Bug: 170964303
Change-Id: I5654d90d8a4b0bae4b4a78e79b27c1cafec36be7
This commit is contained in:
Edwin
2021-12-30 11:39:14 -08:00
parent 627c8d6855
commit 3c3da01d58
75 changed files with 7071 additions and 1480 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -38,7 +38,7 @@ class UsagePropertySet : public CdmClientPropertySet {
public:
UsagePropertySet() {}
~UsagePropertySet() override {}
void set_security_level(SecurityLevel security_level) {
void set_security_level(RequestedSecurityLevel security_level) {
if (kLevel3 == security_level)
security_level_ = QUERY_VALUE_SECURITY_LEVEL_L3;
else
@@ -122,7 +122,7 @@ CdmResponseType CdmEngine::OpenSession(const CdmKeySystem& key_system,
LOGD("forced_session_id = %s", IdPtrToString(forced_session_id));
}
SecurityLevel requested_security_level = kLevelDefault;
RequestedSecurityLevel requested_security_level = kLevelDefault;
if (property_set &&
property_set->security_level() == QUERY_VALUE_SECURITY_LEVEL_L3) {
requested_security_level = kLevel3;
@@ -544,11 +544,11 @@ CdmResponseType CdmEngine::SetSessionServiceCertificate(
return session->SetServiceCertificate(service_certificate);
}
CdmResponseType CdmEngine::QueryStatus(SecurityLevel security_level,
CdmResponseType CdmEngine::QueryStatus(RequestedSecurityLevel security_level,
const std::string& query_token,
std::string* query_response) {
LOGD("security_level = %s, query_token = %s",
SecurityLevelToString(security_level), IdToString(query_token));
RequestedSecurityLevelToString(security_level), IdToString(query_token));
if (query_response == nullptr) {
LOGE("Output |query_response| is null");
return PARAMETER_NULL;
@@ -969,8 +969,8 @@ bool CdmEngine::IsSecurityLevelSupported(CdmSecurityLevel level) {
CdmResponseType CdmEngine::GetProvisioningRequest(
CdmCertificateType cert_type, const std::string& cert_authority,
const std::string& service_certificate,
SecurityLevel requested_security_level, CdmProvisioningRequest* request,
std::string* default_url) {
RequestedSecurityLevel requested_security_level,
CdmProvisioningRequest* request, std::string* default_url) {
LOGI("cert_type = %s", CdmCertificateTypeToString(cert_type));
if (!request) {
LOGE("Output |request| is null");
@@ -1043,10 +1043,10 @@ CdmResponseType CdmEngine::GetProvisioningRequest(
*/
CdmResponseType CdmEngine::HandleProvisioningResponse(
const CdmProvisioningResponse& response,
SecurityLevel requested_security_level, std::string* cert,
RequestedSecurityLevel requested_security_level, std::string* cert,
std::string* wrapped_key) {
LOGI("response_size = %zu, security_level = %s", response.size(),
SecurityLevelToString(requested_security_level));
RequestedSecurityLevelToString(requested_security_level));
if (response.empty()) {
LOGE("Empty provisioning response");
cert_provisioning_.reset();
@@ -1440,7 +1440,7 @@ CdmResponseType CdmEngine::GetUsageInfo(const std::string& app_id,
return PARAMETER_NULL;
}
// Return a random usage report from a random security level
SecurityLevel security_level =
RequestedSecurityLevel security_level =
wvutil::CdmRandom::RandomBool() ? kLevelDefault : kLevel3;
CdmResponseType status = UNKNOWN_ERROR;
do {
@@ -1460,12 +1460,11 @@ CdmResponseType CdmEngine::GetUsageInfo(const std::string& app_id,
return status;
}
CdmResponseType CdmEngine::GetUsageInfo(const std::string& app_id,
SecurityLevel requested_security_level,
int* error_detail,
CdmUsageInfo* usage_info) {
CdmResponseType CdmEngine::GetUsageInfo(
const std::string& app_id, RequestedSecurityLevel requested_security_level,
int* error_detail, CdmUsageInfo* usage_info) {
LOGI("app_id = %s, security_level = %s", IdToString(app_id),
SecurityLevelToString(requested_security_level));
RequestedSecurityLevelToString(requested_security_level));
if (usage_info == nullptr) {
LOGE("Output |usage_info| is null");
return PARAMETER_NULL;
@@ -1550,7 +1549,7 @@ CdmResponseType CdmEngine::RemoveAllUsageInfo(
CdmResponseType status = NO_ERROR;
DeviceFiles handle(file_system_);
if (handle.Init(cdm_security_level)) {
const SecurityLevel security_level =
const RequestedSecurityLevel security_level =
cdm_security_level == kSecurityLevelL3 ? kLevel3 : kLevelDefault;
usage_property_set_->set_security_level(security_level);
usage_session_.reset(new CdmSession(file_system_, metrics_->AddSession()));
@@ -1624,7 +1623,7 @@ CdmResponseType CdmEngine::RemoveUsageInfo(
for (int j = kSecurityLevelL1; j < kSecurityLevelUnknown; ++j) {
DeviceFiles handle(file_system_);
if (handle.Init(static_cast<CdmSecurityLevel>(j))) {
SecurityLevel security_level =
RequestedSecurityLevel security_level =
static_cast<CdmSecurityLevel>(j) == kSecurityLevelL3 ? kLevel3
: kLevelDefault;
usage_property_set_->set_security_level(security_level);

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

@@ -173,7 +173,7 @@ CertificateProvisioning::GetProvisioningType() {
* Returns NO_ERROR for success and CERT_PROVISIONING_REQUEST_ERROR_? if fails.
*/
CdmResponseType CertificateProvisioning::GetProvisioningRequest(
wvutil::FileSystem* file_system, SecurityLevel requested_security_level,
wvutil::FileSystem* file_system, RequestedSecurityLevel requested_security_level,
CdmCertificateType cert_type, const std::string& cert_authority,
const std::string& origin, const std::string& spoid,
CdmProvisioningRequest* request, std::string* default_url) {
@@ -183,7 +183,7 @@ CdmResponseType CertificateProvisioning::GetProvisioningRequest(
}
CdmResponseType CertificateProvisioning::GetProvisioningRequestInternal(
wvutil::FileSystem* file_system, SecurityLevel requested_security_level,
wvutil::FileSystem* file_system, RequestedSecurityLevel requested_security_level,
CdmCertificateType cert_type, const std::string& cert_authority,
const std::string& origin, const std::string& spoid,
CdmProvisioningRequest* request, std::string* default_url) {

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

@@ -299,7 +299,8 @@ CryptoSession::~CryptoSession() {
}
CdmResponseType CryptoSession::GetProvisioningMethod(
SecurityLevel requested_security_level, CdmClientTokenType* token_type) {
RequestedSecurityLevel requested_security_level,
CdmClientTokenType* token_type) {
OEMCrypto_ProvisioningMethod method;
WithOecReadLock("GetProvisioningMethod", [&] {
method = OEMCrypto_GetProvisioningMethod(requested_security_level);
@@ -467,7 +468,7 @@ void CryptoSession::DisableDelayedTermination() {
}
bool CryptoSession::SetUpUsageTableHeader(
SecurityLevel requested_security_level) {
RequestedSecurityLevel requested_security_level) {
if (usage_table_header_ != nullptr) {
LOGE("Usage table is already set up for the current crypto session");
return false;
@@ -616,9 +617,9 @@ CdmSecurityLevel CryptoSession::GetSecurityLevel() {
}
CdmSecurityLevel CryptoSession::GetSecurityLevel(
SecurityLevel requested_security_level) {
RequestedSecurityLevel requested_security_level) {
LOGV("Getting security level: requested_security_level = %s",
SecurityLevelToString(requested_security_level));
RequestedSecurityLevelToString(requested_security_level));
RETURN_IF_UNINITIALIZED(kSecurityLevelUninitialized);
const OEMCrypto_Security_Level level = WithOecReadLock(
"GetSecurityLevel",
@@ -641,7 +642,7 @@ CdmSecurityLevel CryptoSession::GetSecurityLevel(
"Ill-formed security level: "
"level = \"L%u\", requested_security_level = %s",
static_cast<unsigned int>(level),
SecurityLevelToString(requested_security_level));
RequestedSecurityLevelToString(requested_security_level));
return kSecurityLevelUnknown;
}
@@ -731,10 +732,10 @@ bool CryptoSession::GetApiVersion(uint32_t* version) {
return GetApiVersion(requested_security_level_, version);
}
bool CryptoSession::GetApiVersion(SecurityLevel security_level,
bool CryptoSession::GetApiVersion(RequestedSecurityLevel security_level,
uint32_t* version) {
LOGV("Getting API version: security_level = %s",
SecurityLevelToString(security_level));
RequestedSecurityLevelToString(security_level));
if (!version) {
LOGE("Output parameter |version| not provided");
return false;
@@ -749,10 +750,10 @@ bool CryptoSession::GetApiVersion(SecurityLevel security_level,
return true;
}
bool CryptoSession::GetApiMinorVersion(SecurityLevel security_level,
bool CryptoSession::GetApiMinorVersion(RequestedSecurityLevel security_level,
uint32_t* minor_version) {
LOGV("Getting API minor version: security_level = %s",
SecurityLevelToString(security_level));
RequestedSecurityLevelToString(security_level));
if (!minor_version) {
LOGE("Output parameter |minor_version| not provided");
return false;
@@ -890,9 +891,10 @@ uint8_t CryptoSession::GetSecurityPatchLevel() {
return patch;
}
CdmResponseType CryptoSession::Open(SecurityLevel requested_security_level) {
CdmResponseType CryptoSession::Open(
RequestedSecurityLevel requested_security_level) {
LOGD("Opening crypto session: requested_security_level = %s",
SecurityLevelToString(requested_security_level));
RequestedSecurityLevelToString(requested_security_level));
RETURN_IF_UNINITIALIZED(CRYPTO_SESSION_NOT_INITIALIZED);
if (open_) return NO_ERROR;
@@ -1872,8 +1874,8 @@ bool CryptoSession::HasUsageInfoSupport(bool* has_support) {
});
}
bool CryptoSession::HasUsageInfoSupport(SecurityLevel requested_security_level,
bool* has_support) {
bool CryptoSession::HasUsageInfoSupport(
RequestedSecurityLevel requested_security_level, bool* has_support) {
RETURN_IF_UNINITIALIZED(false);
RETURN_IF_NULL(has_support, false);
return WithOecReadLock("HasUsageInfoSupport", [&] {
@@ -1882,9 +1884,9 @@ bool CryptoSession::HasUsageInfoSupport(SecurityLevel requested_security_level,
}
bool CryptoSession::HasUsageInfoSupportInternal(
SecurityLevel requested_security_level, bool* has_support) {
RequestedSecurityLevel requested_security_level, bool* has_support) {
LOGV("requested_security_level = %s",
SecurityLevelToString(requested_security_level));
RequestedSecurityLevelToString(requested_security_level));
*has_support = WithOecReadLock("HasUsageInfoSupport", [&] {
return OEMCrypto_SupportsUsageTable(requested_security_level);
});
@@ -2109,11 +2111,11 @@ CdmResponseType CryptoSession::GetHdcpCapabilities(HdcpCapability* current,
return GetHdcpCapabilities(requested_security_level_, current, max);
}
CdmResponseType CryptoSession::GetHdcpCapabilities(SecurityLevel security_level,
HdcpCapability* current,
HdcpCapability* max) {
CdmResponseType CryptoSession::GetHdcpCapabilities(
RequestedSecurityLevel security_level, HdcpCapability* current,
HdcpCapability* max) {
LOGV("Getting HDCP capabilities: id = %u, security_level = %s",
oec_session_id_, SecurityLevelToString(security_level));
oec_session_id_, RequestedSecurityLevelToString(security_level));
RETURN_IF_UNINITIALIZED(CRYPTO_SESSION_NOT_INITIALIZED);
RETURN_IF_NULL(current, PARAMETER_NULL);
RETURN_IF_NULL(max, PARAMETER_NULL);
@@ -2166,9 +2168,9 @@ CdmResponseType CryptoSession::GetRandom(size_t data_length,
}
CdmResponseType CryptoSession::GetNumberOfOpenSessions(
SecurityLevel security_level, size_t* count) {
RequestedSecurityLevel security_level, size_t* count) {
LOGV("Getting number of open sessions: id = %u, security_level = %s",
oec_session_id_, SecurityLevelToString(security_level));
oec_session_id_, RequestedSecurityLevelToString(security_level));
RETURN_IF_UNINITIALIZED(CRYPTO_SESSION_NOT_INITIALIZED);
RETURN_IF_NULL(count, PARAMETER_NULL);
@@ -2190,9 +2192,9 @@ CdmResponseType CryptoSession::GetNumberOfOpenSessions(
}
CdmResponseType CryptoSession::GetMaxNumberOfSessions(
SecurityLevel security_level, size_t* max) {
RequestedSecurityLevel security_level, size_t* max) {
LOGV("Getting max number of sessions: id = %u, security_level = %s",
oec_session_id_, SecurityLevelToString(security_level));
oec_session_id_, RequestedSecurityLevelToString(security_level));
RETURN_IF_UNINITIALIZED(CRYPTO_SESSION_NOT_INITIALIZED);
RETURN_IF_NULL(max, PARAMETER_NULL);
@@ -2248,10 +2250,10 @@ bool CryptoSession::GetResourceRatingTier(uint32_t* tier) {
return GetResourceRatingTier(requested_security_level_, tier);
}
bool CryptoSession::GetResourceRatingTier(SecurityLevel security_level,
bool CryptoSession::GetResourceRatingTier(RequestedSecurityLevel security_level,
uint32_t* tier) {
LOGV("Getting resource rating tier: security_level = %s",
SecurityLevelToString(security_level));
RequestedSecurityLevelToString(security_level));
RETURN_IF_UNINITIALIZED(false);
RETURN_IF_NULL(tier, false);
@@ -2276,10 +2278,10 @@ bool CryptoSession::GetBuildInformation(std::string* info) {
return GetBuildInformation(requested_security_level_, info);
}
bool CryptoSession::GetBuildInformation(SecurityLevel security_level,
bool CryptoSession::GetBuildInformation(RequestedSecurityLevel security_level,
std::string* info) {
LOGV("Getting build information: security_level = %s",
SecurityLevelToString(security_level));
RequestedSecurityLevelToString(security_level));
RETURN_IF_UNINITIALIZED(false);
RETURN_IF_NULL(info, false);
@@ -2308,10 +2310,10 @@ bool CryptoSession::GetBuildInformation(SecurityLevel security_level,
return true;
}
bool CryptoSession::GetMaximumUsageTableEntries(SecurityLevel security_level,
size_t* number_of_entries) {
bool CryptoSession::GetMaximumUsageTableEntries(
RequestedSecurityLevel security_level, size_t* number_of_entries) {
LOGV("Getting maximum usage table entries: security_level = %s",
SecurityLevelToString(security_level));
RequestedSecurityLevelToString(security_level));
RETURN_IF_UNINITIALIZED(false);
if (number_of_entries == nullptr) {
LOGE("Output parameter |number_of_entries| not provided");
@@ -2332,7 +2334,7 @@ bool CryptoSession::GetMaximumUsageTableEntries(SecurityLevel security_level,
return *number_of_entries >= kMinimumUsageTableEntriesSupported;
}
bool CryptoSession::GetDecryptHashSupport(SecurityLevel security_level,
bool CryptoSession::GetDecryptHashSupport(RequestedSecurityLevel security_level,
uint32_t* decrypt_hash_support) {
LOGV("Checking if decrypt hash is supported");
RETURN_IF_UNINITIALIZED(false);
@@ -2649,10 +2651,10 @@ CdmResponseType CryptoSession::GenericVerify(const std::string& message,
}
CdmResponseType CryptoSession::CreateUsageTableHeader(
SecurityLevel requested_security_level,
RequestedSecurityLevel requested_security_level,
CdmUsageTableHeader* usage_table_header) {
LOGV("Creating usage table header: requested_security_level = %s",
SecurityLevelToString(requested_security_level));
RequestedSecurityLevelToString(requested_security_level));
RETURN_IF_NULL(usage_table_header, PARAMETER_NULL);
usage_table_header->resize(kEstimatedInitialUsageTableHeader);
@@ -2690,10 +2692,10 @@ CdmResponseType CryptoSession::CreateUsageTableHeader(
}
CdmResponseType CryptoSession::LoadUsageTableHeader(
SecurityLevel requested_security_level,
RequestedSecurityLevel requested_security_level,
const CdmUsageTableHeader& usage_table_header) {
LOGV("Loading usage table header: requested_security_level = %s",
SecurityLevelToString(requested_security_level));
RequestedSecurityLevelToString(requested_security_level));
const OEMCryptoResult result = WithOecWriteLock("LoadUsageTableHeader", [&] {
return OEMCrypto_LoadUsageTableHeader(
@@ -2731,10 +2733,10 @@ CdmResponseType CryptoSession::LoadUsageTableHeader(
}
CdmResponseType CryptoSession::ShrinkUsageTableHeader(
SecurityLevel requested_security_level, uint32_t new_entry_count,
RequestedSecurityLevel requested_security_level, uint32_t new_entry_count,
CdmUsageTableHeader* usage_table_header) {
LOGV("Shrinking usage table header: requested_security_level = %s",
SecurityLevelToString(requested_security_level));
RequestedSecurityLevelToString(requested_security_level));
RETURN_IF_NULL(usage_table_header, PARAMETER_NULL);
size_t usage_table_header_len = 0;

79
libwvdrmengine/cdm/core/src/oemcrypto_adapter_dynamic.cpp
View File

@@ -1267,7 +1267,8 @@ class Adapter {
return result;
}
const FunctionPointers* GetFunctionPointers(wvcdm::SecurityLevel level) {
const FunctionPointers* GetFunctionPointers(
wvcdm::RequestedSecurityLevel level) {
if (level1_valid_ && level == kLevelDefault) return &level1_;
return &level3_;
}
@@ -1282,7 +1283,7 @@ class Adapter {
}
OEMCryptoResult OpenSession(OEMCrypto_SESSION* session,
wvcdm::SecurityLevel level) {
wvcdm::RequestedSecurityLevel level) {
LevelSession new_session;
OEMCryptoResult result;
if (level == kLevelDefault && level1_valid_) {
@@ -1592,14 +1593,14 @@ OEMCryptoResult OEMCrypto_InitializeAndCheckKeybox(
}
OEMCryptoResult OEMCrypto_OpenSession(OEMCrypto_SESSION* session,
SecurityLevel level) {
wvcdm::RequestedSecurityLevel level) {
if (!gAdapter) return OEMCrypto_ERROR_OPEN_SESSION_FAILED;
return gAdapter->OpenSession(session, level);
}
OEMCryptoResult OEMCrypto_InstallKeyboxOrOEMCert(const uint8_t* keybox,
size_t keyBoxLength,
SecurityLevel level) {
OEMCryptoResult OEMCrypto_InstallKeyboxOrOEMCert(
const uint8_t* keybox, size_t keyBoxLength,
wvcdm::RequestedSecurityLevel level) {
if (!gAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
@@ -1609,7 +1610,7 @@ OEMCryptoResult OEMCrypto_InstallKeyboxOrOEMCert(const uint8_t* keybox,
}
OEMCrypto_ProvisioningMethod OEMCrypto_GetProvisioningMethod(
SecurityLevel level) {
wvcdm::RequestedSecurityLevel level) {
if (!gAdapter) return OEMCrypto_ProvisioningError;
const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
if (!fcn) return OEMCrypto_ProvisioningError;
@@ -1619,7 +1620,7 @@ OEMCrypto_ProvisioningMethod OEMCrypto_GetProvisioningMethod(
}
OEMCryptoResult OEMCrypto_GetDeviceID(uint8_t* deviceID, size_t* idLength,
SecurityLevel level) {
wvcdm::RequestedSecurityLevel level) {
if (!gAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
@@ -1632,7 +1633,7 @@ OEMCryptoResult OEMCrypto_GetDeviceID(uint8_t* deviceID, size_t* idLength,
}
OEMCryptoResult OEMCrypto_GetKeyData(uint8_t* keyData, size_t* keyDataLength,
SecurityLevel level) {
wvcdm::RequestedSecurityLevel level) {
if (!gAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
@@ -1644,7 +1645,7 @@ OEMCryptoResult OEMCrypto_GetKeyData(uint8_t* keyData, size_t* keyDataLength,
return fcn->GetKeyData(keyData, keyDataLength);
}
uint32_t OEMCrypto_APIVersion(SecurityLevel level) {
uint32_t OEMCrypto_APIVersion(wvcdm::RequestedSecurityLevel level) {
if (!gAdapter) return 0;
const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
if (!fcn) return 0;
@@ -1652,7 +1653,7 @@ uint32_t OEMCrypto_APIVersion(SecurityLevel level) {
return fcn->APIVersion();
}
uint32_t OEMCrypto_MinorAPIVersion(SecurityLevel level) {
uint32_t OEMCrypto_MinorAPIVersion(wvcdm::RequestedSecurityLevel level) {
if (!gAdapter) return 0;
const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
if (!fcn) return 0;
@@ -1660,7 +1661,7 @@ uint32_t OEMCrypto_MinorAPIVersion(SecurityLevel level) {
return fcn->MinorAPIVersion();
}
uint8_t OEMCrypto_Security_Patch_Level(SecurityLevel level) {
uint8_t OEMCrypto_Security_Patch_Level(wvcdm::RequestedSecurityLevel level) {
if (!gAdapter) return 0;
const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
if (!fcn) return 0;
@@ -1669,7 +1670,7 @@ uint8_t OEMCrypto_Security_Patch_Level(SecurityLevel level) {
return fcn->SecurityPatchLevel();
}
OEMCrypto_Security_Level OEMCrypto_SecurityLevel(SecurityLevel level) {
OEMCrypto_Security_Level OEMCrypto_SecurityLevel(wvcdm::RequestedSecurityLevel level) {
if (!gAdapter) return OEMCrypto_Level_Unknown;
const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
if (!fcn) return OEMCrypto_Level_Unknown;
@@ -1691,7 +1692,7 @@ OEMCrypto_Security_Level OEMCrypto_SecurityLevel(SecurityLevel level) {
}
OEMCryptoResult OEMCrypto_GetHDCPCapability(
SecurityLevel level, OEMCrypto_HDCP_Capability* current,
wvcdm::RequestedSecurityLevel level, OEMCrypto_HDCP_Capability* current,
OEMCrypto_HDCP_Capability* maximum) {
if (!gAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
@@ -1715,7 +1716,7 @@ OEMCryptoResult OEMCrypto_GetHDCPCapability(
}
}
uint32_t OEMCrypto_GetAnalogOutputFlags(SecurityLevel level) {
uint32_t OEMCrypto_GetAnalogOutputFlags(wvcdm::RequestedSecurityLevel level) {
if (!gAdapter) return OEMCrypto_Unknown_Analog_Output;
const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
if (!fcn) return OEMCrypto_Unknown_Analog_Output;
@@ -1726,7 +1727,7 @@ uint32_t OEMCrypto_GetAnalogOutputFlags(SecurityLevel level) {
}
OEMCryptoResult OEMCrypto_BuildInformation(char* buffer, size_t* buffer_length,
SecurityLevel level) {
wvcdm::RequestedSecurityLevel level) {
if (!gAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
@@ -1748,7 +1749,7 @@ OEMCryptoResult OEMCrypto_BuildInformation(char* buffer, size_t* buffer_length,
return fcn->BuildInformation(buffer, buffer_length);
}
uint32_t OEMCrypto_ResourceRatingTier(SecurityLevel level) {
uint32_t OEMCrypto_ResourceRatingTier(wvcdm::RequestedSecurityLevel level) {
if (!gAdapter) return 0;
const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
if (!fcn) return 0;
@@ -1757,7 +1758,7 @@ uint32_t OEMCrypto_ResourceRatingTier(SecurityLevel level) {
return fcn->ResourceRatingTier();
}
uint32_t OEMCrypto_SupportsDecryptHash(SecurityLevel level) {
uint32_t OEMCrypto_SupportsDecryptHash(wvcdm::RequestedSecurityLevel level) {
if (!gAdapter) return OEMCrypto_Hash_Not_Supported;
const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
if (!fcn) return OEMCrypto_Hash_Not_Supported;
@@ -1766,7 +1767,8 @@ uint32_t OEMCrypto_SupportsDecryptHash(SecurityLevel level) {
return fcn->SupportsDecryptHash();
}
size_t OEMCrypto_MaximumUsageTableHeaderSize(SecurityLevel level) {
size_t OEMCrypto_MaximumUsageTableHeaderSize(
wvcdm::RequestedSecurityLevel level) {
if (!gAdapter.get()) return 0;
const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
if (!fcn) return 0;
@@ -1775,7 +1777,7 @@ size_t OEMCrypto_MaximumUsageTableHeaderSize(SecurityLevel level) {
return fcn->MaximumUsageTableHeaderSize();
}
bool OEMCrypto_SupportsUsageTable(SecurityLevel level) {
bool OEMCrypto_SupportsUsageTable(wvcdm::RequestedSecurityLevel level) {
if (!gAdapter) return false;
const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
if (!fcn) return false;
@@ -1784,7 +1786,7 @@ bool OEMCrypto_SupportsUsageTable(SecurityLevel level) {
return fcn->SupportsUsageTable();
}
bool OEMCrypto_IsAntiRollbackHwPresent(SecurityLevel level) {
bool OEMCrypto_IsAntiRollbackHwPresent(wvcdm::RequestedSecurityLevel level) {
if (!gAdapter) return false;
const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
if (!fcn) return false;
@@ -1793,8 +1795,8 @@ bool OEMCrypto_IsAntiRollbackHwPresent(SecurityLevel level) {
return fcn->IsAntiRollbackHwPresent();
}
OEMCryptoResult OEMCrypto_GetNumberOfOpenSessions(SecurityLevel level,
size_t* count) {
OEMCryptoResult OEMCrypto_GetNumberOfOpenSessions(
wvcdm::RequestedSecurityLevel level, size_t* count) {
if (!gAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
@@ -1802,8 +1804,8 @@ OEMCryptoResult OEMCrypto_GetNumberOfOpenSessions(SecurityLevel level,
return fcn->GetNumberOfOpenSessions(count);
}
OEMCryptoResult OEMCrypto_GetMaxNumberOfSessions(SecurityLevel level,
size_t* maximum) {
OEMCryptoResult OEMCrypto_GetMaxNumberOfSessions(
wvcdm::RequestedSecurityLevel level, size_t* maximum) {
if (!gAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
@@ -1818,7 +1820,7 @@ OEMCryptoResult OEMCrypto_GetMaxNumberOfSessions(SecurityLevel level,
return result;
}
uint32_t OEMCrypto_SupportedCertificates(SecurityLevel level) {
uint32_t OEMCrypto_SupportedCertificates(wvcdm::RequestedSecurityLevel level) {
if (!gAdapter) return 0;
const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
if (!fcn) return 0;
@@ -1829,9 +1831,9 @@ uint32_t OEMCrypto_SupportedCertificates(SecurityLevel level) {
return fcn->SupportedCertificates();
}
OEMCryptoResult OEMCrypto_CreateUsageTableHeader(SecurityLevel level,
uint8_t* header_buffer,
size_t* header_buffer_length) {
OEMCryptoResult OEMCrypto_CreateUsageTableHeader(
wvcdm::RequestedSecurityLevel level, uint8_t* header_buffer,
size_t* header_buffer_length) {
if (!gAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
@@ -1841,9 +1843,9 @@ OEMCryptoResult OEMCrypto_CreateUsageTableHeader(SecurityLevel level,
return fcn->CreateUsageTableHeader(header_buffer, header_buffer_length);
}
OEMCryptoResult OEMCrypto_LoadUsageTableHeader(SecurityLevel level,
const uint8_t* buffer,
size_t buffer_length) {
OEMCryptoResult OEMCrypto_LoadUsageTableHeader(
wvcdm::RequestedSecurityLevel level, const uint8_t* buffer,
size_t buffer_length) {
if (!gAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
@@ -1853,10 +1855,9 @@ OEMCryptoResult OEMCrypto_LoadUsageTableHeader(SecurityLevel level,
return fcn->LoadUsageTableHeader(buffer, buffer_length);
}
OEMCryptoResult OEMCrypto_ShrinkUsageTableHeader(SecurityLevel level,
uint32_t new_table_size,
uint8_t* header_buffer,
size_t* header_buffer_length) {
OEMCryptoResult OEMCrypto_ShrinkUsageTableHeader(
wvcdm::RequestedSecurityLevel level, uint32_t new_table_size,
uint8_t* header_buffer, size_t* header_buffer_length) {
if (!gAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
@@ -1867,9 +1868,9 @@ OEMCryptoResult OEMCrypto_ShrinkUsageTableHeader(SecurityLevel level,
header_buffer_length);
}
OEMCryptoResult OEMCrypto_GetOEMPublicCertificate(uint8_t* public_cert,
size_t* public_cert_length,
SecurityLevel level) {
OEMCryptoResult OEMCrypto_GetOEMPublicCertificate(
uint8_t* public_cert, size_t* public_cert_length,
wvcdm::RequestedSecurityLevel level) {
if (!gAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;

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

@@ -146,7 +146,7 @@ bool IsValidCdmSecurityLevelForUsageInfo(CdmSecurityLevel security_level) {
security_level == kSecurityLevelL3;
}
SecurityLevel CdmSecurityLevelToRequestedLevel(
RequestedSecurityLevel CdmSecurityLevelToRequestedLevel(
CdmSecurityLevel security_level) {
return security_level == kSecurityLevelL3 ? kLevel3 : kLevelDefault;
}

3
libwvdrmengine/cdm/core/src/wv_cdm_types.cpp
View File

@@ -108,7 +108,8 @@ const char* CdmUsageEntryStorageTypeToString(CdmUsageEntryStorageType type) {
return UnknownValueRep(type);
}
const char* SecurityLevelToString(SecurityLevel security_level) {
const char* RequestedSecurityLevelToString(
RequestedSecurityLevel security_level) {
switch (security_level) {
case kLevelDefault:
return QUERY_VALUE_SECURITY_LEVEL_DEFAULT.c_str();