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

Source release v2.1.3-2-789 + third_party libs

Browse Source 
Change-Id: I8648756dab3fe1f53d6da18b83cd1294581d1abe
This commit is contained in:
Joey Parrish
2014-06-19 17:13:42 -07:00
parent 73445a920c
commit 84acd5a15e
32 changed files with 1340 additions and 1335 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
cdm/cdm.gyp
View File

@@ -91,12 +91,14 @@
'../core/src/privacy_crypto_dummy.cpp',
],
}],
],
'direct_dependencies': [
'device_files',
'license_protocol',
],
'conditions': [
['oemcrypto_v8=="true"', {
'sources!': [ # exclude
'../core/src/oemcrypto_adapter_static.cpp',
],
'sources': [ # include
'../core/src/oemcrypto_adapter_static_v8.cpp',
],
}],
['use_system_protobuf=="true"', {
'direct_dependent_settings': {
'libraries': [

1
cdm/include/cdm_host_clock.h
View File

@@ -21,6 +21,7 @@ class HostClock {
private:
static IClock* impl_;
};
} // namspace wvcdm
#endif // WVCDM_CDM_CDM_HOST_CLOCK_H_

22
cdm/include/cdm_host_file.h
View File

@@ -13,31 +13,37 @@ class IFileFactory;
class File::Impl {
public:
explicit Impl(cdm::Host* const host) : host_(host) {}
FILE* file_;
static void RegisterFileFactory(IFileFactory* factory) {
factory_ = factory;
}
static IFileFactory* factory_;
virtual bool Exists(const std::string& name);
virtual bool Open(const std::string& name);
virtual bool Close();
virtual bool Remove(const std::string& name);
virtual size_t Read(char* buffer, size_t bytes);
virtual size_t Write(const char* buffer, size_t bytes);
virtual size_t FileSize(const std::string& name);
virtual ssize_t Read(char* buffer, size_t bytes);
virtual ssize_t Write(const char* buffer, size_t bytes);
virtual ssize_t FileSize(const std::string& name);
private:
static IFileFactory* factory_;
friend class File;
cdm::Host* const host_;
std::string fname_;
};
class IFileFactory {
protected:
IFileFactory(){File::Impl::RegisterFileFactory(this);}
virtual ~IFileFactory(){}
IFileFactory() {
File::Impl::RegisterFileFactory(this);
}
virtual ~IFileFactory() {}
public:
virtual File::Impl* NewFileImpl () = 0;
virtual File::Impl* NewFileImpl() = 0;
};
} // namespace wvcdm

107
cdm/include/content_decryption_module.h
View File

@@ -269,6 +269,9 @@ class ContentDecryptionModule_1 {
const uint8_t* key, int key_size,
const uint8_t* key_id, int key_id_size) = 0;
// Tests whether |key_id| is known to any current session.
virtual bool IsKeyValid(const uint8_t* key_id, int key_id_size) = 0;
// Cancels any pending key request made to the CDM for |session_id|.
//
// Returns kSuccess if all pending key requests for |session_id| were
@@ -293,80 +296,6 @@ class ContentDecryptionModule_1 {
virtual Status Decrypt(const InputBuffer& encrypted_buffer,
DecryptedBlock* decrypted_buffer) = 0;
// Initializes the CDM audio decoder with |audio_decoder_config|.
// This function is only needed if DecryptAndDecodeSamples() or
// DecryptDecodeAndRenderSamples() is used. It must be called before either
// of these routines is called.
//
// Returns kSuccess if the |audio_decoder_config| is supported and the CDM
// audio decoder is successfully initialized.
// Returns kSessionError if |audio_decoder_config| is not supported. The CDM
// may still be able to do Decrypt().
//
virtual Status InitializeAudioDecoder(
const AudioDecoderConfig& audio_decoder_config) = 0;
// Initializes the CDM video decoder with |video_decoder_config|.
// This function is only needed if DecryptAndDecodeFrame() or
// DecryptDecodeAndRenderFrame() is used. It must be called before either
// of these routines is called.
//
// Returns kSuccess if the |video_decoder_config| is supported and the CDM
// video decoder is successfully initialized.
// Returns kSessionError if |video_decoder_config| is not supported. The CDM
// may still be able to do Decrypt().
//
virtual Status InitializeVideoDecoder(
const VideoDecoderConfig& video_decoder_config) = 0;
// De-initializes the CDM decoder and sets it to an uninitialized state. The
// caller can initialize the decoder again after this call to re-initialize
// it. This can be used to reconfigure the decoder if the configuration
// changes.
virtual void DeinitializeDecoder(StreamType decoder_type) = 0;
// Resets the CDM decoder to an initialized clean state. All internal buffers
// MUST be flushed.
virtual void ResetDecoder(StreamType decoder_type) = 0;
// Decrypts the |encrypted_buffer| and decodes the decrypted buffer into a
// |video_frame|. Upon end-of-stream, the caller should call this function
// repeatedly with empty |encrypted_buffer| (|data| == NULL) until only empty
// |video_frame| (|format| == kEmptyVideoFrame) is produced.
//
// Returns kSuccess if decryption and decoding both succeeded, in which case
// the callee will have filled the |video_frame| and passed the ownership of
// |frame_buffer| in |video_frame| to the caller.
// Returns kNoKey if the CDM did not have the necessary decryption key
// to decrypt.
// Returns kNeedMoreData if more data was needed by the decoder to generate
// a decoded frame (e.g. during initialization and end-of-stream).
// Returns kDecryptError if any decryption error happened.
// Returns kDecodeError if any decoding error happened.
// If the return value is not kSuccess, |video_frame| should be ignored by
// the caller.
virtual Status DecryptAndDecodeFrame(const InputBuffer& encrypted_buffer,
VideoFrame* video_frame) = 0;
// Decrypts the |encrypted_buffer| and decodes the decrypted buffer into
// |audio_frames|. Upon end-of-stream, the caller should call this function
// repeatedly with empty |encrypted_buffer| (|data| == NULL) until only empty
// |audio_frames| is produced.
//
// Returns kSuccess if decryption and decoding both succeeded, in which case
// the callee will have filled |audio_frames| and passed the ownership of
// |data| in |audio_frames| to the caller.
// Returns kNoKey if the CDM did not have the necessary decryption key
// to decrypt.
// Returns kNeedMoreData if more data was needed by the decoder to generate
// audio samples (e.g. during initialization and end-of-stream).
// Returns kDecryptError if any decryption error happened.
// Returns kDecodeError if any decoding error happened.
// If the return value is not kSuccess, |audio_frames| should be ignored by
// the caller.
virtual Status DecryptAndDecodeSamples(const InputBuffer& encrypted_buffer,
AudioFrames* audio_frames) = 0;
// Decrypts the |encrypted_buffer|, decodes the decrypted buffer into a
// video frame, and passes the frame to the rendering FW/HW. No data
// is returned.
@@ -471,28 +400,18 @@ class Host_1 {
MediaKeyError error_code,
uint32_t system_code) = 0;
// Get private data from the host. This function is limited to internal use.
typedef const void* (*GetPrivateInterface)(const char* interface_name);
virtual void GetPrivateData(int32_t* instance,
GetPrivateInterface* get_interface) = 0;
// Version 1.3:
// These virtual member functions extend the cdm::Host interface to allow
// the CDM to query the host for various information.
//Version 1.3
// These Virtual member functions extend the cdm::Host interface to allow
// the sharing for platform specific information, between the cdm::Host and
// the CDM.
// Asks the host to persist a name-value pair.
virtual void SetPlatformString(const std::string& name,
const std::string& value) = 0;
virtual int GetPlatformString(const std::string& name,
std::string* value) = 0;
virtual int SetPlatformString(const std::string& name,
const std::string& value) = 0;
virtual int PersistPlatformString(const std::string& name,
const std::string& value) = 0;
virtual int GetPlatformByteArray(const std::string& name,
std::vector<uint8_t>* value) = 0;
virtual int SetPlatformByteArray(const std::string& name,
const std::vector<uint8_t>& value) = 0;
virtual int PersistPlatformByteArray(const std::string& name,
const std::vector<uint8_t>& value) = 0;
// Retrieves a value by name. If there is no such value, the Host should
// set value to an empty string.
virtual void GetPlatformString(const std::string& name,
std::string* value) = 0;
protected:
Host_1() {}

2
cdm/include/wv_cdm_version.h
View File

@@ -1,3 +1,3 @@
// Widevine CDM Kit Version
#define WV_CDM_VERSION "v2.1.2-0-773"
#define WV_CDM_VERSION "v2.1.3-2-789"

58
cdm/include/wv_content_decryption_module.h
View File

@@ -28,7 +28,7 @@ class WVClientPropertySet : public wvcdm::CdmClientPropertySet {
security_level_ = securityLevel;
}
virtual std::string security_level() const {
virtual const std::string& security_level() const {
return security_level_;
}
@@ -40,11 +40,11 @@ class WVClientPropertySet : public wvcdm::CdmClientPropertySet {
return use_privacy_mode_;
}
void set_service_certificate(const std::vector<uint8_t>& serviceCertificate) {
void set_service_certificate(const std::string& serviceCertificate) {
service_certificate_ = serviceCertificate;
}
virtual std::vector<uint8_t> service_certificate() const {
virtual const std::string& service_certificate() const {
return service_certificate_;
}
@@ -67,24 +67,23 @@ class WVClientPropertySet : public wvcdm::CdmClientPropertySet {
return; // This is unused by common cdm but we need a
// definition for the pure virtual methods.
}
private:
CORE_DISALLOW_COPY_AND_ASSIGN(WVClientPropertySet);
std::string security_level_;
bool use_privacy_mode_;
std::vector<uint8_t> service_certificate_;
std::string service_certificate_;
};
class WvContentDecryptionModule : public cdm::ContentDecryptionModule,
public IFileFactory,
public IClock {
File::Impl* NewFileImpl() { return new File::Impl(host_); }
public:
explicit WvContentDecryptionModule(cdm::Host* host)
: host_(host), host_event_listener_(host, &cdm_engine_) {
HostClock::SetClockInterface(this);
}
explicit WvContentDecryptionModule(cdm::Host* host);
virtual ~WvContentDecryptionModule();
// cdm::ContentDecryptionModule implementation.
virtual cdm::Status GenerateKeyRequest(const char* type, int type_size,
const uint8_t* init_data,
@@ -94,6 +93,8 @@ class WvContentDecryptionModule : public cdm::ContentDecryptionModule,
const uint8_t* key, int key_size,
const uint8_t* key_id, int key_id_size) OVERRIDE;
virtual bool IsKeyValid(const uint8_t* key_id, int key_id_size) OVERRIDE;
virtual cdm::Status CancelKeyRequest(const char* session_id,
int session_id_size) OVERRIDE;
@@ -102,24 +103,6 @@ class WvContentDecryptionModule : public cdm::ContentDecryptionModule,
virtual cdm::Status Decrypt(const cdm::InputBuffer& encrypted_buffer,
cdm::DecryptedBlock* decrypted_buffer) OVERRIDE;
virtual cdm::Status InitializeAudioDecoder(
const cdm::AudioDecoderConfig& audio_decoder_config) OVERRIDE;
virtual cdm::Status InitializeVideoDecoder(
const cdm::VideoDecoderConfig& video_decoder_config) OVERRIDE;
virtual void DeinitializeDecoder(cdm::StreamType decoder_type) OVERRIDE;
virtual void ResetDecoder(cdm::StreamType decoder_type) OVERRIDE;
virtual cdm::Status DecryptAndDecodeFrame(
const cdm::InputBuffer& encrypted_buffer,
cdm::VideoFrame* video_frame) OVERRIDE;
virtual cdm::Status DecryptAndDecodeSamples(
const cdm::InputBuffer& encrypted_buffer,
cdm::AudioFrames* audio_frames) OVERRIDE;
virtual cdm::Status DecryptDecodeAndRenderFrame(
const cdm::InputBuffer& encrypted_buffer) OVERRIDE;
@@ -128,29 +111,30 @@ class WvContentDecryptionModule : public cdm::ContentDecryptionModule,
virtual void Destroy() OVERRIDE;
// Provisioning related methods
virtual cdm::Status GetProvisioningRequest(
std::string* request, std::string* default_url);
std::string* request, std::string* default_url) OVERRIDE;
virtual cdm::Status HandleProvisioningResponse(
std::string& response);
void EnablePolicyTimer();
void DisablePolicyTimer();
void OnTimerEvent();
std::string& response) OVERRIDE;
private:
virtual int64_t GetCurrentTimeInSeconds() {
return host_->GetCurrentWallTimeInSeconds();
}
void EnablePolicyTimer();
void DisablePolicyTimer();
virtual File::Impl* NewFileImpl() OVERRIDE;
virtual int64_t GetCurrentTimeInSeconds() OVERRIDE;
cdm::Status DoSubsampleDecrypt(CdmDecryptionParameters& parameters,
std::vector<uint8_t>& iv,
const cdm::InputBuffer& encrypted_buffer,
cdm::DecryptedBlock* decrypted_block);
CdmEngine cdm_engine_;
cdm::Host* const host_;
HostEventListener host_event_listener_;
WVClientPropertySet property_set_;
bool timer_enabled_;
CORE_DISALLOW_COPY_AND_ASSIGN(WvContentDecryptionModule);
};

75
cdm/src/file_store.cpp
View File

@@ -6,7 +6,7 @@
namespace wvcdm {
IFileFactory* File::Impl::factory_ = NULL;
IFileFactory* File::Impl::factory_ = NULL;
// File::Impl() Section
// The file handler for cert.bin, aka DeviceCertificate is all we're
@@ -14,68 +14,60 @@ IFileFactory* File::Impl::factory_ = NULL;
bool File::Impl::Exists(const std::string& name) {
if (name == "cert.bin") {
std::vector<uint8_t> value;
if (host_->GetPlatformByteArray("DeviceCertificate", &value)) {
return true;
}
std::string value;
host_->GetPlatformString("DeviceCertificate", &value);
return !value.empty();
}
return false;
}
bool File::Impl::Open(const std::string& name) {
if (name == "cert.bin") {
fname_= name;
fname_ = name;
return true;
}
return false;
}
bool File::Impl::Close() {
fname_ = "";
fname_.clear();
return true;
}
bool File::Impl::Remove(const std::string& name) {
if (Exists(name)) {
std::vector<uint8_t> value(0);
if (host_->SetPlatformByteArray("DeviceCertificate", value)) {
return true;
}
if (name == "cert.bin") {
host_->SetPlatformString("DeviceCertificate", "");
return true;
}
return false;
}
size_t File::Impl::Read(char* buffer, size_t bytes) {
if (fname_ == "cert.bin") {
std::vector<uint8_t> value;
if (host_->GetPlatformByteArray("DeviceCertificate", &value)) {
memcpy(buffer, &value[0], bytes);
return bytes;
}
}
return 0;
}
size_t File::Impl::Write(const char* buffer, size_t bytes) {
ssize_t File::Impl::Read(char* buffer, size_t bytes) {
if (fname_ == "cert.bin") {
std::vector<uint8_t> value;
value.resize(bytes);
memcpy(&value[0], buffer, bytes);
if (host_->PersistPlatformByteArray("DeviceCertificate", value)) {
return bytes;
}
std::string value;
host_->GetPlatformString("DeviceCertificate", &value);
memcpy(buffer, value.data(), std::min(bytes, value.size()));
return value.size() ? value.size() : -1;
}
return 0;
return -1;
}
size_t File::Impl::FileSize(const std::string& name) {
if (name == "cert.bin") {
std::vector<uint8_t> value;
if (host_->GetPlatformByteArray("DeviceCertificate", &value)) {
return value.size();
}
ssize_t File::Impl::Write(const char* buffer, size_t bytes) {
if (fname_ == "cert.bin") {
std::string value(buffer, bytes);
host_->SetPlatformString("DeviceCertificate", value);
return bytes;
}
return 0;
return -1;
}
ssize_t File::Impl::FileSize(const std::string& name) {
if (name == "cert.bin") {
std::string value;
host_->GetPlatformString("DeviceCertificate", &value);
return value.size() ? value.size() : -1;
}
return -1;
}
File::File() : impl_(File::Impl::factory_->NewFileImpl()) {}
@@ -91,7 +83,6 @@ bool File::Open(const std::string& name, int flags) {
void File::Close() {
impl_->Close();
return;
}
ssize_t File::Read(char* buffer, size_t bytes) {
@@ -136,11 +127,7 @@ bool File::IsRegularFile(const std::string& path) {
}
ssize_t File::FileSize(const std::string& path) {
size_t size = impl_->FileSize(path);
if (size > 0) {
return size;
}
return -1;
return impl_->FileSize(path);
}
} // namespace wvcdm

1
cdm/src/properties_common.cpp
View File

@@ -3,7 +3,6 @@
#include "properties.h"
#include <string>
#include <sys/utsname.h>
#include "log.h"

76
cdm/src/timer.cpp
View File

@@ -1,76 +0,0 @@
// Copyright 2013 Google Inc. All Rights Reserved.
//
// Timer class - provides a simple timer implementation
//
#include "cdm_host_timer.h"
#include "scoped_ptr.h"
#include "timer.h"
#include <errno.h>
#include <pthread.h>
#include <stdio.h>
#include <time.h>
#include <unistd.h>
namespace wvcdm {
ITimerFactory* Timer::Impl::factory_ = NULL;
Timer::Impl::Impl(cdm::Host* const host)
: host_(host), handler_(NULL), delay_ms_(0),
state_(kIdle) {
}
void Timer::Impl::RegisterTimerFactory(ITimerFactory* factory) {
factory_ = factory;
}
void Timer::Impl::Start(TimerHandler* handler, uint32_t time_in_secs) {
handler_ = handler;
delay_ms_ = time_in_secs * 1000;
state_ = kRunning;
host_->SetTimer(delay_ms_, this);
}
void Timer::Impl::OnTimerEvent() {
if (kRunning == state_) {
handler_->OnTimerEvent();
host_->SetTimer(delay_ms_, this);
}
}
void Timer::Impl::Stop() {
state_ = kIdle;
}
Timer::Timer() : impl_(NULL) {}
Timer::~Timer() {
if (impl_)
delete impl_;
}
bool Timer::Start(TimerHandler* handler, uint32_t time_in_secs) {
if (!handler || 0 == time_in_secs)
return false;
if (!impl_ && Impl::factory_)
impl_ = Impl::factory_->NewTimerImpl();
if(!impl_)
return false;
impl_->Start(handler, time_in_secs);
return IsRunning();
}
void Timer::Stop() {
if (impl_)
impl_->Stop();
}
bool Timer::IsRunning() {
if (!impl_)
return false;
return impl_->IsRunning();
}
} // namespace wvcdm

114
cdm/src/wv_content_decryption_module.cpp
View File

@@ -2,17 +2,14 @@
#include "wv_content_decryption_module.h"
#include <iostream>
#include <string.h>
#include "cdm_client_property_set.h"
#include "content_decryption_module.h"
#include "initialization_data.h"
#include <iostream>
#include "initialization_data.h"
#include "log.h"
#include "OEMCryptoCENC.h"
#include "properties.h"
#include "wv_cdm_constants.h"
#include "wv_cdm_types.h"
#include "wv_cdm_version.h"
@@ -38,10 +35,10 @@ void* CreateCdmInstance(int cdm_interface_version, const char* key_system,
int GetCdmVersion() { return cdm::kCdmInterfaceVersion; }
namespace {
static const std::string kWvCdmVersionString(WV_CDM_VERSION);
const int kCdmPolicyTimerDurationSeconds = 1;
const int kCdmPolicyTimerCancel = 0;
const int kCdmPolicyTimerDurationSeconds = 5;
// The iso spec only uses the lower 8 bytes of the iv as
// the counter.
@@ -69,6 +66,7 @@ bool Ctr128Add(size_t block_count, uint8_t* counter) {
}
return true;
}
} // namespace
namespace wvcdm {
@@ -80,6 +78,13 @@ bool IsBufferEncrypted(const cdm::InputBuffer& input_buffer) {
// cdm::ContentDecryptionModule implementation.
WvContentDecryptionModule::WvContentDecryptionModule(cdm::Host* host)
: host_(host),
host_event_listener_(host, &cdm_engine_),
timer_enabled_(false) {
HostClock::SetClockInterface(this);
}
WvContentDecryptionModule::~WvContentDecryptionModule() {
DisablePolicyTimer();
}
@@ -87,7 +92,7 @@ WvContentDecryptionModule::~WvContentDecryptionModule() {
cdm::Status WvContentDecryptionModule::GenerateKeyRequest(
const char* type, int type_size, const uint8_t* init_data,
int init_data_size) {
LOGI("Enter WvContentDecryptionModule::GenerateKeyRequest()");
LOGI("WvContentDecryptionModule::GenerateKeyRequest()");
CdmInitData init_data_internal(reinterpret_cast<const char*>(init_data),
init_data_size);
InitializationData initialization_data(ISO_BMFF_VIDEO_MIME_TYPE,
@@ -97,14 +102,14 @@ cdm::Status WvContentDecryptionModule::GenerateKeyRequest(
std::string security_level;
std::string privacy_mode;
VectorBytes service_certificate;
std::string service_certificate;
host_->GetPlatformString("SecurityLevel", &security_level);
host_->GetPlatformString("PrivacyOn", &privacy_mode);
host_->GetPlatformByteArray("ServiceCertificate", &service_certificate);
host_->GetPlatformString("ServiceCertificate", &service_certificate);
property_set_.set_security_level(security_level);
property_set_.set_use_privacy_mode(privacy_mode == "True" ? 1 : 0 );
property_set_.set_use_privacy_mode(privacy_mode == "True" ? 1 : 0);
property_set_.set_service_certificate(service_certificate);
CdmResponseType result =
@@ -146,7 +151,7 @@ cdm::Status WvContentDecryptionModule::AddKey(const char* session_id,
const uint8_t* key, int key_size,
const uint8_t* key_id,
int key_id_size) {
LOGI("Enter WvContentDecryptionModule::AddKey()\n");
LOGI("WvContentDecryptionModule::AddKey()");
CdmSessionId session_id_internal(session_id, session_id_size);
CdmKeyResponse key_data((const char*)key, key_size);
CdmKeySetId key_set_id;
@@ -160,12 +165,17 @@ cdm::Status WvContentDecryptionModule::AddKey(const char* session_id,
} else {
return cdm::kSessionError;
}
}
bool WvContentDecryptionModule::IsKeyValid(const uint8_t* key_id,
int key_id_size) {
KeyId key(reinterpret_cast<const char*>(key_id), key_id_size);
return cdm_engine_.IsKeyLoaded(key);
}
cdm::Status WvContentDecryptionModule::CancelKeyRequest(const char* session_id,
int session_id_size) {
LOGI("Enter WvContentDecryptionModule::CancelKeyRequest()\n");
LOGI("WvContentDecryptionModule::CancelKeyRequest()");
CdmSessionId session_id_internal(session_id, session_id_size);
return cdm_engine_.CancelKeyRequest(session_id_internal) == NO_ERROR
? cdm::kSuccess
@@ -173,18 +183,17 @@ cdm::Status WvContentDecryptionModule::CancelKeyRequest(const char* session_id,
}
void WvContentDecryptionModule::TimerExpired(void* context) {
LOGI("Timer expired, send cdm_engine OnTimerEvent");
if (this != context) {
LOGD("Context should have been set, Timer Expired Error\n");
return;
LOGI("WvContentDecryptionModule::TimerExpired()");
if (timer_enabled_) {
cdm_engine_.OnTimerEvent();
host_->SetTimer(kCdmPolicyTimerDurationSeconds * 1000, NULL);
}
OnTimerEvent();
}
cdm::Status WvContentDecryptionModule::Decrypt(
const cdm::InputBuffer& encrypted_buffer,
cdm::DecryptedBlock* decrypted_block) {
LOGI("=>Enter WvContentDecryptionModule::Decrypt()\n");
LOGI("WvContentDecryptionModule::Decrypt()");
if (static_cast<size_t>(encrypted_buffer.iv_size) != KEY_IV_SIZE)
return cdm::kDecryptError;
std::vector < uint8_t > iv(KEY_IV_SIZE);
@@ -210,47 +219,13 @@ cdm::Status WvContentDecryptionModule::Decrypt(
decrypted_block);
}
cdm::Status WvContentDecryptionModule::InitializeAudioDecoder(
const cdm::AudioDecoderConfig& audio_decoder_config) {
LOGI("WvContentDecryptionModule::InitializeAudioDecoder() Not implemented\n");
return cdm::kDecodeError;
}
cdm::Status WvContentDecryptionModule::InitializeVideoDecoder(
const cdm::VideoDecoderConfig& video_decoder_config) {
LOGI("WvContentDecryptionModule::InitializeVideoDecoder() Not implemented\n");
return cdm::kDecodeError;
}
void WvContentDecryptionModule::DeinitializeDecoder(
cdm::StreamType decoder_type) {
LOGI("WvContentDecryptionModule::DeInitializeDecoder() Not implemented\n");
}
void WvContentDecryptionModule::ResetDecoder(cdm::StreamType decoder_type) {
LOGI("WvContentDecryptionModule::ResetDecoder() Not implemented\n");
}
cdm::Status WvContentDecryptionModule::DecryptAndDecodeFrame(
const cdm::InputBuffer& encrypted_buffer, cdm::VideoFrame* video_frame) {
LOGI("WvContentDecryptionModule::DecryptAndDecodeFrame() Not implemented\n");
return cdm::kDecodeError;
}
cdm::Status WvContentDecryptionModule::DecryptAndDecodeSamples(
const cdm::InputBuffer& encrypted_buffer, cdm::AudioFrames* audio_frames) {
LOGI(
"WvContentDecryptionModule::DecryptAndDecodeSamples() Not implemented\n");
return cdm::kDecodeError;
}
// This is the Level 1 API. When the host application calls the CDM's
// DecryptDecodeAndRenderFrame(), rather than the CDM's Decrypt(),
// OEMCrypto_DecryptCTR() will be told to use direct rendering with no
// cleartext in the return.
cdm::Status WvContentDecryptionModule::DecryptDecodeAndRenderFrame(
const cdm::InputBuffer& encrypted_buffer) {
LOGI("WvContentDecryptionModule::DecryptDecodeAndRenderFrame()\n");
LOGI("WvContentDecryptionModule::DecryptDecodeAndRenderFrame()");
if (static_cast<size_t>(encrypted_buffer.iv_size) != KEY_IV_SIZE)
return cdm::kDecryptError;
@@ -276,7 +251,7 @@ cdm::Status WvContentDecryptionModule::DecryptDecodeAndRenderFrame(
// in the return.
cdm::Status WvContentDecryptionModule::DecryptDecodeAndRenderSamples(
const cdm::InputBuffer& encrypted_buffer) {
LOGI("WvContentDecryptionModule::DecryptDecodeAndRenderSamples()\n");
LOGI("WvContentDecryptionModule::DecryptDecodeAndRenderSamples()");
if (static_cast<size_t>(encrypted_buffer.iv_size) != KEY_IV_SIZE)
return cdm::kDecryptError;
@@ -324,19 +299,16 @@ cdm::Status WvContentDecryptionModule::HandleProvisioningResponse(
}
void WvContentDecryptionModule::EnablePolicyTimer() {
LOGI("WvContentDecryptionModule::EnablePolicyTimer()\n");
host_->SetTimer(kCdmPolicyTimerDurationSeconds * 1000, this);
LOGI("WvContentDecryptionModule::EnablePolicyTimer()");
if (!timer_enabled_) {
timer_enabled_ = true;
host_->SetTimer(kCdmPolicyTimerDurationSeconds * 1000, NULL);
}
}
void WvContentDecryptionModule::DisablePolicyTimer() {
LOGI("WvContentDecryptionModule::DisablePolicyTimer()\n");
host_->SetTimer(kCdmPolicyTimerCancel, NULL);
}
void WvContentDecryptionModule::OnTimerEvent() {
LOGI("WvContentDecryptionModule::OnTimerEvent()\n");
cdm_engine_.OnTimerEvent();
LOGI("WvContentDecryptionModule::DisablePolicyTimer()");
timer_enabled_ = false;
}
cdm::Status WvContentDecryptionModule::DoSubsampleDecrypt(
@@ -385,7 +357,7 @@ cdm::Status WvContentDecryptionModule::DoSubsampleDecrypt(
continue;
if (is_encrypted) {
uint32_t counter = encrypted_offset / kIvSize;
::Ctr128Add(counter - block_ctr, &iv[0]);
Ctr128Add(counter - block_ctr, &iv[0]);
block_ctr = counter;
}
@@ -413,16 +385,22 @@ cdm::Status WvContentDecryptionModule::DoSubsampleDecrypt(
switch (status) {
case wvcdm::NEED_KEY:
return cdm::kNoKey;
break;
case wvcdm::NO_ERROR:
break;
default:
return cdm::kDecryptError;
break;
}
}
}
return cdm::kSuccess;
}
int64_t WvContentDecryptionModule::GetCurrentTimeInSeconds() {
return host_->GetCurrentWallTimeInSeconds();
}
File::Impl* WvContentDecryptionModule::NewFileImpl() {
return new File::Impl(host_);
}
} // namespace wvcdm

607
cdm/test/cdm_api_test.cpp
View File

@@ -7,49 +7,37 @@
// Review the TestHost class below to observe how the CDM interfaces with
// the host application.
//
#include <set>
#include <queue>
#include <errno.h>
#include <getopt.h>
#include <pthread.h>
#include <unistd.h>
#include <gtest/gtest.h>
#include "clock.h"
#include "config_test_env.h"
#include "content_decryption_module.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include "license_request.h"
#include "log.h"
#include "scoped_ptr.h"
#include "string_conversions.h"
#include "url_request.h"
#include "wv_cdm_types.h"
#include "wv_cdm_common.h"
using ::testing::_;
using ::testing::AtLeast;
using ::testing::Invoke;
using ::testing::Return;
using wvcdm::scoped_ptr;
static const int kTestPolicyRenewalDelaySeconds = 60;
static const int kDelayWaitToForRenewalMessageSeconds = 2;
// Linux based get time for host.
// This can be tailored if required.
double GetCurrentTestTime() {
static double GetCurrentTime() {
struct timeval tv;
tv.tv_sec = tv.tv_usec = 0;
gettimeofday(&tv, NULL);
return tv.tv_sec;
}
using wvcdm::StringPairs;
using wvcdm::VectorPairs;
// These classes below are naive implementation of the abstract classes defined
// in the CDM interface (content_decryptiom_module.h), which are used for tests
// only.
@@ -77,192 +65,11 @@ class TestBuffer : public cdm::Buffer {
CORE_DISALLOW_COPY_AND_ASSIGN(TestBuffer);
};
class TestHostFile {
public:
TestHostFile() : fname_(""), file_(NULL) {}
virtual ~TestHostFile() { if (file_) fclose(file_); }
virtual bool Init(const std::string& name);
virtual bool Exists();
virtual bool Remove();
virtual size_t Size();
virtual size_t Read(char* buffer, size_t bytes);
virtual size_t Write(const char* buffer, size_t bytes);
virtual std::string GetFileName() { return fname_;}
private:
std::string fname_;
FILE* file_;
CORE_DISALLOW_COPY_AND_ASSIGN(TestHostFile);
};
bool TestHostFile::Init(const std::string& name) {
fname_ = name;
return true;
}
bool TestHostFile::Exists() {
file_ = fopen(fname_.c_str(), "rb");
bool exists = file_;
if (file_) {
fclose(file_);
file_ = NULL;
}
return (exists);
}
bool TestHostFile::Remove() {
if (Exists()) {
if (remove(fname_.c_str())) {
return true;
}
}
return false;
}
size_t TestHostFile::Size() {
file_ = fopen(fname_.c_str(), "rb");
if (file_) {
fseek (file_, 0, SEEK_END);
size_t size = ftell (file_);
rewind (file_);
if (file_) {
fclose(file_);
file_ = NULL;
}
return size;
}
return 0;
}
size_t TestHostFile::Read(char* buffer, size_t bytes) {
file_ = fopen(fname_.c_str(), "rb");
if (file_) {
fseek (file_, 0, SEEK_END);
size_t size = ftell (file_);
rewind (file_);
size_t check = fread (buffer,1,size,file_);
if (file_) {
fclose(file_);
file_ = NULL;
}
return check;
}
return 0;
}
size_t TestHostFile::Write(const char* buffer, size_t bytes) {
FILE* file_ = fopen(fname_.c_str(), "w+");
if (file_) {
size_t check = fwrite (buffer,1,bytes,file_);
if (file_) {
fclose(file_);
file_ = NULL;
}
return check;
}
return 0;
}
class IHostTime {
public:
virtual double GetCurrentTestTime() = 0;
};
class SimplePThread {
public:
SimplePThread();
~SimplePThread();
void Start(uint64_t periodicity, void* host_ptr, void* context);
void Stop();
uint32_t GetTickCount();
private:
static bool is_running_;
pthread_t simple_timer_thread_;
typedef void* (*TimeThreadFunc)(void *arg_list);
static void* Tthread_function(void *arg_list);
TimeThreadFunc time_thread_function_;
struct arg_list_struct {
uint64_t periodicity;
void* host_ptr;
void* context;
};
static uint32_t tick_count_;
};
bool SimplePThread::is_running_ = false;
uint32_t SimplePThread::tick_count_ = 0;
SimplePThread::SimplePThread() : simple_timer_thread_(0) {
}
SimplePThread::~SimplePThread() {
LOGI("SimplePThread DTOR: calling Stop() to shutdown thread.");
Stop();
}
void SimplePThread::Stop() {
if (is_running_) {
void* result = NULL;
LOGI("SimplePThread is running and now it will be cancelled\n");
pthread_cancel(simple_timer_thread_);
pthread_join(simple_timer_thread_, &result);
is_running_ = false;
tick_count_ = 0;
}
}
void SimplePThread::Start(uint64_t periodicity, void* host_ptr, void* context) {
struct arg_list_struct* arg_list = new(struct arg_list_struct);
arg_list->periodicity = periodicity;
arg_list->host_ptr = host_ptr;
arg_list->context = context;
time_thread_function_ = &Tthread_function;
Stop();
is_running_ = true;
if(pthread_create(&simple_timer_thread_, NULL, time_thread_function_,
arg_list)) {
LOGI("Error creating pthread\n");
return;
}
LOGI("Created the Simple thread to support the timer callback\n");
}
void* SimplePThread::Tthread_function(void *arg_list) {
LOGI("Entered the SimplePThread::Tthread_function\n");
uint64_t periodicity = (static_cast<arg_list_struct*>(arg_list))->periodicity;
void* host_ptr = (static_cast<arg_list_struct*>(arg_list))->host_ptr;
void* context = (static_cast<arg_list_struct*>(arg_list))->context;
delete static_cast<struct arg_list_struct*>(arg_list);
LOGI("starting the while loop in the secondary thread\n");
while (is_running_) {
usleep(static_cast<uint64_t>(periodicity * 1000));
if (is_running_) {
((cdm::ContentDecryptionModule*)host_ptr)->TimerExpired(context);
tick_count_++;
}
}
return NULL;
}
uint32_t SimplePThread::GetTickCount() {
return tick_count_;
}
class TestHost : public cdm::Host, public IHostTime {
class TestHost : public cdm::Host {
public:
// These structs are used to store the KeyMessages and KeyErrors passed to
// this class' objects.
struct KeyMessage {
KeyMessage() {}
std::string session_id;
std::string message;
std::string default_url;
@@ -281,11 +88,9 @@ class TestHost : public cdm::Host, public IHostTime {
// cdm::Host implementation.
virtual cdm::Buffer* Allocate(int32_t capacity) OVERRIDE;
MOCK_METHOD2(SetTimer, void(int64_t, void*));
virtual void DoSetTimer(int64_t delay_ms, void* context);
// Returns the current "global" time from the GetCurrentTestTime() function
// unless the time is manually set using TestHost::SetCurrentTime()().
MOCK_METHOD0(GetCurrentWallTimeInSeconds, double(void));
virtual void SetTimer(int64_t delay_ms, void* context) OVERRIDE;
virtual double GetCurrentWallTimeInSeconds() OVERRIDE;
virtual void SendKeyMessage(const char* session_id, int32_t session_id_length,
const char* message, int32_t message_length,
@@ -296,30 +101,14 @@ class TestHost : public cdm::Host, public IHostTime {
cdm::MediaKeyError error_code,
uint32_t system_code) OVERRIDE;
virtual void GetPrivateData(int32_t* instance,
GetPrivateInterface* get_interface) OVERRIDE;
virtual void GetPlatformString(const std::string& name,
std::string* value) OVERRIDE;
virtual int GetPlatformString(const std::string& name,
std::string* value) OVERRIDE;
virtual int SetPlatformString(const std::string& name,
const std::string& value) OVERRIDE;;
virtual int PersistPlatformString(const std::string& name,
const std::string& value) OVERRIDE;;
virtual int GetPlatformByteArray(const std::string& name,
std::vector<uint8_t>* value) OVERRIDE;
virtual int SetPlatformByteArray(const std::string& name,
const std::vector<uint8_t>& value) OVERRIDE;
virtual int PersistPlatformByteArray(const std::string& name,
const std::vector<uint8_t>& value) OVERRIDE;
virtual void SetPlatformString(const std::string& name,
const std::string& value) OVERRIDE;
// Methods only for this test.
void SetCurrentTime(double current_time);
void FastForwardTimeForNextTimerEvent();
void FastForwardTime(double seconds);
int KeyMessagesSize() const;
int KeyErrorsSize() const;
@@ -333,17 +122,23 @@ class TestHost : public cdm::Host, public IHostTime {
KeyMessage GetKeyMessage(int index) const;
KeyError GetKeyError(int index) const;
void* context() { return context_; }
void SetCdmPtr(cdm::ContentDecryptionModule* host_cdm_ptr);
virtual double GetCurrentTestTime();
uint32_t GetTickCount();
void SetCdmPtr(cdm::ContentDecryptionModule* cdm);
private:
// This is used in GetCurrentWallTimeInSeconds(). This field is used to
// control the "current time".
struct Timer {
Timer(double expiry_time, void* context)
: expiry_time(expiry_time), context(context) {}
bool operator<(const Timer& other) const {
return expiry_time < other.expiry_time;
}
double expiry_time;
void* context;
};
double current_time_;
bool current_time_is_set_;
std::priority_queue<Timer> timers_;
std::vector<KeyMessage> key_messages_;
std::vector<KeyError> key_errors_;
@@ -351,29 +146,13 @@ class TestHost : public cdm::Host, public IHostTime {
bool has_new_key_message_;
bool has_new_key_error_;
void* context_;
int64_t delay_ms_;
std::map<std::string, std::string> platform_strings_;
cdm::ContentDecryptionModule* host_cdm_ptr_;
// These are containers for the platform sharing data.
std::set<StringPairs> platform_strings_set_;
std::set<VectorPairs> platform_vectors_set_;
TestHostFile test_host_file_;
void LoadPersistentValues();
SimplePThread simple_thread_;
cdm::ContentDecryptionModule* cdm_;
CORE_DISALLOW_COPY_AND_ASSIGN(TestHost);
};
class TestHostFactory {
public:
TestHost* GetTestHost();
private:
scoped_ptr<TestHost> test_host_;
};
TestBuffer* TestBuffer::Create(uint32_t capacity) {
return new TestBuffer(capacity);
}
@@ -395,37 +174,34 @@ void TestBuffer::SetSize(int32_t size) { size_ = size; }
int32_t TestBuffer::Size() const { return size_; }
TestBuffer::TestBuffer(uint32_t capacity)
: buffer_(new uint8_t[capacity]), capacity_(capacity) {}
: buffer_(new uint8_t[capacity]),
capacity_(capacity) {}
TestBuffer::~TestBuffer() {}
TestHost::TestHost()
: current_time_(::GetCurrentTestTime()),
current_time_is_set_(false),
: current_time_(GetCurrentTime()),
has_new_key_message_(false),
has_new_key_error_(false),
context_(NULL),
delay_ms_(0),
host_cdm_ptr_(NULL) {
LoadPersistentValues();
cdm_(NULL) {
}
TestHost::~TestHost() {}
TestHost::~TestHost() {
if (cdm_)
cdm_->Destroy();
}
cdm::Buffer* TestHost::Allocate(int32_t capacity) {
return TestBuffer::Create(capacity);
}
// SetTimer is a mock method mapping to DoSetTimer(). The cdm::Host
// calls back to the TimerExpired callback
// every delay_ms. Zero delay_ms means WV is requesting
// termination of timer services.
void TestHost::DoSetTimer(int64_t delay_ms, void* context) {
if (delay_ms == 0) {
simple_thread_.Stop();
return;
}
simple_thread_.Start(delay_ms, (void*)host_cdm_ptr_, context);
void TestHost::SetTimer(int64_t delay_ms, void* context) {
double expiry_time = current_time_ + (delay_ms / 1000.0);
timers_.push(Timer(expiry_time, context));
}
double TestHost::GetCurrentWallTimeInSeconds() {
return current_time_;
}
void TestHost::SendKeyMessage(const char* session_id, int32_t session_id_length,
@@ -451,131 +227,34 @@ void TestHost::SendKeyError(const char* session_id, int32_t session_id_length,
has_new_key_error_ = true;
}
void TestHost::SetCurrentTime(double current_time) {
current_time_is_set_ = true;
current_time_ = current_time;
}
void TestHost::FastForwardTimeForNextTimerEvent() {
current_time_is_set_ = true;
current_time_ += (delay_ms_ / 1000.0);
delay_ms_ = 0;
}
void TestHost::GetPrivateData(int32_t* instance,
GetPrivateInterface* get_interface) {
LOGI("NOTIMPLEMENTED()");
}
// The Platform methods below are implemented to fill and retrieve
// platform specific information. The host application takes responsibility for
// this interface.
int TestHost::GetPlatformString(const std::string& name,
std::string* value) {
std::set<StringPairs>::iterator it;
for (it = platform_strings_set_.begin();
it != platform_strings_set_.end(); ++it) {
StringPairs sp = *it;
std::string x = sp.first;
std::string y = sp.second;
if (x == name) {
*value = y;
return 1;
void TestHost::FastForwardTime(double seconds) {
double goal_time = current_time_ + seconds;
while (current_time_ < goal_time) {
if (timers_.empty()) {
current_time_ = goal_time;
} else {
Timer t = timers_.top();
timers_.pop();
current_time_ = t.expiry_time;
cdm_->TimerExpired(t.context);
}
}
*value = "Not Found!";
return 0;
}
int TestHost::SetPlatformString(const std::string& name,
const std::string& value) {
StringPairs sp(name, value);
platform_strings_set_.insert(sp);
return 1;
void TestHost::GetPlatformString(const std::string& name,
std::string* value) {
*value = platform_strings_[name];
}
int TestHost::PersistPlatformString(const std::string& name,
const std::string& value) {
StringPairs sp(name, value);
// Write the pairs to a file such that they can be retrieved by
// GetPlatformString() even after a power cycle.
return 1;
}
int TestHost::SetPlatformByteArray(const std::string& name,
const std::vector<uint8_t>& value) {
// A zero value pair is an erase only.
std::set<VectorPairs>::iterator it;
for (it = platform_vectors_set_.begin();
it != platform_vectors_set_.end(); ++it) {
VectorPairs vp = *it;
if (vp.first == name) {
platform_vectors_set_.erase(vp);
}
}
if (value.size() > 0) {
VectorPairs vp(name, value);
platform_vectors_set_.insert(vp);
}
return 1;
}
int TestHost::PersistPlatformByteArray(const std::string& name,
const std::vector<uint8_t>& value) {
// Assume input name = "DeviceCertificate" and
// test_host_file.fname_ == "cert.bin"
// No other cases are currently needed or supported.
if (value.size() == 0) {
remove(test_host_file_.GetFileName().c_str());
} else {
std::string string_buffer;
string_buffer.resize(value.size());
memcpy(&string_buffer[0], &value[0], value.size());
test_host_file_.Write(&string_buffer[0], value.size());
}
VectorPairs vp(name, value);
SetPlatformByteArray(name, value);
// open file and persist this so that it can be retrieved as a string/vector
// correlated pair. Vendor needs to implement this!
return 1;
}
int TestHost::GetPlatformByteArray(const std::string& name,
std::vector<uint8_t>* value) {
std::set<VectorPairs>::iterator it;
for (it = platform_vectors_set_.begin();
it != platform_vectors_set_.end(); ++it) {
VectorPairs vp = *it;
std::string x = vp.first;
if (x == name) {
*value = vp.second;
return 1;
}
}
value = NULL;
return 0;
void TestHost::SetPlatformString(const std::string& name,
const std::string& value) {
platform_strings_[name] = value;
}
int TestHost::KeyMessagesSize() const { return key_messages_.size(); }
int TestHost::KeyErrorsSize() const { return key_errors_.size(); }
double TestHost::GetCurrentTestTime() {
current_time_is_set_ = true;
FastForwardTimeForNextTimerEvent();
return current_time_;
}
TestHost::KeyMessage TestHost::GetLastKeyMessage() {
if (!has_new_key_message_) {
LOGD("No NEW");
@@ -609,40 +288,8 @@ TestHost::KeyError TestHost::GetKeyError(int index) const {
return key_errors_[index];
}
void TestHost::SetCdmPtr(cdm::ContentDecryptionModule* host_cdm_ptr) {
host_cdm_ptr_ = host_cdm_ptr;
}
uint32_t TestHost::GetTickCount() {
return simple_thread_.GetTickCount();
}
TestHost* TestHostFactory::GetTestHost() {
if (!test_host_.get()) test_host_.reset(new TestHost());
return test_host_.get();
return NULL;
}
// The CDM::Host object is responsible for storing and retrieving items
// that are accessed via GetPlatformByteArray. Currently, support for
// the device certificate is all that is required.
void TestHost::LoadPersistentValues() {
test_host_file_.Init("cert.bin");
if (test_host_file_.Exists()) {
size_t size = test_host_file_.Size();
std::string string_buffer;
string_buffer.resize(size);
test_host_file_.Read(&string_buffer[0], size);
std::vector<uint8_t> vector_buffer(size);
memcpy(&vector_buffer[0], &string_buffer[0], size);
SetPlatformByteArray("DeviceCertificate", vector_buffer);
}
void TestHost::SetCdmPtr(cdm::ContentDecryptionModule* cdm) {
cdm_ = cdm;
}
class TestDecryptedBlock : public cdm::DecryptedBlock {
@@ -686,6 +333,7 @@ void TestDecryptedBlock::SetTimestamp(int64_t timestamp) {
int64_t TestDecryptedBlock::Timestamp() const { return timestamp_; }
namespace {
// Default license server, can be configured using --server command line option
// Default key id (pssh), can be configured using --keyid command line option
const char kKeySystemWidevine[] = "com.widevine.alpha";
@@ -694,53 +342,49 @@ wvcdm::KeyId g_key_id;
wvcdm::CdmKeySystem g_key_system;
std::string g_license_server;
wvcdm::KeyId g_wrong_key_id;
int g_use_full_path = 0; // cannot use boolean in getopt_long
void* GetCdmHost(int host_interface_version, void* user_data) {
if (host_interface_version != cdm::kHostInterfaceVersion)
return NULL;
return user_data;
}
} // namespace
namespace wvcdm {
void* GetCdmHost(int host_interface_version, void* user_data);
class WvCdmApiTest : public testing::Test {
public:
WvCdmApiTest() : cdm_(NULL) {}
~WvCdmApiTest() {
if (cdm_) cdm_->Destroy();
}
~WvCdmApiTest() {}
protected:
virtual void SetUp() {
cdm_ = reinterpret_cast<cdm::ContentDecryptionModule*>(::CreateCdmInstance(
cdm::kCdmInterfaceVersion, kKeySystemWidevine,
strlen(kKeySystemWidevine), GetCdmHost, &host_factory_));
host_ = host_factory_.GetTestHost();
host_->SetCdmPtr(cdm_);
// Create the Host.
host_.reset(new TestHost());
// Set various parameters that the CDM will query.
host_->SetPlatformString("SecurityLevel", "L1");
host_->SetPlatformString("PrivacyOn", "False");
host_->SetPlatformString("UsesServiceCertificates", "False");
// By default we allow the timer to fire twice; once
// when the addkey comes, and once when the wvcdm destructs and
// disables the timer.
EXPECT_CALL(*host_, SetTimer(_,_))
.Times(AtLeast(2))
.WillRepeatedly(Invoke(host_, &TestHost::DoSetTimer));
EXPECT_CALL(*host_, GetCurrentWallTimeInSeconds())
.Times(AtLeast(1))
.WillRepeatedly(Invoke(host_, &TestHost::GetCurrentTestTime));
// emulate pulling a certificate out of persistent storage.
// Put a phony service certificate into persistent storage.
static const size_t kPrivacyCertSize = 256;
VectorBytes cert(kPrivacyCertSize);
std::string cert(kPrivacyCertSize, '\0');
for (size_t i = 0; i < cert.size(); i++) {
cert[i] = i;
}
host_->SetPlatformString("ServiceCertificate", cert);
host_->SetPlatformByteArray("ServiceCertificate", cert);
// Initialize the CDM module before creating a CDM instance.
INITIALIZE_CDM_MODULE();
// Create the CDM.
cdm_ = reinterpret_cast<cdm::ContentDecryptionModule*>(::CreateCdmInstance(
cdm::kCdmInterfaceVersion, kKeySystemWidevine,
strlen(kKeySystemWidevine), GetCdmHost, host_.get()));
// Tell the Host about the CDM.
host_->SetCdmPtr(cdm_);
}
void GenerateKeyRequest(const std::string& key_system,
@@ -781,7 +425,6 @@ class WvCdmApiTest : public testing::Test {
std::string GetKeyRequestResponse(const std::string& server_url,
const std::string& client_auth,
int expected_response) {
// Use secure connection and chunk transfer coding.
UrlRequest url_request(server_url + client_auth);
if (!url_request.is_connected()) {
return "";
@@ -790,8 +433,6 @@ class WvCdmApiTest : public testing::Test {
url_request.PostRequest(key_msg_);
std::string response;
int resp_bytes = url_request.GetResponse(&response);
LOGD("response:\r\n%s", response.c_str());
LOGD("end %d bytes response dump", resp_bytes);
// Some license servers return 400 for invalid message, some
// return 500; treat anything other than 200 as an invalid message.
@@ -809,7 +450,7 @@ class WvCdmApiTest : public testing::Test {
std::string drm_msg;
LicenseRequest lic_request;
lic_request.GetDrmMessage(response, drm_msg);
LOGV("drm msg: %u bytes\r\n%s", drm_msg.size(),
LOGV("drm msg: %u bytes\n%s", drm_msg.size(),
HexEncode(reinterpret_cast<const uint8_t*>(drm_msg.data()),
drm_msg.size()).c_str());
return drm_msg;
@@ -1310,15 +951,12 @@ class WvCdmApiTest : public testing::Test {
EXPECT_EQ(cdm::kDecryptError, status);
}
void TimerTest(void* session_id) { host_->SetTimer(1000, session_id); }
std::string key_msg_;
std::string session_id_;
std::string server_url_;
cdm::ContentDecryptionModule* cdm_;
TestHostFactory host_factory_;
TestHost* host_;
cdm::ContentDecryptionModule* cdm_; // owned by host_
scoped_ptr<TestHost> host_;
};
// Note that these tests, BaseMessageTest, NormalDecryption and TimeTest,
@@ -1328,8 +966,7 @@ class WvCdmApiTest : public testing::Test {
// and works in your test environment.
TEST_F(WvCdmApiTest, DeviceCertificateTest) {
std::vector<uint8_t> value(0);
host_->PersistPlatformByteArray("DeviceCertificate", value);
host_->SetPlatformString("DeviceCertificate", "");
GenerateKeyRequest(g_key_system, g_key_id); // It will have to provision -
// in here.
TestHost::KeyMessage key_msg = host_->GetLastKeyMessage();
@@ -1352,25 +989,6 @@ TEST_F(WvCdmApiTest, BaseMessageTest) {
CancelKeyRequest(session_id_);
}
TEST_F(WvCdmApiTest, BaseTimerTest) {
GenerateKeyRequest(g_key_system, g_key_id);
TestHost::KeyMessage key_msg = host_->GetLastKeyMessage();
session_id_ = key_msg.session_id;
key_msg_ = key_msg.message;
std::string drm_msg = GetKeyRequestResponse(g_license_server,
g_client_auth, 200);
AddKey(key_msg.session_id, drm_msg);
LOGI("Sleeping and allowing the time expirations to increment");
uint32_t sleep_period = static_cast<uint32_t>(12000 / 1000);
sleep(sleep_period);
LOGI("Tick count is %ld\n", host_->GetTickCount());
// We should have close to, maybe slightly less than sleep_period ticks.
// If it ticked at all then we pass as the timer must be expriring.
EXPECT_GE(host_->GetTickCount(), 1U);
CancelKeyRequest(session_id_);
}
TEST_F(WvCdmApiTest, NormalDecryption) {
GenerateKeyRequest(g_key_system, g_key_id);
TestHost::KeyMessage key_msg = host_->GetLastKeyMessage();
@@ -1410,8 +1028,8 @@ TEST_F(WvCdmApiTest, TimeTest) {
g_client_auth, 200);
AddKey(key_msg.session_id, drm_msg);
host_->SetCurrentTime(host_->GetCurrentTestTime() + kTestPolicyRenewalDelaySeconds);
sleep(kDelayWaitToForRenewalMessageSeconds);
host_->FastForwardTime(kTestPolicyRenewalDelaySeconds +
kDelayWaitToForRenewalMessageSeconds);
// When the timer expired, we should have sent a renewal, so we can
// add this renewed key now, assuming things are working as expected.
@@ -1419,7 +1037,10 @@ TEST_F(WvCdmApiTest, TimeTest) {
session_id_ = key_msg2.session_id;
key_msg_ = key_msg2.message;
drm_msg = GetKeyRequestResponse(key_msg2.default_url, g_client_auth, 200);
// Note that the client auth string is not appended when the CDM tells
// us what URL to use.
EXPECT_FALSE(key_msg2.default_url.empty());
drm_msg = GetKeyRequestResponse(key_msg2.default_url, "", 200);
AddKey(key_msg2.session_id, drm_msg);
}
@@ -1453,15 +1074,6 @@ TEST_F(WvCdmApiTest, SecureDecryptionLevel1WithMissingSubsampleInfo) {
WithMissingSubsampleInfoTest();
}
void* GetCdmHost(int host_interface_version, void* user_data) {
if (!host_interface_version || !user_data) return NULL;
if (host_interface_version != cdm::kHostInterfaceVersion) return NULL;
TestHostFactory* host_factory = reinterpret_cast<TestHostFactory*>(user_data);
return host_factory->GetTestHost();
}
} // namespace wvcdm
int main(int argc, char** argv) {
@@ -1480,16 +1092,13 @@ int main(int argc, char** argv) {
int show_usage = 0;
static const struct option long_options[] = {
{"use_full_path", no_argument, &g_use_full_path, 0},
{"keyid", required_argument, NULL, 'k'},
{"server", required_argument, NULL, 's'},
{"vmodule", required_argument, NULL, 0},
{"v", required_argument, NULL, 0},
{NULL, 0, NULL, '\0'}};
int option_index = 0;
int opt = 0;
while ((opt = getopt_long(argc, argv, "k:p:s:u:v", long_options,
while ((opt = getopt_long(argc, argv, "k:s:v", long_options,
&option_index)) != -1) {
switch (opt) {
case 'k': {
@@ -1502,15 +1111,19 @@ int main(int argc, char** argv) {
g_license_server.assign(optarg);
break;
}
case 'u': {
g_use_full_path = 1;
case 'v': {
// This option has already been consumed by wvcdm::InitLogging() above.
// We only tell getopt about it so that it is not an error. We ignore
// the option here when seen.
// TODO: Stop passing argv to InitLogging, and instead set the log
// level here through the logging API. We should keep all command-line
// parsing at the application level, rather than split between various
// apps and various platform-specific logging implementations.
break;
}
case '?': {
show_usage = 1;
break;
case 'v':
break;
}
}
}
@@ -1518,10 +1131,6 @@ int main(int argc, char** argv) {
if (show_usage) {
std::cout << std::endl;
std::cout << "usage: " << argv[0] << " [options]" << std::endl << std::endl;
std::cout << " enclose multiple arguments in '' when using adb shell"
<< std::endl;
std::cout << " e.g. adb shell '" << argv[0] << " --server=\"url\"'"
<< std::endl << std::endl;
std::cout << std::setw(30) << std::left << " --server=<server_url>";
std::cout
@@ -1534,10 +1143,6 @@ int main(int argc, char** argv) {
std::cout << "configure the key id or pssh, in hex format" << std::endl;
std::cout << std::setw(30) << std::left << " default keyid:";
std::cout << g_key_id << std::endl;
std::cout << std::setw(30) << std::left << " --use_full_path";
std::cout << "specify server url is not a proxy server" << std::endl;
std::cout << std::endl;
return 0;
}

4
core/include/cdm_client_property_set.h
View File

@@ -13,9 +13,9 @@ class CdmClientPropertySet {
public:
virtual ~CdmClientPropertySet() {}
virtual std::string security_level() const = 0;
virtual const std::string& security_level() const = 0;
virtual bool use_privacy_mode() const = 0;
virtual std::vector<uint8_t> service_certificate() const = 0;
virtual const std::string& service_certificate() const = 0;
virtual bool is_session_sharing_enabled() const = 0;
virtual uint32_t session_sharing_id() const = 0;
virtual void set_session_sharing_id(uint32_t id) = 0;

96
core/include/cdm_engine.h
View File

@@ -24,95 +24,91 @@ class CdmEngine {
virtual ~CdmEngine();
// Session related methods
CdmResponseType OpenSession(const CdmKeySystem& key_system,
const CdmClientPropertySet* property_set,
CdmSessionId* session_id);
CdmResponseType CloseSession(const CdmSessionId& session_id);
virtual CdmResponseType OpenSession(const CdmKeySystem& key_system,
const CdmClientPropertySet* property_set,
CdmSessionId* session_id);
virtual CdmResponseType CloseSession(const CdmSessionId& session_id);
CdmResponseType OpenKeySetSession(const CdmKeySetId& key_set_id);
CdmResponseType CloseKeySetSession(const CdmKeySetId& key_set_id);
virtual CdmResponseType OpenKeySetSession(const CdmKeySetId& key_set_id);
virtual CdmResponseType CloseKeySetSession(const CdmKeySetId& key_set_id);
// License related methods
// Construct a valid license request
CdmResponseType GenerateKeyRequest(const CdmSessionId& session_id,
const CdmKeySetId& key_set_id,
const InitializationData& init_data,
const CdmLicenseType license_type,
CdmAppParameterMap& app_parameters,
CdmKeyMessage* key_request,
std::string* server_url);
virtual CdmResponseType GenerateKeyRequest(
const CdmSessionId& session_id, const CdmKeySetId& key_set_id,
const InitializationData& init_data, const CdmLicenseType license_type,
CdmAppParameterMap& app_parameters, CdmKeyMessage* key_request,
std::string* server_url);
// Accept license response and extract key info.
CdmResponseType AddKey(const CdmSessionId& session_id,
const CdmKeyResponse& key_data,
CdmKeySetId* key_set_id);
virtual CdmResponseType AddKey(const CdmSessionId& session_id,
const CdmKeyResponse& key_data,
CdmKeySetId* key_set_id);
CdmResponseType RestoreKey(const CdmSessionId& session_id,
const CdmKeySetId& key_set_id);
virtual CdmResponseType RestoreKey(const CdmSessionId& session_id,
const CdmKeySetId& key_set_id);
CdmResponseType CancelKeyRequest(const CdmSessionId& session_id);
virtual CdmResponseType CancelKeyRequest(const CdmSessionId& session_id);
// Construct valid renewal request for the current session keys.
CdmResponseType GenerateRenewalRequest(const CdmSessionId& session_id,
CdmKeyMessage* key_request,
std::string* server_url);
virtual CdmResponseType GenerateRenewalRequest(const CdmSessionId& session_id,
CdmKeyMessage* key_request,
std::string* server_url);
// Accept renewal response and update key info.
CdmResponseType RenewKey(const CdmSessionId& session_id,
const CdmKeyResponse& key_data);
virtual CdmResponseType RenewKey(const CdmSessionId& session_id,
const CdmKeyResponse& key_data);
// Query system information
CdmResponseType QueryStatus(CdmQueryMap* info);
virtual CdmResponseType QueryStatus(CdmQueryMap* info);
// Query session information
virtual CdmResponseType QuerySessionStatus(const CdmSessionId& session_id,
CdmQueryMap* key_info);
// Query license information
CdmResponseType QueryKeyStatus(const CdmSessionId& session_id,
CdmQueryMap* key_info);
virtual CdmResponseType QueryKeyStatus(const CdmSessionId& session_id,
CdmQueryMap* key_info);
// Query seesion control information
CdmResponseType QueryKeyControlInfo(const CdmSessionId& session_id,
CdmQueryMap* key_info);
virtual CdmResponseType QueryKeyControlInfo(const CdmSessionId& session_id,
CdmQueryMap* key_info);
// Provisioning related methods
CdmResponseType GetProvisioningRequest(
CdmCertificateType cert_type,
const std::string& cert_authority,
CdmProvisioningRequest* request,
std::string* default_url);
virtual CdmResponseType GetProvisioningRequest(
CdmCertificateType cert_type, const std::string& cert_authority,
CdmProvisioningRequest* request, std::string* default_url);
CdmResponseType HandleProvisioningResponse(
CdmProvisioningResponse& response,
std::string* cert,
virtual CdmResponseType HandleProvisioningResponse(
CdmProvisioningResponse& response, std::string* cert,
std::string* wrapped_key);
CdmResponseType Unprovision(CdmSecurityLevel security_level);
virtual CdmResponseType Unprovision(CdmSecurityLevel security_level);
// Usage related methods for streaming licenses
CdmResponseType GetUsageInfo(CdmUsageInfo* usage_info);
CdmResponseType ReleaseUsageInfo(const CdmUsageInfoReleaseMessage& message);
virtual CdmResponseType GetUsageInfo(CdmUsageInfo* usage_info);
virtual CdmResponseType ReleaseUsageInfo(
const CdmUsageInfoReleaseMessage& message);
// Decryption and key related methods
// Accept encrypted buffer and return decrypted data.
CdmResponseType Decrypt(const CdmSessionId& session_id,
const CdmDecryptionParameters& parameters);
virtual CdmResponseType Decrypt(const CdmSessionId& session_id,
const CdmDecryptionParameters& parameters);
size_t SessionSize() const { return sessions_.size(); }
virtual size_t SessionSize() const { return sessions_.size(); }
// Is the key known to any session?
bool IsKeyLoaded(const KeyId& key_id);
bool FindSessionForKey(const KeyId& key_id, CdmSessionId* sessionId);
virtual bool IsKeyLoaded(const KeyId& key_id);
virtual bool FindSessionForKey(const KeyId& key_id, CdmSessionId* sessionId);
// Event listener related methods
bool AttachEventListener(const CdmSessionId& session_id,
WvCdmEventListener* listener);
bool DetachEventListener(const CdmSessionId& session_id,
WvCdmEventListener* listener);
virtual bool AttachEventListener(const CdmSessionId& session_id,
WvCdmEventListener* listener);
virtual bool DetachEventListener(const CdmSessionId& session_id,
WvCdmEventListener* listener);
// Timer expiration method
void OnTimerEvent();
virtual void OnTimerEvent();
private:
// private methods

79
core/include/cdm_session.h
View File

@@ -22,81 +22,83 @@ class WvCdmEventListener;
class CdmSession {
public:
explicit CdmSession(const CdmClientPropertySet* cdm_client_property_set);
~CdmSession();
virtual ~CdmSession();
CdmResponseType Init();
virtual CdmResponseType Init();
CdmResponseType RestoreOfflineSession(const CdmKeySetId& key_set_id,
const CdmLicenseType license_type);
CdmResponseType RestoreUsageSession(const CdmKeyMessage& key_request,
const CdmKeyResponse& key_response);
virtual CdmResponseType RestoreOfflineSession(
const CdmKeySetId& key_set_id, const CdmLicenseType license_type);
virtual CdmResponseType RestoreUsageSession(
const CdmKeyMessage& key_request, const CdmKeyResponse& key_response);
void set_key_system(const CdmKeySystem& ksystem) { key_system_ = ksystem; }
const CdmKeySystem& key_system() { return key_system_; }
virtual void set_key_system(const CdmKeySystem& ksystem) {
key_system_ = ksystem;
}
virtual const CdmKeySystem& key_system() { return key_system_; }
const CdmSessionId& session_id() { return session_id_; }
virtual const CdmSessionId& session_id() { return session_id_; }
CdmResponseType GenerateKeyRequest(const InitializationData& init_data,
const CdmLicenseType license_type,
const CdmAppParameterMap& app_parameters,
CdmKeyMessage* key_request,
std::string* server_url);
virtual CdmResponseType GenerateKeyRequest(
const InitializationData& init_data, const CdmLicenseType license_type,
const CdmAppParameterMap& app_parameters, CdmKeyMessage* key_request,
std::string* server_url);
// AddKey() - Accept license response and extract key info.
CdmResponseType AddKey(const CdmKeyResponse& key_response,
CdmKeySetId* key_set_id);
virtual CdmResponseType AddKey(const CdmKeyResponse& key_response,
CdmKeySetId* key_set_id);
// CancelKeyRequest() - Cancel session.
CdmResponseType CancelKeyRequest();
virtual CdmResponseType CancelKeyRequest();
// Query session status
CdmResponseType QueryStatus(CdmQueryMap* key_info);
virtual CdmResponseType QueryStatus(CdmQueryMap* key_info);
// Query license information
CdmResponseType QueryKeyStatus(CdmQueryMap* key_info);
virtual CdmResponseType QueryKeyStatus(CdmQueryMap* key_info);
// Query session control info
CdmResponseType QueryKeyControlInfo(CdmQueryMap* key_info);
virtual CdmResponseType QueryKeyControlInfo(CdmQueryMap* key_info);
// Decrypt() - Accept encrypted buffer and return decrypted data.
CdmResponseType Decrypt(const CdmDecryptionParameters& parameters);
virtual CdmResponseType Decrypt(const CdmDecryptionParameters& parameters);
// License renewal
// GenerateRenewalRequest() - Construct valid renewal request for the current
// session keys.
CdmResponseType GenerateRenewalRequest(CdmKeyMessage* key_request,
std::string* server_url);
virtual CdmResponseType GenerateRenewalRequest(CdmKeyMessage* key_request,
std::string* server_url);
// RenewKey() - Accept renewal response and update key info.
CdmResponseType RenewKey(const CdmKeyResponse& key_response);
virtual CdmResponseType RenewKey(const CdmKeyResponse& key_response);
// License release
// GenerateReleaseRequest() - Construct valid release request for the current
// session keys.
CdmResponseType GenerateReleaseRequest(CdmKeyMessage* key_request,
std::string* server_url);
virtual CdmResponseType GenerateReleaseRequest(CdmKeyMessage* key_request,
std::string* server_url);
// ReleaseKey() - Accept response and release key.
CdmResponseType ReleaseKey(const CdmKeyResponse& key_response);
virtual CdmResponseType ReleaseKey(const CdmKeyResponse& key_response);
bool IsKeyLoaded(const KeyId& key_id);
virtual bool IsKeyLoaded(const KeyId& key_id);
bool AttachEventListener(WvCdmEventListener* listener);
bool DetachEventListener(WvCdmEventListener* listener);
virtual bool AttachEventListener(WvCdmEventListener* listener);
virtual bool DetachEventListener(WvCdmEventListener* listener);
void OnTimerEvent();
void OnKeyReleaseEvent(const CdmKeySetId& key_set_id);
virtual void OnTimerEvent();
virtual void OnKeyReleaseEvent(const CdmKeySetId& key_set_id);
SecurityLevel GetRequestedSecurityLevel();
CdmSecurityLevel GetSecurityLevel();
virtual SecurityLevel GetRequestedSecurityLevel();
virtual CdmSecurityLevel GetSecurityLevel();
CdmResponseType UpdateUsageInformation();
virtual CdmResponseType UpdateUsageInformation();
bool is_usage_update_needed() { return is_usage_update_needed_; }
void reset_is_usage_update_needed() { is_usage_update_needed_ = false; }
virtual bool is_usage_update_needed() { return is_usage_update_needed_; }
virtual void reset_is_usage_update_needed() {
is_usage_update_needed_ = false;
}
private:
// Generate unique ID for each new session.
CdmSessionId GenerateSessionId();
bool GenerateKeySetId(CdmKeySetId* key_set_id);
@@ -116,6 +118,7 @@ class CdmSession {
bool is_offline_;
bool is_release_;
bool is_usage_update_needed_;
bool is_initial_decryption_;
// information useful for offline and usage scenarios
CdmKeyMessage key_request_;

89
core/include/crypto_session.h
View File

@@ -19,61 +19,60 @@ typedef std::map<CryptoKeyId, CryptoKey*> CryptoKeyMap;
class CryptoSession {
public:
CryptoSession();
~CryptoSession();
virtual ~CryptoSession();
bool ValidateKeybox();
bool GetToken(std::string* token);
CdmSecurityLevel GetSecurityLevel();
bool GetDeviceUniqueId(std::string* device_id);
bool GetSystemId(uint32_t* system_id);
bool GetProvisioningId(std::string* provisioning_id);
virtual bool ValidateKeybox();
virtual bool GetToken(std::string* token);
virtual CdmSecurityLevel GetSecurityLevel();
virtual bool GetDeviceUniqueId(std::string* device_id);
virtual bool GetSystemId(uint32_t* system_id);
virtual bool GetProvisioningId(std::string* provisioning_id);
CdmResponseType Open() { return Open(kLevelDefault); }
CdmResponseType Open(SecurityLevel requested_security_level);
void Close();
virtual CdmResponseType Open() { return Open(kLevelDefault); }
virtual CdmResponseType Open(SecurityLevel requested_security_level);
virtual void Close();
bool IsOpen() { return open_; }
CryptoSessionId oec_session_id() { return oec_session_id_; }
virtual bool IsOpen() { return open_; }
virtual CryptoSessionId oec_session_id() { return oec_session_id_; }
// Key request/response
void GenerateRequestId(std::string& req_id_str);
bool PrepareRequest(const std::string& key_deriv_message,
bool is_provisioning, std::string* signature);
bool PrepareRenewalRequest(const std::string& message,
std::string* signature);
CdmResponseType LoadKeys(const std::string& message,
const std::string& signature,
const std::string& mac_key_iv,
const std::string& mac_key,
const std::vector<CryptoKey>& key_array,
const std::string& provider_session_token);
bool LoadCertificatePrivateKey(std::string& wrapped_key);
bool RefreshKeys(const std::string& message, const std::string& signature,
int num_keys, const CryptoKey* key_array);
bool GenerateNonce(uint32_t* nonce);
bool GenerateDerivedKeys(const std::string& message);
bool GenerateDerivedKeys(const std::string& message,
const std::string& session_key);
bool RewrapDeviceRSAKey(const std::string& message,
const std::string& signature,
const std::string& nonce,
const std::string& enc_rsa_key,
const std::string& rsa_key_iv,
std::string* wrapped_rsa_key);
virtual void GenerateRequestId(std::string& req_id_str);
virtual bool PrepareRequest(const std::string& key_deriv_message,
bool is_provisioning, std::string* signature);
virtual bool PrepareRenewalRequest(const std::string& message,
std::string* signature);
virtual CdmResponseType LoadKeys(const std::string& message,
const std::string& signature,
const std::string& mac_key_iv,
const std::string& mac_key,
const std::vector<CryptoKey>& key_array,
const std::string& provider_session_token);
virtual bool LoadCertificatePrivateKey(std::string& wrapped_key);
virtual bool RefreshKeys(const std::string& message,
const std::string& signature, int num_keys,
const CryptoKey* key_array);
virtual bool GenerateNonce(uint32_t* nonce);
virtual bool GenerateDerivedKeys(const std::string& message);
virtual bool GenerateDerivedKeys(const std::string& message,
const std::string& session_key);
virtual bool RewrapDeviceRSAKey(const std::string& message,
const std::string& signature,
const std::string& nonce,
const std::string& enc_rsa_key,
const std::string& rsa_key_iv,
std::string* wrapped_rsa_key);
// Media data path
CdmResponseType Decrypt(const CdmDecryptionParameters& parameters);
virtual CdmResponseType Decrypt(const CdmDecryptionParameters& parameters);
CdmResponseType UpdateUsageInformation();
CdmResponseType GenerateUsageReport(
const std::string& provider_session_token,
std::string* usage_report);
CdmResponseType ReleaseUsageInformation(
const std::string& message,
const std::string& signature,
virtual CdmResponseType UpdateUsageInformation();
virtual CdmResponseType GenerateUsageReport(
const std::string& provider_session_token, std::string* usage_report);
virtual CdmResponseType ReleaseUsageInformation(
const std::string& message, const std::string& signature,
const std::string& provider_session_token);
bool GetRandom(size_t data_length, uint8_t* random_data);
virtual bool GetRandom(size_t data_length, uint8_t* random_data);
private:
void Init();

22
core/include/license.h
View File

@@ -23,32 +23,32 @@ class CdmLicense {
public:
CdmLicense() : session_(NULL), initialized_(false) {}
~CdmLicense() {}
virtual ~CdmLicense() {}
bool Init(const std::string& token, CryptoSession* session,
virtual bool Init(const std::string& token, CryptoSession* session,
PolicyEngine* policy_engine);
bool PrepareKeyRequest(const InitializationData& init_data,
virtual bool PrepareKeyRequest(const InitializationData& init_data,
const CdmLicenseType license_type,
const CdmAppParameterMap& app_parameters,
const CdmSessionId& session_id,
CdmKeyMessage* signed_request,
std::string* server_url);
bool PrepareKeyUpdateRequest(bool is_renewal, CdmKeyMessage* signed_request,
virtual bool PrepareKeyUpdateRequest(bool is_renewal, CdmKeyMessage* signed_request,
std::string* server_url);
CdmResponseType HandleKeyResponse(const CdmKeyResponse& license_response);
CdmResponseType HandleKeyUpdateResponse(
virtual CdmResponseType HandleKeyResponse(const CdmKeyResponse& license_response);
virtual CdmResponseType HandleKeyUpdateResponse(
bool is_renewal, const CdmKeyResponse& license_response);
bool RestoreOfflineLicense(const CdmKeyMessage& license_request,
virtual bool RestoreOfflineLicense(const CdmKeyMessage& license_request,
const CdmKeyResponse& license_response,
const CdmKeyResponse& license_renewal_response);
bool RestoreUsageLicense(const CdmKeyMessage& license_request,
virtual bool RestoreUsageLicense(const CdmKeyMessage& license_request,
const CdmKeyResponse& license_response);
bool HasInitData() { return !stored_init_data_.empty(); }
bool IsKeyLoaded(const KeyId& key_id);
virtual bool HasInitData() { return !stored_init_data_.empty(); }
virtual bool IsKeyLoaded(const KeyId& key_id);
std::string provider_session_token() { return provider_session_token_; }
virtual std::string provider_session_token() { return provider_session_token_; }
private:
bool PrepareServiceCertificateRequest(CdmKeyMessage* signed_request,

34
core/include/policy_engine.h
View File

@@ -10,6 +10,8 @@
namespace wvcdm {
using video_widevine_server::sdk::LicenseIdentification;
class Clock;
class PolicyEngineTest;
@@ -18,53 +20,46 @@ class PolicyEngineTest;
class PolicyEngine {
public:
PolicyEngine();
~PolicyEngine();
virtual ~PolicyEngine();
// The value returned should be taken as a hint rather than an absolute
// status. It is computed during the last call to either SetLicense/
// UpdateLicense/OnTimerEvent/BeginDecryption and may be out of sync
// depending on the amount of time elapsed. The current decryption
// status is not calculated to avoid overhead in the decryption path.
inline bool can_decrypt() { return can_decrypt_; }
virtual bool can_decrypt() { return can_decrypt_; }
// OnTimerEvent is called when a timer fires. It notifies the Policy Engine
// that the timer has fired and that it should check whether any events have
// occurred since the last timer event. If so, it sets event_occurred to true
// and sets event to point to the event that occurred. If not, it sets
// event_occurred to false.
void OnTimerEvent(bool* event_occurred, CdmEventType* event);
virtual void OnTimerEvent(bool* event_occurred, CdmEventType* event);
// SetLicense is used in handling the initial license response. It stores
// an exact copy of the policy information stored in the license.
// The license state transitions to kLicenseStateCanPlay if the license
// permits playback.
void SetLicense(const video_widevine_server::sdk::License& license);
virtual void SetLicense(const video_widevine_server::sdk::License& license);
// Call this on first decrypt to set the start of playback. This is
// for cases where usage begins not when the license is received,
// but at the start of playback
void BeginDecryption(void);
// Call this on first decrypt to set the start of playback.
virtual void BeginDecryption(void);
// UpdateLicense is used in handling a license response for a renewal request.
// The response may only contain any policy fields that have changed. In this
// case an exact copy is not what we want to happen. We also will receive an
// updated license_start_time from the server. The license will transition to
// kLicenseStateCanPlay if the license permits playback.
void UpdateLicense(const video_widevine_server::sdk::License& license);
virtual void UpdateLicense(
const video_widevine_server::sdk::License& license);
CdmResponseType Query(CdmQueryMap* key_info);
virtual CdmResponseType Query(CdmQueryMap* key_info);
const video_widevine_server::sdk::LicenseIdentification& license_id() {
return license_id_;
}
bool IsLicenseDurationExpired(int64_t current_time);
bool IsPlaybackDurationExpired(int64_t current_time);
virtual const LicenseIdentification& license_id() { return license_id_; }
private:
typedef enum {
kLicenseStateInitial,
kLicenseStateInitialPendingUsage,
kLicenseStateCanPlay,
kLicenseStateNeedRenewal,
kLicenseStateWaitingLicenseUpdate,
@@ -73,6 +68,11 @@ class PolicyEngine {
void Init(Clock* clock);
bool IsLicenseDurationExpired(int64_t current_time);
int64_t GetLicenseDurationRemaining(int64_t current_time);
bool IsPlaybackDurationExpired(int64_t current_time);
int64_t GetPlaybackDurationRemaining(int64_t current_time);
bool IsRenewalDelayExpired(int64_t current_time);
bool IsRenewalRecoveryDurationExpired(int64_t current_time);
bool IsRenewalRetryIntervalExpired(int64_t current_time);

7
core/include/properties.h
View File

@@ -53,9 +53,10 @@ class Properties {
static bool GetFactoryKeyboxPath(std::string* keybox);
static bool GetOEMCryptoPath(std::string* library_name);
static bool GetSecurityLevelDirectories(std::vector<std::string>* dirs);
static const std::string GetSecurityLevel(const CdmSessionId& session_id);
static const std::vector<uint8_t> GetServiceCertificate(
const CdmSessionId& session_id);
static bool GetSecurityLevel(const CdmSessionId& session_id,
std::string* security_level);
static bool GetServiceCertificate(const CdmSessionId& session_id,
std::string* service_certificate);
static bool UsePrivacyMode(const CdmSessionId& session_id);
static uint32_t GetSessionSharingId(const CdmSessionId& session_id);

5
core/include/wv_cdm_types.h
View File

@@ -28,11 +28,6 @@ typedef std::string CdmUsageInfoReleaseMessage;
typedef std::string CdmProvisioningRequest;
typedef std::string CdmProvisioningResponse;
// Types for shared host/cdm interface pairs used to shared vendor data.
typedef std::pair<std::string, std::string> StringPairs;
typedef std::vector<uint8_t> VectorBytes;
typedef std::pair<std::string, VectorBytes> VectorPairs;
enum CdmResponseType {
NO_ERROR,
UNKNOWN_ERROR,

11
core/src/cdm_session.cpp
View File

@@ -33,6 +33,7 @@ CdmSession::CdmSession(const CdmClientPropertySet* cdm_client_property_set)
is_offline_(false),
is_release_(false),
is_usage_update_needed_(false),
is_initial_decryption_(true),
is_certificate_loaded_(false) {
if (cdm_client_property_set) {
Properties::AddSessionPropertySet(session_id_, cdm_client_property_set);
@@ -64,6 +65,7 @@ CdmResponseType CdmSession::Init() {
crypto_session_.reset(session.release());
license_received_ = false;
reinitialize_session_ = false;
is_initial_decryption_ = true;
return NO_ERROR;
}
@@ -313,6 +315,10 @@ CdmResponseType CdmSession::Decrypt(const CdmDecryptionParameters& params) {
CdmResponseType status = crypto_session_->Decrypt(params);
if (NO_ERROR == status) {
if (is_initial_decryption_) {
policy_engine_.BeginDecryption();
is_initial_decryption_ = false;
}
if (!is_usage_update_needed_) {
is_usage_update_needed_ =
!license_parser_.provider_session_token().empty();
@@ -515,8 +521,9 @@ void CdmSession::OnKeyReleaseEvent(const CdmKeySetId& key_set_id) {
}
SecurityLevel CdmSession::GetRequestedSecurityLevel() {
if (Properties::GetSecurityLevel(session_id_)
.compare(QUERY_VALUE_SECURITY_LEVEL_L3) == 0) {
std::string security_level;
if (Properties::GetSecurityLevel(session_id_, &security_level) &&
security_level == QUERY_VALUE_SECURITY_LEVEL_L3) {
return kLevel3;
}

8
core/src/license.cpp
View File

@@ -193,10 +193,10 @@ bool CdmLicense::PrepareKeyRequest(const InitializationData& init_data,
}
bool privacy_mode_enabled = Properties::UsePrivacyMode(session_id);
std::vector<uint8_t> cert = Properties::GetServiceCertificate(session_id);
std::string serialized_service_certificate(cert.begin(), cert.end());
if (serialized_service_certificate.empty())
std::string serialized_service_certificate;
if (!Properties::GetServiceCertificate(session_id,
&serialized_service_certificate) ||
serialized_service_certificate.empty())
serialized_service_certificate = service_certificate_;
if (privacy_mode_enabled && serialized_service_certificate.empty()) {

70
core/src/policy_engine.cpp
View File

@@ -2,16 +2,16 @@
#include "policy_engine.h"
#include <algorithm>
#include <map>
#include <limits.h>
#include <sstream>
#include <string>
#include <vector>
#include "clock.h"
#include "log.h"
#include "properties.h"
#include "string_conversions.h"
#include "clock.h"
#include "wv_cdm_constants.h"
namespace wvcdm {
@@ -59,7 +59,6 @@ void PolicyEngine::OnTimerEvent(bool* event_occurred, CdmEventType* event) {
// Test to determine if renewal should be attempted.
switch (license_state_) {
case kLicenseStateInitialPendingUsage:
case kLicenseStateCanPlay: {
if (IsRenewalDelayExpired(current_time))
renewal_needed = true;
@@ -115,11 +114,6 @@ void PolicyEngine::UpdateLicense(
policy_.MergeFrom(license.policy());
if (!policy_.can_play()) {
license_state_ = kLicenseStateExpired;
return;
}
// some basic license validation
if (license_state_ == kLicenseStateInitial) {
// license start time needs to be present in the initial response
@@ -158,20 +152,23 @@ void PolicyEngine::UpdateLicense(
policy_max_duration_seconds_ = policy_.license_duration_seconds();
}
if (!policy_.can_play()) {
license_state_ = kLicenseStateExpired;
return;
}
if (IsLicenseDurationExpired(current_time)) return;
if (IsPlaybackDurationExpired(current_time)) return;
// Update state
if (license_state_ == kLicenseStateInitial) {
license_state_ = kLicenseStateInitialPendingUsage;
}
else {
license_state_ = kLicenseStateCanPlay;
can_decrypt_ = true;
}
license_state_ = kLicenseStateCanPlay;
can_decrypt_ = true;
}
void PolicyEngine::BeginDecryption() {
if (playback_start_time_ == 0) {
switch (license_state_) {
case kLicenseStateInitialPendingUsage:
case kLicenseStateCanPlay:
case kLicenseStateNeedRenewal:
case kLicenseStateWaitingLicenseUpdate:
playback_start_time_ = clock_->GetCurrentTime();
@@ -179,12 +176,7 @@ void PolicyEngine::BeginDecryption() {
if (policy_.renew_with_usage()) {
license_state_ = kLicenseStateNeedRenewal;
}
else {
license_state_ = kLicenseStateCanPlay;
can_decrypt_ = true;
}
break;
case kLicenseStateCanPlay:
case kLicenseStateInitial:
case kLicenseStateExpired:
default:
@@ -209,17 +201,10 @@ CdmResponseType PolicyEngine::Query(CdmQueryMap* key_info) {
QUERY_VALUE_TRUE : QUERY_VALUE_FALSE;
(*key_info)[QUERY_KEY_RENEW_ALLOWED] = policy_.can_renew() ?
QUERY_VALUE_TRUE : QUERY_VALUE_FALSE;
int64_t remaining_time = policy_max_duration_seconds_ +
license_received_time_ - current_time;
if (remaining_time < 0)
remaining_time = 0;
ss << remaining_time;
ss << GetLicenseDurationRemaining(current_time);
(*key_info)[QUERY_KEY_LICENSE_DURATION_REMAINING] = ss.str();
remaining_time = policy_.playback_duration_seconds() + playback_start_time_ -
current_time;
if (remaining_time < 0)
remaining_time = 0;
ss << remaining_time;
ss.str("");
ss << GetPlaybackDurationRemaining(current_time);
(*key_info)[QUERY_KEY_PLAYBACK_DURATION_REMAINING] = ss.str();
(*key_info)[QUERY_KEY_RENEWAL_SERVER_URL] = policy_.renewal_server_url();
@@ -240,6 +225,16 @@ bool PolicyEngine::IsLicenseDurationExpired(int64_t current_time) {
current_time;
}
int64_t PolicyEngine::GetLicenseDurationRemaining(int64_t current_time) {
if (0 == policy_max_duration_seconds_) return LLONG_MAX;
int64_t remaining_time = policy_max_duration_seconds_
+ license_received_time_ - current_time;
if (remaining_time < 0) remaining_time = 0;
return remaining_time;
}
bool PolicyEngine::IsPlaybackDurationExpired(int64_t current_time) {
return (policy_.playback_duration_seconds() > 0) &&
playback_start_time_ &&
@@ -247,6 +242,17 @@ bool PolicyEngine::IsPlaybackDurationExpired(int64_t current_time) {
current_time;
}
int64_t PolicyEngine::GetPlaybackDurationRemaining(int64_t current_time) {
if (0 == policy_.playback_duration_seconds()) return LLONG_MAX;
if (0 == playback_start_time_) return policy_.playback_duration_seconds();
int64_t remaining_time = policy_.playback_duration_seconds()
+ playback_start_time_ - current_time;
if (remaining_time < 0) remaining_time = 0;
return remaining_time;
}
bool PolicyEngine::IsRenewalDelayExpired(int64_t current_time) {
return policy_.can_renew() &&
(policy_.renewal_delay_seconds() > 0) &&

17
core/src/properties.cpp
View File

@@ -60,27 +60,30 @@ const CdmClientPropertySet* Properties::GetCdmClientPropertySet(
return NULL;
}
const std::string Properties::GetSecurityLevel(const CdmSessionId& session_id) {
bool Properties::GetSecurityLevel(const CdmSessionId& session_id,
std::string* security_level) {
const CdmClientPropertySet* property_set =
GetCdmClientPropertySet(session_id);
if (NULL == property_set) {
LOGE("Properties::GetSecurityLevel: cannot find property set for %s",
session_id.c_str());
return "";
return false;
}
return property_set->security_level();
*security_level = property_set->security_level();
return true;
}
const std::vector<uint8_t> Properties::GetServiceCertificate(
const CdmSessionId& session_id) {
bool Properties::GetServiceCertificate(const CdmSessionId& session_id,
std::string* service_certificate) {
const CdmClientPropertySet* property_set =
GetCdmClientPropertySet(session_id);
if (NULL == property_set) {
LOGE("Properties::GetServiceCertificate: cannot find property set for %s",
session_id.c_str());
return std::vector<uint8_t>();
return false;
}
return property_set->service_certificate();
*service_certificate = property_set->service_certificate();
return true;
}
bool Properties::UsePrivacyMode(const CdmSessionId& session_id) {

21
core/test/cdm_engine_test.cpp
View File

@@ -34,7 +34,6 @@ wvcdm::KeyId g_key_id_unwrapped;
wvcdm::CdmKeySystem g_key_system;
std::string g_license_server;
wvcdm::KeyId g_wrong_key_id;
int g_use_full_path = 0; // cannot use boolean in getopt_long
// This is an RSA certificate message from the provisioning server.
// The client sends this certificate to a license server for device
@@ -257,17 +256,14 @@ int main(int argc, char **argv) {
int show_usage = 0;
static const struct option long_options[] = {
{ "use_full_path", no_argument, &g_use_full_path, 0 },
{ "keyid", required_argument, NULL, 'k' },
{ "server", required_argument, NULL, 's' },
{ "vmodule", required_argument, NULL, 0 },
{ "v", required_argument, NULL, 0 },
{ NULL, 0, NULL, '\0' }
};
int option_index = 0;
int opt = 0;
while ((opt = getopt_long(argc, argv, "k:p:s:u", long_options, &option_index)) != -1) {
while ((opt = getopt_long(argc, argv, "k:s:v", long_options, &option_index)) != -1) {
switch (opt) {
case 'k': {
g_key_id_pssh.clear();
@@ -279,8 +275,15 @@ int main(int argc, char **argv) {
g_license_server.assign(optarg);
break;
}
case 'u': {
g_use_full_path = 1;
case 'v': {
// This option _may_ have already been consumed by wvcdm::InitLogging()
// above, depending on the platform-specific logging implementation.
// We only tell getopt about it so that it is not an error. We ignore
// the option here when seen.
// TODO: Stop passing argv to InitLogging, and instead set the log
// level here through the logging API. We should keep all command-line
// parsing at the application level, rather than split between various
// apps and various platform-specific logging implementations.
break;
}
case '?': {
@@ -305,10 +308,6 @@ int main(int argc, char **argv) {
std::cout << "configure the key id or pssh, in hex format" << std::endl;
std::cout << std::setw(30) << std::left << " default keyid:";
std::cout << g_key_id_pssh << std::endl;
std::cout << std::setw(30) << std::left << " --use_full_path";
std::cout << "specify server url is not a proxy server" << std::endl;
std::cout << std::endl;
return 0;
}

92
core/test/config_test_env.cpp
View File

@@ -5,36 +5,33 @@
namespace {
const std::string kWidevineKeySystem = "com.widevine.alpha";
// Youtube Content Protection license server data
const std::string kYtCpLicenseServer =
// Content Protection license server data
const std::string kCpLicenseServer =
"http://wv-ref-eme-player.appspot.com/proxy";
const std::string kYtCpClientAuth = "";
const std::string kYtCpKeyId =
"000000427073736800000000" // blob size and pssh
"EDEF8BA979D64ACEA3C827DCD51D21ED00000022" // Widevine system id
"08011a0d7769646576696e655f7465737422" // pssh data (streaming)
"0f73747265616d696e675f636c697031";
const std::string kYtCpOfflineKeyId =
"000000407073736800000000" // blob size and pssh
"EDEF8BA979D64ACEA3C827DCD51D21ED00000020" // Widevine system id
"08011a0d7769646576696e655f7465737422" //pssh data (offline)
"0d6f66666c696e655f636c697031";
// Youtube license server data
const std::string kYtLicenseServer =
"https://www.youtube.com/api/drm/"
"widevine?video_id=03681262dc412c06&source=YOUTUBE";
const std::string kYtClientAuth = "";
const std::string kYtKeyId =
"000000347073736800000000" // blob size and pssh
"EDEF8BA979D64ACEA3C827DCD51D21ED00000014" // Widevine system id
"0801121093789920E8D6520098577DF8F2DD5546"; // pssh data
const std::string kCpClientAuth = "";
const std::string kCpKeyId =
"00000042" // blob size
"70737368" // "pssh"
"00000000" // flags
"edef8ba979d64acea3c827dcd51d21ed" // Widevine system id
"00000022" // pssh data size
// pssh data:
"08011a0d7769646576696e655f746573"
"74220f73747265616d696e675f636c69"
"7031";
const std::string kCpOfflineKeyId =
"00000040" // blob size
"70737368" // "pssh"
"00000000" // flags
"edef8ba979d64acea3c827dcd51d21ed" // Widevine system id
"00000020" // pssh data size
// pssh data:
"08011a0d7769646576696e655f746573"
"74220d6f66666c696e655f636c697031";
// Google Play license server data
const std::string kGpLicenseServer =
"https://jmt17.google.com/video/license/GetCencLicense";
// Test client authorization string.
// NOTE: Append a userdata attribute to place a unique marker that the
// server team can use to track down specific requests during debugging
@@ -42,6 +39,16 @@ const std::string kGpLicenseServer =
// "<existing-client-auth-string>&userdata=jbmr2.dev"
const std::string kGpClientAuth =
"?source=YOUTUBE&video_id=EGHC6OHNbOo&oauth=ya.gtsqawidevine";
const std::string kGpKeyId =
"00000034" // blob size
"70737368" // "pssh"
"00000000" // flags
"edef8ba979d64acea3c827dcd51d21ed" // Widevine system id
"00000014" // pssh data size
// pssh data:
"08011210e02562e04cd55351b14b3d74"
"8d36ed8e";
const std::string kGpOfflineKeyId = kGpKeyId;
const std::string kGpClientOfflineQueryParameters =
"&offline=true";
@@ -50,16 +57,16 @@ const std::string kGpClientOfflineRenewalQueryParameters =
const std::string kGpClientOfflineReleaseQueryParameters =
"&offline=true&release=true";
const std::string kGpKeyId =
"000000347073736800000000" // blob size and pssh
"edef8ba979d64acea3c827dcd51d21ed00000014" // Widevine system id
"08011210e02562e04cd55351b14b3d748d36ed8e"; // pssh data
// An invalid key id, expected to fail
const std::string kWrongKeyId =
"000000347073736800000000" // blob size and pssh
"EDEF8BA979D64ACEA3C827DCD51D21ED00000014" // Widevine system id
"0901121094889920E8D6520098577DF8F2DD5546"; // pssh data
"00000034" // blob size
"70737368" // "pssh"
"00000000" // flags
"edef8ba979d64acea3c827dcd51d21ed" // Widevine system id
"00000014" // pssh data size
// pssh data:
"0901121094889920e8d6520098577df8"
"f2dd5546";
// URL of provisioning server (returned by GetProvisioningRequest())
const std::string kProductionProvisioningServerUrl =
@@ -67,22 +74,13 @@ const std::string kProductionProvisioningServerUrl =
"certificateprovisioning/v1/devicecertificates/create"
"?key=AIzaSyB-5OLKTx2iU5mko18DfdwK5611JIjbUhE";
// Return production-rooted certificates that have test bit set,
// request_license_test uses this url.
const std::string kProductionTestProvisioningServerUrl =
"https://www.googleapis.com/"
"certificateprovisioning/v1exttest/devicecertificates/create"
"?key=AIzaSyB-5OLKTx2iU5mko18DfdwK5611JIjbUhE";
const std::string kServerSdkLicenseServer =
"http://kir03fcpg174.widevine.net/widevine/cgi-bin/drm.cgi";
const wvcdm::ConfigTestEnv::LicenseServerConfiguration license_servers[] = {
{ wvcdm::kGooglePlayServer, kGpLicenseServer, kGpClientAuth, kGpKeyId,
kGpKeyId },
{ wvcdm::kYouTubeContentProtectionServer, kYtCpLicenseServer,
kYtCpClientAuth, kYtCpKeyId, kYtCpOfflineKeyId }
{ wvcdm::kGooglePlayServer, kGpLicenseServer,
kGpClientAuth, kGpKeyId, kGpOfflineKeyId },
{ wvcdm::kContentProtectionServer, kCpLicenseServer,
kCpClientAuth, kCpKeyId, kCpOfflineKeyId },
};
} // namespace
namespace wvcdm {

2
core/test/config_test_env.h
View File

@@ -9,7 +9,7 @@
namespace wvcdm {
typedef enum {
kGooglePlayServer,
kYouTubeContentProtectionServer
kContentProtectionServer,
} LicenseServerId;
// Configures default test environment.

1002
core/test/policy_engine_unittest.cpp
View File

File diff suppressed because it is too large Load Diff

15
linux/src/log.cpp
View File

@@ -1,13 +1,12 @@
// Copyright 2013 Google Inc. All Rights Reserved.
//
// Log - implemented using stdout.
//
#define LOG_BUF_SIZE 4096
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "log.h"
namespace wvcdm {
@@ -35,13 +34,13 @@ void Log(const char* file, int line, LogPriority level, const char* fmt, ...) {
}
if (level > g_cutoff) return;
va_list ap;
char buf[LOG_BUF_SIZE];
va_start(ap, fmt);
vsnprintf(buf, LOG_BUF_SIZE, fmt, ap);
va_end(ap);
printf("[%s:%s(%d)] ", severities[level], file, line);
fputs(buf, stdout);
va_list ap;
va_start(ap, fmt);
vprintf(fmt, ap);
va_end(ap);
putc('\n', stdout);
}

6
oemcrypto/include/OEMCryptoCENC.h
View File

@@ -9,9 +9,9 @@
#ifndef OEMCRYPTO_CENC_H_
#define OEMCRYPTO_CENC_H_
#include<stdbool.h>
#include<stddef.h>
#include<stdint.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#ifdef __cplusplus
extern "C" {

1
platforms/global_config.gypi
View File

@@ -11,6 +11,7 @@
'product_name%': '"UndefinedProductName"',
'buildinfo_data%': '"UndefinedBuildInfo"',
'oemcrypto_target%': '../oemcrypto/mock/oec_mock.gyp:oec_mock',
'oemcrypto_v8%': 'false',
'protobuf_source_dir%': '',
'use_system_protobuf%': 'true',
'protoc_dir%': '/usr/bin',

2
third_party/protobuf.gyp vendored
View File

@@ -52,6 +52,7 @@
'target_name': 'protobuf',
'type': 'static_library',
'toolsets': ['host'],
'includes': ['xcode_host.gypi'], # xcode workaround
'sources': [
'<@(protobuf_lite_sources)',
@@ -89,6 +90,7 @@
'target_name': 'protoc',
'type': 'executable',
'toolsets': ['host'],
'includes': ['xcode_host.gypi'], # xcode workaround
'sources': [
'<(protobuf_source_dir)/src/google/protobuf/compiler/code_generator.cc',
'<(protobuf_source_dir)/src/google/protobuf/compiler/command_line_interface.cc',

15
third_party/xcode_host.gypi vendored Normal file
View File

@@ -0,0 +1,15 @@
# Copyright 2014 Google Inc. All Rights Reserved.
# Since the Xcode generator for gyp doesn't support host targets,
# the workaround is to add a special xcode_settings section to any
# target that must be built for the host. This file encapsulates
# those settings such that they can be included into any target.
{
'xcode_settings': {
'VALID_ARCHS': 'i386 x86_64',
'IPHONEOS_DEPLOYMENT_TARGET': '',
'TARGETED_DEVICE_FAMILY': '',
'SDKROOT': '',
},
}