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

Add "copts = PUBLIC_COPTS" option

Browse Source 
-------------
Use forward declaration in wvpl_sdk_session.h

-------------
Created by MOE: https://github.com/google/moe
MOE_MIGRATED_REVID=227753690
This commit is contained in:
Fang Yu
2019-01-03 14:45:58 -08:00
parent ed36938c81
commit f234dd036d
4 changed files with 122 additions and 109 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
media_cas_proxy_sdk/external/common/wvpl/BUILD vendored
View File

@@ -12,6 +12,12 @@ package(
default_visibility = ["//visibility:public"], default_visibility = ["//visibility:public"],
) )
# Defines the common copts for cc_library targets. The main option here is
# -fvisibility=default, which exports symbols from the public APIs in the shared
# library.
# Note that the shared library should be built with -fvisibility=hidden.
PUBLIC_COPTS = ["-fvisibility=default"]
filegroup( filegroup(
name = "binary_release_files", name = "binary_release_files",
srcs = glob(["*.h"]), srcs = glob(["*.h"]),
@@ -44,6 +50,7 @@ cc_library(
hdrs = [ hdrs = [
"wvpl_cas_proxy_session.h", "wvpl_cas_proxy_session.h",
], ],
copts = PUBLIC_COPTS,
deps = [ deps = [
"//base", "//base",
"@abseil_repo//absl/strings", "@abseil_repo//absl/strings",
@@ -62,6 +69,7 @@ cc_library(
"wvpl_cas_proxy_environment.h", "wvpl_cas_proxy_environment.h",
"wvpl_cas_proxy_session.h", "wvpl_cas_proxy_session.h",
], ],
copts = PUBLIC_COPTS,
deps = [ deps = [
"//base", "//base",
"@abseil_repo//absl/strings", "@abseil_repo//absl/strings",

165
sdk/external/common/wvpl/wvpl_sdk_session.cc vendored
View File

@@ -18,8 +18,10 @@
#include "license_server_sdk/internal/parse_content_id.h" #include "license_server_sdk/internal/parse_content_id.h"
#include "sdk/external/common/wvpl/wvpl_sdk_environment.h" #include "sdk/external/common/wvpl/wvpl_sdk_environment.h"
#include "sdk/external/common/wvpl/wvpl_types.h" #include "sdk/external/common/wvpl/wvpl_types.h"
#include "protos/public/client_identification.pb.h"
#include "protos/public/errors.pb.h" #include "protos/public/errors.pb.h"
#include "protos/public/license_protocol.pb.h" #include "protos/public/license_protocol.pb.h"
#include "protos/public/license_server_sdk.pb.h"
#include "protos/public/provisioned_device_info.pb.h" #include "protos/public/provisioned_device_info.pb.h"
#include "protos/public/widevine_pssh.pb.h" #include "protos/public/widevine_pssh.pb.h"
@@ -58,6 +60,74 @@ namespace error = widevine::error;
namespace widevine_server { namespace widevine_server {
namespace wv_pl_sdk { namespace wv_pl_sdk {
namespace {
// Copy the |hdcp_value| into the client_capabilities.
void CopyHDCPToClientCapabilities(
widevine::ClientIdentification::ClientCapabilities::HdcpVersion
hdcp_value,
WvPLClientCapabilities* client_capabilities) {
DCHECK(client_capabilities);
if (!client_capabilities) {
return;
}
switch (hdcp_value) {
case ClientIdentification::ClientCapabilities::HDCP_NONE:
client_capabilities->set_max_hdcp_version(HDCP_NONE);
break;
case ClientIdentification::ClientCapabilities::HDCP_V1:
client_capabilities->set_max_hdcp_version(HDCP_V1);
break;
case ClientIdentification::ClientCapabilities::HDCP_V2:
client_capabilities->set_max_hdcp_version(HDCP_V2);
break;
case ClientIdentification::ClientCapabilities::HDCP_V2_1:
client_capabilities->set_max_hdcp_version(HDCP_V2_1);
break;
case ClientIdentification::ClientCapabilities::HDCP_V2_2:
client_capabilities->set_max_hdcp_version(HDCP_V2_2);
break;
case ClientIdentification::ClientCapabilities::HDCP_V2_3:
client_capabilities->set_max_hdcp_version(HDCP_V2_3);
break;
case ClientIdentification::ClientCapabilities::HDCP_NO_DIGITAL_OUTPUT:
client_capabilities->set_max_hdcp_version(HDCP_NO_DIGITAL_OUTPUT);
break;
default:
break;
}
}
// Copy the |analog_output_capabilities| into the client_capabilities.
void CopyAnalogOutputCapabilities(
widevine::ClientIdentification::ClientCapabilities::
AnalogOutputCapabilities analog_output_capabilities,
WvPLClientCapabilities* client_capabilities) {
DCHECK(client_capabilities);
if (!client_capabilities) {
return;
}
switch (analog_output_capabilities) {
case ClientIdentification::ClientCapabilities::ANALOG_OUTPUT_UNKNOWN:
client_capabilities->set_analog_output_capabilities(
ANALOG_OUTPUT_UNKNOWN);
break;
case ClientIdentification::ClientCapabilities::ANALOG_OUTPUT_NONE:
client_capabilities->set_analog_output_capabilities(ANALOG_OUTPUT_NONE);
break;
case ClientIdentification::ClientCapabilities::ANALOG_OUTPUT_SUPPORTED:
client_capabilities->set_analog_output_capabilities(
ANALOG_OUTPUT_SUPPORTED);
break;
case ClientIdentification::ClientCapabilities::
ANALOG_OUTPUT_SUPPORTS_CGMS_A:
client_capabilities->set_analog_output_capabilities(
ANALOG_OUTPUT_SUPPORTS_CGMS_A);
break;
default:
break;
}
}
} // namespace
WvPLSDKSession::WvPLSDKSession(const DrmRootCertificate* drm_root_certificate) WvPLSDKSession::WvPLSDKSession(const DrmRootCertificate* drm_root_certificate)
: drm_root_certificate_(drm_root_certificate) {} : drm_root_certificate_(drm_root_certificate) {}
@@ -244,70 +314,6 @@ void WvPLSDKSession::CopyHDCP(
} }
} }
void WvPLSDKSession::CopyHDCPToClientCapabilities(
ClientIdentification::ClientCapabilities::HdcpVersion hdcp_value,
WvPLClientCapabilities* client_capabilities) const {
DCHECK(client_capabilities);
if (!client_capabilities) {
return;
}
switch (hdcp_value) {
case ClientIdentification::ClientCapabilities::HDCP_NONE:
client_capabilities->set_max_hdcp_version(HDCP_NONE);
break;
case ClientIdentification::ClientCapabilities::HDCP_V1:
client_capabilities->set_max_hdcp_version(HDCP_V1);
break;
case ClientIdentification::ClientCapabilities::HDCP_V2:
client_capabilities->set_max_hdcp_version(HDCP_V2);
break;
case ClientIdentification::ClientCapabilities::HDCP_V2_1:
client_capabilities->set_max_hdcp_version(HDCP_V2_1);
break;
case ClientIdentification::ClientCapabilities::HDCP_V2_2:
client_capabilities->set_max_hdcp_version(HDCP_V2_2);
break;
case ClientIdentification::ClientCapabilities::HDCP_V2_3:
client_capabilities->set_max_hdcp_version(HDCP_V2_3);
break;
case ClientIdentification::ClientCapabilities::HDCP_NO_DIGITAL_OUTPUT:
client_capabilities->set_max_hdcp_version(HDCP_NO_DIGITAL_OUTPUT);
break;
default:
break;
}
}
void WvPLSDKSession::CopyAnalogOutputCapabilities(
ClientIdentification::ClientCapabilities::AnalogOutputCapabilities
analog_output_capabilities,
WvPLClientCapabilities* client_capabilities) const {
DCHECK(client_capabilities);
if (!client_capabilities) {
return;
}
switch (analog_output_capabilities) {
case ClientIdentification::ClientCapabilities::ANALOG_OUTPUT_UNKNOWN:
client_capabilities->set_analog_output_capabilities(
ANALOG_OUTPUT_UNKNOWN);
break;
case ClientIdentification::ClientCapabilities::ANALOG_OUTPUT_NONE:
client_capabilities->set_analog_output_capabilities(ANALOG_OUTPUT_NONE);
break;
case ClientIdentification::ClientCapabilities::ANALOG_OUTPUT_SUPPORTED:
client_capabilities->set_analog_output_capabilities(
ANALOG_OUTPUT_SUPPORTED);
break;
case ClientIdentification::ClientCapabilities::
ANALOG_OUTPUT_SUPPORTS_CGMS_A:
client_capabilities->set_analog_output_capabilities(
ANALOG_OUTPUT_SUPPORTS_CGMS_A);
break;
default:
break;
}
}
void WvPLSDKSession::CopyOutputProtection( void WvPLSDKSession::CopyOutputProtection(
const WvPLKey& wvpl_key, License::KeyContainer* sdk_key_container) { const WvPLKey& wvpl_key, License::KeyContainer* sdk_key_container) {
DCHECK(sdk_key_container); DCHECK(sdk_key_container);
@@ -477,11 +483,13 @@ WvPLStatus WvPLSDKSession::ParseLicenseRequest() {
"are both specified in the license request"); "are both specified in the license request");
} }
if (sdk_license_request_->has_client_id()) { if (sdk_license_request_->has_client_id()) {
client_id_ = sdk_license_request_->client_id(); client_id_ = absl::make_unique<ClientIdentification>(
sdk_license_request_->client_id());
has_client_id_ = true; has_client_id_ = true;
} else if (sdk_license_request_->has_encrypted_client_id()) { } else if (sdk_license_request_->has_encrypted_client_id()) {
client_id_ = absl::make_unique<ClientIdentification>();
if (!DrmServiceCertificate::DecryptClientIdentification( if (!DrmServiceCertificate::DecryptClientIdentification(
sdk_license_request_->encrypted_client_id(), &client_id_) sdk_license_request_->encrypted_client_id(), client_id_.get())
.ok()) { .ok()) {
return WvPLStatus( return WvPLStatus(
error_space, error_space,
@@ -491,10 +499,10 @@ WvPLStatus WvPLSDKSession::ParseLicenseRequest() {
} }
has_client_id_ = true; has_client_id_ = true;
} }
if (client_id_.has_token() && if (client_id_->has_token() &&
client_id_.type() == ClientIdentification::KEYBOX) { client_id_->type() == ClientIdentification::KEYBOX) {
// Get system_id from token field in ClientIdentification. // Get system_id from token field in ClientIdentification.
SetSystemId(KeyboxClientCert::GetSystemId(client_id_.token())); SetSystemId(KeyboxClientCert::GetSystemId(client_id_->token()));
} }
if (!HasSystemId()) { if (!HasSystemId()) {
ClientCert* client_cert_ptr = nullptr; ClientCert* client_cert_ptr = nullptr;
@@ -518,7 +526,8 @@ WvPLStatus WvPLSDKSession::ParseLicenseRequest() {
has_pssh_data_ = true; has_pssh_data_ = true;
} }
} }
request_type_ = sdk_license_request_->type(); request_type_ =
static_cast<LicenseRequestType>(sdk_license_request_->type());
} }
return OkStatus(); return OkStatus();
} }
@@ -542,7 +551,7 @@ WvPLStatus WvPLSDKSession::GetClientInfo(WvPLClientInfo* client_info) const {
error_space, widevine::MISSING_CLIENT_ID, error_space, widevine::MISSING_CLIENT_ID,
"ClientIdentification is not found in the license request"); "ClientIdentification is not found in the license request");
} }
switch (client_id_.client_capabilities().max_hdcp_version()) { switch (client_id_->client_capabilities().max_hdcp_version()) {
case ClientIdentification::ClientCapabilities::HDCP_NONE: case ClientIdentification::ClientCapabilities::HDCP_NONE:
client_info->set_max_hdcp_version(HDCP_NONE); client_info->set_max_hdcp_version(HDCP_NONE);
break; break;
@@ -567,14 +576,14 @@ WvPLStatus WvPLSDKSession::GetClientInfo(WvPLClientInfo* client_info) const {
default: default:
break; break;
} }
if (client_id_.client_capabilities().has_oem_crypto_api_version()) { if (client_id_->client_capabilities().has_oem_crypto_api_version()) {
client_info->set_oem_crypto_api_version( client_info->set_oem_crypto_api_version(
client_id_.client_capabilities().oem_crypto_api_version()); client_id_->client_capabilities().oem_crypto_api_version());
} }
if (client_id_.has_provider_client_token()) { if (client_id_->has_provider_client_token()) {
client_info->set_provider_client_token(client_id_.provider_client_token()); client_info->set_provider_client_token(client_id_->provider_client_token());
} }
for (const auto& name_value : client_id_.client_info()) { for (const auto& name_value : client_id_->client_info()) {
client_info->set_name_value(name_value.name(), name_value.value()); client_info->set_name_value(name_value.name(), name_value.value());
} }
WvPLClientCapabilities client_capabilities; WvPLClientCapabilities client_capabilities;
@@ -614,7 +623,7 @@ WvPLStatus WvPLSDKSession::GetClientCapabilities(
error_space, widevine::MISSING_CLIENT_ID, error_space, widevine::MISSING_CLIENT_ID,
"ClientIdentification is not found in the license request"); "ClientIdentification is not found in the license request");
} }
status = GetWvPLClientCapabilities(client_id_, client_capabilities); status = GetWvPLClientCapabilities(*client_id_, client_capabilities);
return status; return status;
} }
@@ -691,7 +700,7 @@ WvPLStatus WvPLSDKSession::GetPsshData(
return WvPLStatus(error_space, error::INVALID_ARGUMENT, return WvPLStatus(error_space, error::INVALID_ARGUMENT,
"sdk_license_request_ is null"); "sdk_license_request_ is null");
} }
if (request_type() == LicenseRequest::NEW) { if (request_type() == LicenseRequestType::NEW) {
ContentInfo content_info; ContentInfo content_info;
WvPLStatus status = widevine::ParseContentId( WvPLStatus status = widevine::ParseContentId(
sdk_license_request_->content_id(), &content_info); sdk_license_request_->content_id(), &content_info);

51
sdk/external/common/wvpl/wvpl_sdk_session.h vendored
View File

@@ -11,15 +11,18 @@
#include <memory> #include <memory>
#include "sdk/external/common/wvpl/wvpl_types.h" #include "sdk/external/common/wvpl/wvpl_types.h"
#include "protos/public/client_identification.pb.h"
#include "protos/public/device_certificate_status.pb.h"
#include "protos/public/license_protocol.pb.h"
#include "protos/public/license_server_sdk.pb.h"
#include "protos/public/provisioned_device_info.pb.h"
namespace widevine { namespace widevine {
class ClientIdentification;
class DrmRootCertificate; class DrmRootCertificate;
class LicenseRequest;
class License_KeyContainer_OutputProtection;
class License_KeyContainer;
class License_Policy;
class ProvisionedDeviceInfo;
class SessionInit; class SessionInit;
class SessionState;
class SignedMessage;
} // namespace widevine } // namespace widevine
namespace widevine_server { namespace widevine_server {
namespace wv_pl_sdk { namespace wv_pl_sdk {
@@ -28,7 +31,7 @@ class WvPLSDKSession {
public: public:
explicit WvPLSDKSession( explicit WvPLSDKSession(
const widevine::DrmRootCertificate* drm_root_certificate); const widevine::DrmRootCertificate* drm_root_certificate);
virtual ~WvPLSDKSession() = 0; virtual ~WvPLSDKSession();
public: public:
// Add WvPLKey. // Add WvPLKey.
@@ -101,9 +104,7 @@ class WvPLSDKSession {
virtual PlatformVerificationStatus VerifyPlatform() = 0; virtual PlatformVerificationStatus VerifyPlatform() = 0;
virtual widevine::LicenseRequest::RequestType request_type() const { virtual LicenseRequestType request_type() const { return request_type_; }
return request_type_;
}
/** /**
* Returns true if the license type is offline, otherwise return false. * Returns true if the license type is offline, otherwise return false.
@@ -119,7 +120,7 @@ class WvPLSDKSession {
WvPLPlaybackPolicy policy_; WvPLPlaybackPolicy policy_;
WvPLSessionInit session_init_; WvPLSessionInit session_init_;
WvPLWidevinePsshData pssh_data_; WvPLWidevinePsshData pssh_data_;
widevine::ClientIdentification client_id_; std::unique_ptr<widevine::ClientIdentification> client_id_;
bool has_pssh_data_ = false; bool has_pssh_data_ = false;
bool has_client_id_ = false; bool has_client_id_ = false;
MessageType message_type_ = UNKNOWN; MessageType message_type_ = UNKNOWN;
@@ -130,7 +131,7 @@ class WvPLSDKSession {
std::string license_request_from_cdm_; std::string license_request_from_cdm_;
std::string remote_attestation_cert_serial_number_; std::string remote_attestation_cert_serial_number_;
std::unique_ptr<widevine::LicenseRequest> sdk_license_request_; std::unique_ptr<widevine::LicenseRequest> sdk_license_request_;
widevine::LicenseRequest::RequestType request_type_; LicenseRequestType request_type_;
virtual WvPLStatus VerifyRemoteAttestation(); virtual WvPLStatus VerifyRemoteAttestation();
// Returns the WvPL Client Capabilities information for the license request // Returns the WvPL Client Capabilities information for the license request
@@ -146,35 +147,23 @@ class WvPLSDKSession {
widevine::License_KeyContainer* sdk_key_container); widevine::License_KeyContainer* sdk_key_container);
virtual void CopySecurityLevel( virtual void CopySecurityLevel(
const WvPLOutputProtection& output_protection, TrackType track_type, const WvPLOutputProtection& output_protection, TrackType track_type,
widevine::License::KeyContainer* key_container); widevine::License_KeyContainer* key_container);
// Copies/translates the policy from a WvPL policy into an SDK policy. A // Copies/translates the policy from a WvPL policy into an SDK policy. A
// helper function for GenerateLicenseRequestAsJSON. // helper function for GenerateLicenseRequestAsJSON.
virtual void CopyPlaybackPolicy(const WvPLPlaybackPolicy& wvpl_policy, virtual void CopyPlaybackPolicy(const WvPLPlaybackPolicy& wvpl_policy,
widevine::License::Policy* sdk_policy); widevine::License_Policy* sdk_policy);
// Copy the |cgms_value| into the key container. A helper function for // Copy the |cgms_value| into the key container. A helper function for
// GenerateLicenseRequestAsJSON. // GenerateLicenseRequestAsJSON.
virtual void CopyCGMS(CGMS cgms_value, virtual void CopyCGMS(
widevine::License::KeyContainer::OutputProtection* CGMS cgms_value,
output_protection); widevine::License_KeyContainer_OutputProtection* output_protection);
// Copy the |hdcp_value| into the key container. // Copy the |hdcp_value| into the key container.
virtual void CopyHDCP(HDCP hdcp_value, virtual void CopyHDCP(
widevine::License::KeyContainer::OutputProtection* HDCP hdcp_value,
output_protection); widevine::License_KeyContainer_OutputProtection* output_protection);
// Copy the |hdcp_value| into the client_capabilities.
virtual void CopyHDCPToClientCapabilities(
widevine::ClientIdentification::ClientCapabilities::HdcpVersion
hdcp_value,
WvPLClientCapabilities* client_capabilities) const;
// Copy the |analog_output_capabilities| into the client_capabilities.
virtual void CopyAnalogOutputCapabilities(
widevine::ClientIdentification::ClientCapabilities::
AnalogOutputCapabilities analog_output_capabilities,
WvPLClientCapabilities* client_capabilities) const;
// Copy the WvPLSession Init into Session Init. // Copy the WvPLSession Init into Session Init.
virtual void CopySessionInit(const WvPLSessionInit& wvpl_session_init, virtual void CopySessionInit(const WvPLSessionInit& wvpl_session_init,

7
sdk/external/common/wvpl/wvpl_types.h vendored
View File

@@ -59,6 +59,13 @@ enum CertificateKeyType {
RSA_3072 = 1, RSA_3072 = 1,
}; };
enum LicenseRequestType {
REQUEST_TYPE_UNSPECIFIED = 0,
NEW = 1,
RENEWAL = 2,
RELEASE = 3,
};
enum PlatformVerificationStatus { enum PlatformVerificationStatus {
PLATFORM_UNVERIFIED = 0, PLATFORM_UNVERIFIED = 0,
PLATFORM_TAMPERED = 1, PLATFORM_TAMPERED = 1,