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

Revert "Use aidl interface for Widevine service."

Browse Source 
This reverts commit 96a8ccd4a1.

Reason for revert:
Could break DeviceManifest/SingleManifestTest#ManifestAidlHalsServed

Bug: 200055138
Bug: 170964303
Bug: 217241995
Change-Id: I9c42df15defec428c9ef8c62439c63d4a603fee6
This commit is contained in:
Yohei Yukawa
2022-01-31 22:01:25 +00:00
parent 96a8ccd4a1
commit a4d835af3a
75 changed files with 1480 additions and 7078 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(RequestedSecurityLevel security_level) {
void set_security_level(SecurityLevel 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));
}
RequestedSecurityLevel requested_security_level = kLevelDefault;
SecurityLevel 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(RequestedSecurityLevel security_level,
CdmResponseType CdmEngine::QueryStatus(SecurityLevel security_level,
const std::string& query_token,
std::string* query_response) {
LOGD("security_level = %s, query_token = %s",
RequestedSecurityLevelToString(security_level), IdToString(query_token));
SecurityLevelToString(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,
RequestedSecurityLevel requested_security_level,
CdmProvisioningRequest* request, std::string* default_url) {
SecurityLevel 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,
RequestedSecurityLevel requested_security_level, std::string* cert,
SecurityLevel requested_security_level, std::string* cert,
std::string* wrapped_key) {
LOGI("response_size = %zu, security_level = %s", response.size(),
RequestedSecurityLevelToString(requested_security_level));
SecurityLevelToString(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
RequestedSecurityLevel security_level =
SecurityLevel security_level =
wvutil::CdmRandom::RandomBool() ? kLevelDefault : kLevel3;
CdmResponseType status = UNKNOWN_ERROR;
do {
@@ -1460,11 +1460,12 @@ CdmResponseType CdmEngine::GetUsageInfo(const std::string& app_id,
return status;
}
CdmResponseType CdmEngine::GetUsageInfo(
const std::string& app_id, RequestedSecurityLevel requested_security_level,
int* error_detail, CdmUsageInfo* usage_info) {
CdmResponseType CdmEngine::GetUsageInfo(const std::string& app_id,
SecurityLevel requested_security_level,
int* error_detail,
CdmUsageInfo* usage_info) {
LOGI("app_id = %s, security_level = %s", IdToString(app_id),
RequestedSecurityLevelToString(requested_security_level));
SecurityLevelToString(requested_security_level));
if (usage_info == nullptr) {
LOGE("Output |usage_info| is null");
return PARAMETER_NULL;
@@ -1549,7 +1550,7 @@ CdmResponseType CdmEngine::RemoveAllUsageInfo(
CdmResponseType status = NO_ERROR;
DeviceFiles handle(file_system_);
if (handle.Init(cdm_security_level)) {
const RequestedSecurityLevel security_level =
const SecurityLevel 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()));
@@ -1623,7 +1624,7 @@ CdmResponseType CdmEngine::RemoveUsageInfo(
for (int j = kSecurityLevelL1; j < kSecurityLevelUnknown; ++j) {
DeviceFiles handle(file_system_);
if (handle.Init(static_cast<CdmSecurityLevel>(j))) {
RequestedSecurityLevel security_level =
SecurityLevel 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, RequestedSecurityLevel requested_security_level,
wvutil::FileSystem* file_system, SecurityLevel 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, RequestedSecurityLevel requested_security_level,
wvutil::FileSystem* file_system, SecurityLevel 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,8 +299,7 @@ CryptoSession::~CryptoSession() {
}
CdmResponseType CryptoSession::GetProvisioningMethod(
RequestedSecurityLevel requested_security_level,
CdmClientTokenType* token_type) {
SecurityLevel requested_security_level, CdmClientTokenType* token_type) {
OEMCrypto_ProvisioningMethod method;
WithOecReadLock("GetProvisioningMethod", [&] {
method = OEMCrypto_GetProvisioningMethod(requested_security_level);
@@ -468,7 +467,7 @@ void CryptoSession::DisableDelayedTermination() {
}
bool CryptoSession::SetUpUsageTableHeader(
RequestedSecurityLevel requested_security_level) {
SecurityLevel requested_security_level) {
if (usage_table_header_ != nullptr) {
LOGE("Usage table is already set up for the current crypto session");
return false;
@@ -617,9 +616,9 @@ CdmSecurityLevel CryptoSession::GetSecurityLevel() {
}
CdmSecurityLevel CryptoSession::GetSecurityLevel(
RequestedSecurityLevel requested_security_level) {
SecurityLevel requested_security_level) {
LOGV("Getting security level: requested_security_level = %s",
RequestedSecurityLevelToString(requested_security_level));
SecurityLevelToString(requested_security_level));
RETURN_IF_UNINITIALIZED(kSecurityLevelUninitialized);
const OEMCrypto_Security_Level level = WithOecReadLock(
"GetSecurityLevel",
@@ -642,7 +641,7 @@ CdmSecurityLevel CryptoSession::GetSecurityLevel(
"Ill-formed security level: "
"level = \"L%u\", requested_security_level = %s",
static_cast<unsigned int>(level),
RequestedSecurityLevelToString(requested_security_level));
SecurityLevelToString(requested_security_level));
return kSecurityLevelUnknown;
}
@@ -732,10 +731,10 @@ bool CryptoSession::GetApiVersion(uint32_t* version) {
return GetApiVersion(requested_security_level_, version);
}
bool CryptoSession::GetApiVersion(RequestedSecurityLevel security_level,
bool CryptoSession::GetApiVersion(SecurityLevel security_level,
uint32_t* version) {
LOGV("Getting API version: security_level = %s",
RequestedSecurityLevelToString(security_level));
SecurityLevelToString(security_level));
if (!version) {
LOGE("Output parameter |version| not provided");
return false;
@@ -750,10 +749,10 @@ bool CryptoSession::GetApiVersion(RequestedSecurityLevel security_level,
return true;
}
bool CryptoSession::GetApiMinorVersion(RequestedSecurityLevel security_level,
bool CryptoSession::GetApiMinorVersion(SecurityLevel security_level,
uint32_t* minor_version) {
LOGV("Getting API minor version: security_level = %s",
RequestedSecurityLevelToString(security_level));
SecurityLevelToString(security_level));
if (!minor_version) {
LOGE("Output parameter |minor_version| not provided");
return false;
@@ -891,10 +890,9 @@ uint8_t CryptoSession::GetSecurityPatchLevel() {
return patch;
}
CdmResponseType CryptoSession::Open(
RequestedSecurityLevel requested_security_level) {
CdmResponseType CryptoSession::Open(SecurityLevel requested_security_level) {
LOGD("Opening crypto session: requested_security_level = %s",
RequestedSecurityLevelToString(requested_security_level));
SecurityLevelToString(requested_security_level));
RETURN_IF_UNINITIALIZED(CRYPTO_SESSION_NOT_INITIALIZED);
if (open_) return NO_ERROR;
@@ -1874,8 +1872,8 @@ bool CryptoSession::HasUsageInfoSupport(bool* has_support) {
});
}
bool CryptoSession::HasUsageInfoSupport(
RequestedSecurityLevel requested_security_level, bool* has_support) {
bool CryptoSession::HasUsageInfoSupport(SecurityLevel requested_security_level,
bool* has_support) {
RETURN_IF_UNINITIALIZED(false);
RETURN_IF_NULL(has_support, false);
return WithOecReadLock("HasUsageInfoSupport", [&] {
@@ -1884,9 +1882,9 @@ bool CryptoSession::HasUsageInfoSupport(
}
bool CryptoSession::HasUsageInfoSupportInternal(
RequestedSecurityLevel requested_security_level, bool* has_support) {
SecurityLevel requested_security_level, bool* has_support) {
LOGV("requested_security_level = %s",
RequestedSecurityLevelToString(requested_security_level));
SecurityLevelToString(requested_security_level));
*has_support = WithOecReadLock("HasUsageInfoSupport", [&] {
return OEMCrypto_SupportsUsageTable(requested_security_level);
});
@@ -2111,11 +2109,11 @@ CdmResponseType CryptoSession::GetHdcpCapabilities(HdcpCapability* current,
return GetHdcpCapabilities(requested_security_level_, current, max);
}
CdmResponseType CryptoSession::GetHdcpCapabilities(
RequestedSecurityLevel security_level, HdcpCapability* current,
HdcpCapability* max) {
CdmResponseType CryptoSession::GetHdcpCapabilities(SecurityLevel security_level,
HdcpCapability* current,
HdcpCapability* max) {
LOGV("Getting HDCP capabilities: id = %u, security_level = %s",
oec_session_id_, RequestedSecurityLevelToString(security_level));
oec_session_id_, SecurityLevelToString(security_level));
RETURN_IF_UNINITIALIZED(CRYPTO_SESSION_NOT_INITIALIZED);
RETURN_IF_NULL(current, PARAMETER_NULL);
RETURN_IF_NULL(max, PARAMETER_NULL);
@@ -2168,9 +2166,9 @@ CdmResponseType CryptoSession::GetRandom(size_t data_length,
}
CdmResponseType CryptoSession::GetNumberOfOpenSessions(
RequestedSecurityLevel security_level, size_t* count) {
SecurityLevel security_level, size_t* count) {
LOGV("Getting number of open sessions: id = %u, security_level = %s",
oec_session_id_, RequestedSecurityLevelToString(security_level));
oec_session_id_, SecurityLevelToString(security_level));
RETURN_IF_UNINITIALIZED(CRYPTO_SESSION_NOT_INITIALIZED);
RETURN_IF_NULL(count, PARAMETER_NULL);
@@ -2192,9 +2190,9 @@ CdmResponseType CryptoSession::GetNumberOfOpenSessions(
}
CdmResponseType CryptoSession::GetMaxNumberOfSessions(
RequestedSecurityLevel security_level, size_t* max) {
SecurityLevel security_level, size_t* max) {
LOGV("Getting max number of sessions: id = %u, security_level = %s",
oec_session_id_, RequestedSecurityLevelToString(security_level));
oec_session_id_, SecurityLevelToString(security_level));
RETURN_IF_UNINITIALIZED(CRYPTO_SESSION_NOT_INITIALIZED);
RETURN_IF_NULL(max, PARAMETER_NULL);
@@ -2250,10 +2248,10 @@ bool CryptoSession::GetResourceRatingTier(uint32_t* tier) {
return GetResourceRatingTier(requested_security_level_, tier);
}
bool CryptoSession::GetResourceRatingTier(RequestedSecurityLevel security_level,
bool CryptoSession::GetResourceRatingTier(SecurityLevel security_level,
uint32_t* tier) {
LOGV("Getting resource rating tier: security_level = %s",
RequestedSecurityLevelToString(security_level));
SecurityLevelToString(security_level));
RETURN_IF_UNINITIALIZED(false);
RETURN_IF_NULL(tier, false);
@@ -2278,10 +2276,10 @@ bool CryptoSession::GetBuildInformation(std::string* info) {
return GetBuildInformation(requested_security_level_, info);
}
bool CryptoSession::GetBuildInformation(RequestedSecurityLevel security_level,
bool CryptoSession::GetBuildInformation(SecurityLevel security_level,
std::string* info) {
LOGV("Getting build information: security_level = %s",
RequestedSecurityLevelToString(security_level));
SecurityLevelToString(security_level));
RETURN_IF_UNINITIALIZED(false);
RETURN_IF_NULL(info, false);
@@ -2310,10 +2308,10 @@ bool CryptoSession::GetBuildInformation(RequestedSecurityLevel security_level,
return true;
}
bool CryptoSession::GetMaximumUsageTableEntries(
RequestedSecurityLevel security_level, size_t* number_of_entries) {
bool CryptoSession::GetMaximumUsageTableEntries(SecurityLevel security_level,
size_t* number_of_entries) {
LOGV("Getting maximum usage table entries: security_level = %s",
RequestedSecurityLevelToString(security_level));
SecurityLevelToString(security_level));
RETURN_IF_UNINITIALIZED(false);
if (number_of_entries == nullptr) {
LOGE("Output parameter |number_of_entries| not provided");
@@ -2334,7 +2332,7 @@ bool CryptoSession::GetMaximumUsageTableEntries(
return *number_of_entries >= kMinimumUsageTableEntriesSupported;
}
bool CryptoSession::GetDecryptHashSupport(RequestedSecurityLevel security_level,
bool CryptoSession::GetDecryptHashSupport(SecurityLevel security_level,
uint32_t* decrypt_hash_support) {
LOGV("Checking if decrypt hash is supported");
RETURN_IF_UNINITIALIZED(false);
@@ -2651,10 +2649,10 @@ CdmResponseType CryptoSession::GenericVerify(const std::string& message,
}
CdmResponseType CryptoSession::CreateUsageTableHeader(
RequestedSecurityLevel requested_security_level,
SecurityLevel requested_security_level,
CdmUsageTableHeader* usage_table_header) {
LOGV("Creating usage table header: requested_security_level = %s",
RequestedSecurityLevelToString(requested_security_level));
SecurityLevelToString(requested_security_level));
RETURN_IF_NULL(usage_table_header, PARAMETER_NULL);
usage_table_header->resize(kEstimatedInitialUsageTableHeader);
@@ -2692,10 +2690,10 @@ CdmResponseType CryptoSession::CreateUsageTableHeader(
}
CdmResponseType CryptoSession::LoadUsageTableHeader(
RequestedSecurityLevel requested_security_level,
SecurityLevel requested_security_level,
const CdmUsageTableHeader& usage_table_header) {
LOGV("Loading usage table header: requested_security_level = %s",
RequestedSecurityLevelToString(requested_security_level));
SecurityLevelToString(requested_security_level));
const OEMCryptoResult result = WithOecWriteLock("LoadUsageTableHeader", [&] {
return OEMCrypto_LoadUsageTableHeader(
@@ -2733,10 +2731,10 @@ CdmResponseType CryptoSession::LoadUsageTableHeader(
}
CdmResponseType CryptoSession::ShrinkUsageTableHeader(
RequestedSecurityLevel requested_security_level, uint32_t new_entry_count,
SecurityLevel requested_security_level, uint32_t new_entry_count,
CdmUsageTableHeader* usage_table_header) {
LOGV("Shrinking usage table header: requested_security_level = %s",
RequestedSecurityLevelToString(requested_security_level));
SecurityLevelToString(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,8 +1267,7 @@ class Adapter {
return result;
}
const FunctionPointers* GetFunctionPointers(
wvcdm::RequestedSecurityLevel level) {
const FunctionPointers* GetFunctionPointers(wvcdm::SecurityLevel level) {
if (level1_valid_ && level == kLevelDefault) return &level1_;
return &level3_;
}
@@ -1283,7 +1282,7 @@ class Adapter {
}
OEMCryptoResult OpenSession(OEMCrypto_SESSION* session,
wvcdm::RequestedSecurityLevel level) {
wvcdm::SecurityLevel level) {
LevelSession new_session;
OEMCryptoResult result;
if (level == kLevelDefault && level1_valid_) {
@@ -1593,14 +1592,14 @@ OEMCryptoResult OEMCrypto_InitializeAndCheckKeybox(
}
OEMCryptoResult OEMCrypto_OpenSession(OEMCrypto_SESSION* session,
wvcdm::RequestedSecurityLevel level) {
SecurityLevel level) {
if (!gAdapter) return OEMCrypto_ERROR_OPEN_SESSION_FAILED;
return gAdapter->OpenSession(session, level);
}
OEMCryptoResult OEMCrypto_InstallKeyboxOrOEMCert(
const uint8_t* keybox, size_t keyBoxLength,
wvcdm::RequestedSecurityLevel level) {
OEMCryptoResult OEMCrypto_InstallKeyboxOrOEMCert(const uint8_t* keybox,
size_t keyBoxLength,
SecurityLevel level) {
if (!gAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
@@ -1610,7 +1609,7 @@ OEMCryptoResult OEMCrypto_InstallKeyboxOrOEMCert(
}
OEMCrypto_ProvisioningMethod OEMCrypto_GetProvisioningMethod(
wvcdm::RequestedSecurityLevel level) {
SecurityLevel level) {
if (!gAdapter) return OEMCrypto_ProvisioningError;
const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
if (!fcn) return OEMCrypto_ProvisioningError;
@@ -1620,7 +1619,7 @@ OEMCrypto_ProvisioningMethod OEMCrypto_GetProvisioningMethod(
}
OEMCryptoResult OEMCrypto_GetDeviceID(uint8_t* deviceID, size_t* idLength,
wvcdm::RequestedSecurityLevel level) {
SecurityLevel level) {
if (!gAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
@@ -1633,7 +1632,7 @@ OEMCryptoResult OEMCrypto_GetDeviceID(uint8_t* deviceID, size_t* idLength,
}
OEMCryptoResult OEMCrypto_GetKeyData(uint8_t* keyData, size_t* keyDataLength,
wvcdm::RequestedSecurityLevel level) {
SecurityLevel level) {
if (!gAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
@@ -1645,7 +1644,7 @@ OEMCryptoResult OEMCrypto_GetKeyData(uint8_t* keyData, size_t* keyDataLength,
return fcn->GetKeyData(keyData, keyDataLength);
}
uint32_t OEMCrypto_APIVersion(wvcdm::RequestedSecurityLevel level) {
uint32_t OEMCrypto_APIVersion(SecurityLevel level) {
if (!gAdapter) return 0;
const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
if (!fcn) return 0;
@@ -1653,7 +1652,7 @@ uint32_t OEMCrypto_APIVersion(wvcdm::RequestedSecurityLevel level) {
return fcn->APIVersion();
}
uint32_t OEMCrypto_MinorAPIVersion(wvcdm::RequestedSecurityLevel level) {
uint32_t OEMCrypto_MinorAPIVersion(SecurityLevel level) {
if (!gAdapter) return 0;
const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
if (!fcn) return 0;
@@ -1661,7 +1660,7 @@ uint32_t OEMCrypto_MinorAPIVersion(wvcdm::RequestedSecurityLevel level) {
return fcn->MinorAPIVersion();
}
uint8_t OEMCrypto_Security_Patch_Level(wvcdm::RequestedSecurityLevel level) {
uint8_t OEMCrypto_Security_Patch_Level(SecurityLevel level) {
if (!gAdapter) return 0;
const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
if (!fcn) return 0;
@@ -1670,7 +1669,7 @@ uint8_t OEMCrypto_Security_Patch_Level(wvcdm::RequestedSecurityLevel level) {
return fcn->SecurityPatchLevel();
}
OEMCrypto_Security_Level OEMCrypto_SecurityLevel(wvcdm::RequestedSecurityLevel level) {
OEMCrypto_Security_Level OEMCrypto_SecurityLevel(SecurityLevel level) {
if (!gAdapter) return OEMCrypto_Level_Unknown;
const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
if (!fcn) return OEMCrypto_Level_Unknown;
@@ -1692,7 +1691,7 @@ OEMCrypto_Security_Level OEMCrypto_SecurityLevel(wvcdm::RequestedSecurityLevel l
}
OEMCryptoResult OEMCrypto_GetHDCPCapability(
wvcdm::RequestedSecurityLevel level, OEMCrypto_HDCP_Capability* current,
SecurityLevel level, OEMCrypto_HDCP_Capability* current,
OEMCrypto_HDCP_Capability* maximum) {
if (!gAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
@@ -1716,7 +1715,7 @@ OEMCryptoResult OEMCrypto_GetHDCPCapability(
}
}
uint32_t OEMCrypto_GetAnalogOutputFlags(wvcdm::RequestedSecurityLevel level) {
uint32_t OEMCrypto_GetAnalogOutputFlags(SecurityLevel level) {
if (!gAdapter) return OEMCrypto_Unknown_Analog_Output;
const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
if (!fcn) return OEMCrypto_Unknown_Analog_Output;
@@ -1727,7 +1726,7 @@ uint32_t OEMCrypto_GetAnalogOutputFlags(wvcdm::RequestedSecurityLevel level) {
}
OEMCryptoResult OEMCrypto_BuildInformation(char* buffer, size_t* buffer_length,
wvcdm::RequestedSecurityLevel level) {
SecurityLevel level) {
if (!gAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
@@ -1749,7 +1748,7 @@ OEMCryptoResult OEMCrypto_BuildInformation(char* buffer, size_t* buffer_length,
return fcn->BuildInformation(buffer, buffer_length);
}
uint32_t OEMCrypto_ResourceRatingTier(wvcdm::RequestedSecurityLevel level) {
uint32_t OEMCrypto_ResourceRatingTier(SecurityLevel level) {
if (!gAdapter) return 0;
const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
if (!fcn) return 0;
@@ -1758,7 +1757,7 @@ uint32_t OEMCrypto_ResourceRatingTier(wvcdm::RequestedSecurityLevel level) {
return fcn->ResourceRatingTier();
}
uint32_t OEMCrypto_SupportsDecryptHash(wvcdm::RequestedSecurityLevel level) {
uint32_t OEMCrypto_SupportsDecryptHash(SecurityLevel level) {
if (!gAdapter) return OEMCrypto_Hash_Not_Supported;
const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
if (!fcn) return OEMCrypto_Hash_Not_Supported;
@@ -1767,8 +1766,7 @@ uint32_t OEMCrypto_SupportsDecryptHash(wvcdm::RequestedSecurityLevel level) {
return fcn->SupportsDecryptHash();
}
size_t OEMCrypto_MaximumUsageTableHeaderSize(
wvcdm::RequestedSecurityLevel level) {
size_t OEMCrypto_MaximumUsageTableHeaderSize(SecurityLevel level) {
if (!gAdapter.get()) return 0;
const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
if (!fcn) return 0;
@@ -1777,7 +1775,7 @@ size_t OEMCrypto_MaximumUsageTableHeaderSize(
return fcn->MaximumUsageTableHeaderSize();
}
bool OEMCrypto_SupportsUsageTable(wvcdm::RequestedSecurityLevel level) {
bool OEMCrypto_SupportsUsageTable(SecurityLevel level) {
if (!gAdapter) return false;
const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
if (!fcn) return false;
@@ -1786,7 +1784,7 @@ bool OEMCrypto_SupportsUsageTable(wvcdm::RequestedSecurityLevel level) {
return fcn->SupportsUsageTable();
}
bool OEMCrypto_IsAntiRollbackHwPresent(wvcdm::RequestedSecurityLevel level) {
bool OEMCrypto_IsAntiRollbackHwPresent(SecurityLevel level) {
if (!gAdapter) return false;
const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
if (!fcn) return false;
@@ -1795,8 +1793,8 @@ bool OEMCrypto_IsAntiRollbackHwPresent(wvcdm::RequestedSecurityLevel level) {
return fcn->IsAntiRollbackHwPresent();
}
OEMCryptoResult OEMCrypto_GetNumberOfOpenSessions(
wvcdm::RequestedSecurityLevel level, size_t* count) {
OEMCryptoResult OEMCrypto_GetNumberOfOpenSessions(SecurityLevel level,
size_t* count) {
if (!gAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
@@ -1804,8 +1802,8 @@ OEMCryptoResult OEMCrypto_GetNumberOfOpenSessions(
return fcn->GetNumberOfOpenSessions(count);
}
OEMCryptoResult OEMCrypto_GetMaxNumberOfSessions(
wvcdm::RequestedSecurityLevel level, size_t* maximum) {
OEMCryptoResult OEMCrypto_GetMaxNumberOfSessions(SecurityLevel level,
size_t* maximum) {
if (!gAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
@@ -1820,7 +1818,7 @@ OEMCryptoResult OEMCrypto_GetMaxNumberOfSessions(
return result;
}
uint32_t OEMCrypto_SupportedCertificates(wvcdm::RequestedSecurityLevel level) {
uint32_t OEMCrypto_SupportedCertificates(SecurityLevel level) {
if (!gAdapter) return 0;
const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
if (!fcn) return 0;
@@ -1831,9 +1829,9 @@ uint32_t OEMCrypto_SupportedCertificates(wvcdm::RequestedSecurityLevel level) {
return fcn->SupportedCertificates();
}
OEMCryptoResult OEMCrypto_CreateUsageTableHeader(
wvcdm::RequestedSecurityLevel level, uint8_t* header_buffer,
size_t* header_buffer_length) {
OEMCryptoResult OEMCrypto_CreateUsageTableHeader(SecurityLevel 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;
@@ -1843,9 +1841,9 @@ OEMCryptoResult OEMCrypto_CreateUsageTableHeader(
return fcn->CreateUsageTableHeader(header_buffer, header_buffer_length);
}
OEMCryptoResult OEMCrypto_LoadUsageTableHeader(
wvcdm::RequestedSecurityLevel level, const uint8_t* buffer,
size_t buffer_length) {
OEMCryptoResult OEMCrypto_LoadUsageTableHeader(SecurityLevel 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;
@@ -1855,9 +1853,10 @@ OEMCryptoResult OEMCrypto_LoadUsageTableHeader(
return fcn->LoadUsageTableHeader(buffer, buffer_length);
}
OEMCryptoResult OEMCrypto_ShrinkUsageTableHeader(
wvcdm::RequestedSecurityLevel level, uint32_t new_table_size,
uint8_t* header_buffer, size_t* header_buffer_length) {
OEMCryptoResult OEMCrypto_ShrinkUsageTableHeader(SecurityLevel 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;
@@ -1868,9 +1867,9 @@ OEMCryptoResult OEMCrypto_ShrinkUsageTableHeader(
header_buffer_length);
}
OEMCryptoResult OEMCrypto_GetOEMPublicCertificate(
uint8_t* public_cert, size_t* public_cert_length,
wvcdm::RequestedSecurityLevel level) {
OEMCryptoResult OEMCrypto_GetOEMPublicCertificate(uint8_t* public_cert,
size_t* public_cert_length,
SecurityLevel 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;
}
RequestedSecurityLevel CdmSecurityLevelToRequestedLevel(
SecurityLevel CdmSecurityLevelToRequestedLevel(
CdmSecurityLevel security_level) {
return security_level == kSecurityLevelL3 ? kLevel3 : kLevelDefault;
}

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

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