gugelfrei
/
android_frameworks_av
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge "Add support for KEY_TYPE_RELEASE for clearkey plugin."

Browse Source
gugelfrei
TreeHugger Robot 6 years ago committed by Android (Google) Code Review
parent f9d217fa52 c895ed3083
commit 344d6dbbab
8 changed files with 74 additions and 41 deletions
Show Stats Download Patch File Download Diff File

9
drm/mediadrm/plugins/clearkey/hidl/DeviceFiles.cpp
Unescape View File

@ -57,6 +57,7 @@ bool DeviceFiles::StoreLicense(
break;
case kLicenseStateReleasing:
license->set_state(License_LicenseState_RELEASING);
license->set_license(licenseResponse);
break;
default:
ALOGW("StoreLicense: Unknown license state: %u", state);
@ -106,8 +107,8 @@ bool DeviceFiles::StoreFileRaw(const std::string& fileName, const std::string& s
bool DeviceFiles::RetrieveLicense(
const std::string& keySetId, LicenseState* state, std::string* offlineLicense) {
OfflineFile file;
OfflineFile file;
if (!RetrieveHashedFile(keySetId + kLicenseFileNameExt, &file)) {
return false;
}
@ -128,7 +129,6 @@ bool DeviceFiles::RetrieveLicense(
}
License license = file.license();
switch (license.state()) {
case License_LicenseState_ACTIVE:
*state = kLicenseStateActive;
@ -142,11 +142,14 @@ bool DeviceFiles::RetrieveLicense(
*state = kLicenseStateUnknown;
break;
}
*offlineLicense = license.license();
return true;
}
bool DeviceFiles::DeleteLicense(const std::string& keySetId) {
return mFileHandle.RemoveFile(keySetId + kLicenseFileNameExt);
}
bool DeviceFiles::DeleteAllLicenses() {
return mFileHandle.RemoveAllFiles();
}

83
drm/mediadrm/plugins/clearkey/hidl/DrmPlugin.cpp
Unescape View File

@ -70,6 +70,7 @@ DrmPlugin::DrmPlugin(SessionLibrary* sessionLibrary)
mPlayPolicy.clear();
initProperties();
mSecureStops.clear();
mReleaseKeysMap.clear();
std::srand(std::time(nullptr));
}
@ -155,7 +156,7 @@ Status DrmPlugin::getKeyRequestCommon(const hidl_vec<uint8_t>& scope,
// GetKeyRequestOfflineKeyTypeNotSupported() in vts 1.0 and 1.1 expects
// KeyType::OFFLINE to return ERROR_DRM_CANNOT_HANDLE in clearkey plugin.
// Those tests pass in an empty initData, we use the empty initData to
// signal the specific use case.
// signal such specific use case.
if (keyType == KeyType::OFFLINE && 0 == initData.size()) {
return Status::ERROR_DRM_CANNOT_HANDLE;
}
@ -196,6 +197,14 @@ Status DrmPlugin::getKeyRequestCommon(const hidl_vec<uint8_t>& scope,
ALOGE("Problem releasing offline license");
return Status::ERROR_DRM_UNKNOWN;
}
if (mReleaseKeysMap.find(keySetIdString) == mReleaseKeysMap.end()) {
sp<Session> session = mSessionLibrary->createSession();
mReleaseKeysMap[keySetIdString] = session->sessionId();
} else {
ALOGI("key is in use, ignore release request");
}
} else {
ALOGE("Offline license not found, nothing to release");
}
*keyRequestType = KeyRequestType::RELEASE;
}
@ -305,25 +314,35 @@ Return<void> DrmPlugin::provideKeyResponse(
bool isRelease = (memcmp(scopeId.data(), kKeySetIdPrefix.data(), kKeySetIdPrefix.size()) == 0);
if (isRelease) {
keySetId.assign(scopeId.begin(), scopeId.end());
auto iter = mReleaseKeysMap.find(std::string(keySetId.begin(), keySetId.end()));
if (iter != mReleaseKeysMap.end()) {
sessionId.assign(iter->second.begin(), iter->second.end());
}
} else {
sessionId.assign(scopeId.begin(), scopeId.end());
sp<Session> session = mSessionLibrary->findSession(sessionId);
if (!session.get()) {
_hidl_cb(Status::ERROR_DRM_SESSION_NOT_OPENED, hidl_vec<uint8_t>());
return Void();
}
setPlayPolicy();
// non offline license returns empty keySetId
keySetId.clear();
}
status = session->provideKeyResponse(response);
if (status == Status::OK) {
if (isOfflineLicense) {
sp<Session> session = mSessionLibrary->findSession(sessionId);
if (!session.get()) {
_hidl_cb(Status::ERROR_DRM_SESSION_NOT_OPENED, hidl_vec<uint8_t>());
return Void();
}
setPlayPolicy();
status = session->provideKeyResponse(response);
if (status == Status::OK) {
if (isOfflineLicense) {
if (isRelease) {
mFileHandle.DeleteLicense(keySetId);
} else {
if (!makeKeySetId(&keySetId)) {
_hidl_cb(Status::ERROR_DRM_UNKNOWN, hidl_vec<uint8_t>());
return Void();
}
bool ok = mFileHandle.StoreLicense(
keySetId,
DeviceFiles::kLicenseStateActive,
@ -332,32 +351,32 @@ Return<void> DrmPlugin::provideKeyResponse(
ALOGE("Failed to store offline license");
}
}
}
// Test calling AMediaDrm listeners.
sendEvent(EventType::VENDOR_DEFINED, sessionId, sessionId);
// Test calling AMediaDrm listeners.
sendEvent(EventType::VENDOR_DEFINED, sessionId, sessionId);
sendExpirationUpdate(sessionId, 100);
sendExpirationUpdate(sessionId, 100);
std::vector<KeyStatus> keysStatus;
KeyStatus keyStatus;
std::vector<KeyStatus> keysStatus;
KeyStatus keyStatus;
std::vector<uint8_t> keyId1 = { 0xA, 0xB, 0xC };
keyStatus.keyId = keyId1;
keyStatus.type = V1_0::KeyStatusType::USABLE;
keysStatus.push_back(keyStatus);
std::vector<uint8_t> keyId1 = { 0xA, 0xB, 0xC };
keyStatus.keyId = keyId1;
keyStatus.type = V1_0::KeyStatusType::USABLE;
keysStatus.push_back(keyStatus);
std::vector<uint8_t> keyId2 = { 0xD, 0xE, 0xF };
keyStatus.keyId = keyId2;
keyStatus.type = V1_0::KeyStatusType::EXPIRED;
keysStatus.push_back(keyStatus);
std::vector<uint8_t> keyId2 = { 0xD, 0xE, 0xF };
keyStatus.keyId = keyId2;
keyStatus.type = V1_0::KeyStatusType::EXPIRED;
keysStatus.push_back(keyStatus);
sendKeysChange(sessionId, keysStatus, true);
sendKeysChange(sessionId, keysStatus, true);
installSecureStop(sessionId);
} else {
ALOGE("Failed to add key, error=%d", status);
}
} // keyType::STREAMING || keyType::OFFLINE
installSecureStop(sessionId);
} else {
ALOGE("provideKeyResponse returns error=%d", status);
}
std::vector<uint8_t> keySetIdVec(keySetId.begin(), keySetId.end());
_hidl_cb(status, toHidlVec(keySetIdVec));
@ -371,10 +390,10 @@ Return<Status> DrmPlugin::restoreKeys(
}
DeviceFiles::LicenseState licenseState;
std::string keySetIdString(keySetId.begin(), keySetId.end());
std::string offlineLicense;
Status status = Status::OK;
if (!mFileHandle.RetrieveLicense(keySetIdString, &licenseState, &offlineLicense)) {
if (!mFileHandle.RetrieveLicense(std::string(keySetId.begin(), keySetId.end()),
&licenseState, &offlineLicense)) {
ALOGE("Failed to restore offline license");
return Status::ERROR_DRM_NO_LICENSE;
}

3
drm/mediadrm/plugins/clearkey/hidl/InitDataParser.cpp
Unescape View File

@ -156,7 +156,8 @@ std::string InitDataParser::generateRequest(V1_0::KeyType keyType,
}
if (keyType == V1_0::KeyType::STREAMING) {
request.append(kTemporarySession);
} else if (keyType == V1_0::KeyType::OFFLINE) {
} else if (keyType == V1_0::KeyType::OFFLINE ||
keyType == V1_0::KeyType::RELEASE) {
request.append(kPersistentSession);
}

5
drm/mediadrm/plugins/clearkey/hidl/MemoryFileSystem.cpp
Unescape View File

@ -3,7 +3,6 @@
// License Agreement.
#include <utils/Log.h>
#include <string>
#include "MemoryFileSystem.h"
@ -54,6 +53,10 @@ size_t MemoryFileSystem::Read(const std::string& path, std::string* buffer) {
size_t MemoryFileSystem::Write(const std::string& path, const MemoryFile& memoryFile) {
std::string key = GetFileName(path);
auto result = mMemoryFileSystem.find(key);
if (result != mMemoryFileSystem.end()) {
mMemoryFileSystem.erase(key);
}
mMemoryFileSystem.insert(std::pair<std::string, MemoryFile>(key, memoryFile));
return memoryFile.getFileSize();
}

6
drm/mediadrm/plugins/clearkey/hidl/SessionLibrary.cpp
Unescape View File

@ -59,7 +59,8 @@ sp<Session> SessionLibrary::createSession() {
mSessions.insert(std::pair<std::vector<uint8_t>,
sp<Session> >(sessionId, new Session(sessionId)));
std::map<std::vector<uint8_t>, sp<Session> >::iterator itr = mSessions.find(sessionId);
std::map<std::vector<uint8_t>, sp<Session> >::iterator itr =
mSessions.find(sessionId);
if (itr != mSessions.end()) {
return itr->second;
} else {
@ -70,7 +71,8 @@ sp<Session> SessionLibrary::createSession() {
sp<Session> SessionLibrary::findSession(
const std::vector<uint8_t>& sessionId) {
Mutex::Autolock lock(mSessionsLock);
std::map<std::vector<uint8_t>, sp<Session> >::iterator itr = mSessions.find(sessionId);
std::map<std::vector<uint8_t>, sp<Session> >::iterator itr =
mSessions.find(sessionId);
if (itr != mSessions.end()) {
return itr->second;
} else {

4
drm/mediadrm/plugins/clearkey/hidl/include/DeviceFiles.h
Unescape View File

@ -26,9 +26,9 @@ namespace clearkey {
class DeviceFiles {
public:
typedef enum {
kLicenseStateUnknown,
kLicenseStateActive,
kLicenseStateReleasing,
kLicenseStateUnknown,
} LicenseState;
DeviceFiles() {};
@ -42,6 +42,8 @@ class DeviceFiles {
virtual bool LicenseExists(const std::string& keySetId);
virtual bool DeleteLicense(const std::string& keySetId);
virtual bool DeleteAllLicenses();
private:

1
drm/mediadrm/plugins/clearkey/hidl/include/DrmPlugin.h
Unescape View File

@ -319,6 +319,7 @@ private:
std::vector<KeyValue> mPlayPolicy;
std::map<std::string, std::string> mStringProperties;
std::map<std::string, std::vector<uint8_t> > mByteArrayProperties;
std::map<std::string, std::vector<uint8_t> > mReleaseKeysMap;
std::map<std::vector<uint8_t>, SecurityLevel> mSecurityLevel;
sp<IDrmPluginListener> mListener;
SessionLibrary *mSessionLibrary;

4
drm/mediadrm/plugins/clearkey/hidl/include/MemoryFileSystem.h
Unescape View File

@ -32,7 +32,9 @@ class MemoryFileSystem {
size_t getFileSize() const { return fileSize; }
void setContent(const std::string& file) { content = file; }
void setFileName(const std::string& name) { fileName = name; }
void setFileSize(size_t size) { fileSize = size; }
void setFileSize(size_t size) {
content.resize(size); fileSize = size;
}
};
MemoryFileSystem() {};

Write Preview
Loading…
Cancel
Save