• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2021 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 //#define LOG_NDEBUG 0
18 #define LOG_TAG "DrmHalAidl"
19 
20 #include <array>
21 #include <algorithm>
22 #include <map>
23 #include <android/binder_auto_utils.h>
24 #include <android/binder_manager.h>
25 #include <media/PluginMetricsReporting.h>
26 #include <media/stagefright/foundation/ADebug.h>
27 #include <media/stagefright/foundation/AString.h>
28 #include <media/stagefright/foundation/base64.h>
29 #include <media/stagefright/foundation/hexdump.h>
30 #include <mediadrm/DrmHalAidl.h>
31 #include <mediadrm/DrmSessionManager.h>
32 #include <mediadrm/DrmUtils.h>
33 
34 using ::android::DrmUtils::statusAidlToStatusT;
35 using ::aidl::android::hardware::drm::CryptoSchemes;
36 using ::aidl::android::hardware::drm::DrmMetricNamedValue;
37 using ::aidl::android::hardware::drm::DrmMetricValue;
38 using ::aidl::android::hardware::drm::HdcpLevel;
39 using ::aidl::android::hardware::drm::HdcpLevels;
40 using ::aidl::android::hardware::drm::KeyRequest;
41 using ::aidl::android::hardware::drm::KeyRequestType;
42 using ::aidl::android::hardware::drm::KeySetId;
43 using ::aidl::android::hardware::drm::KeyStatus;
44 using ::aidl::android::hardware::drm::KeyStatusType;
45 using ::aidl::android::hardware::drm::KeyType;
46 using ::aidl::android::hardware::drm::KeyValue;
47 using ::aidl::android::hardware::drm::NumberOfSessions;
48 using ::aidl::android::hardware::drm::OfflineLicenseState;
49 using ::aidl::android::hardware::drm::OpaqueData;
50 using ::aidl::android::hardware::drm::ProvideProvisionResponseResult;
51 using ::aidl::android::hardware::drm::ProvisionRequest;
52 using ::aidl::android::hardware::drm::SecureStop;
53 using ::aidl::android::hardware::drm::SecureStopId;
54 using ::aidl::android::hardware::drm::SecurityLevel;
55 using ::aidl::android::hardware::drm::Status;
56 using ::aidl::android::hardware::drm::SupportedContentType;
57 using ::aidl::android::hardware::drm::Uuid;
58 using DrmMetricGroupAidl = ::aidl::android::hardware::drm::DrmMetricGroup;
59 using DrmMetricGroupHidl = ::android::hardware::drm::V1_1::DrmMetricGroup;
60 using DrmMetricAidl = ::aidl::android::hardware::drm::DrmMetric;
61 using DrmMetricHidl = ::android::hardware::drm::V1_1::DrmMetricGroup::Metric;
62 using ValueHidl = ::android::hardware::drm::V1_1::DrmMetricGroup::Value;
63 using AttributeHidl = ::android::hardware::drm::V1_1::DrmMetricGroup::Attribute;
64 using IDrmPluginAidl = ::aidl::android::hardware::drm::IDrmPlugin;
65 using EventTypeAidl = ::aidl::android::hardware::drm::EventType;
66 using ::android::hardware::hidl_vec;
67 
68 namespace {
69 
70 constexpr char kPropertyDeviceUniqueId[] = "deviceUniqueId";
71 constexpr char kEqualsSign[] = "=";
72 
73 template <typename T>
toBase64StringNoPad(const T * data,size_t size)74 std::string toBase64StringNoPad(const T* data, size_t size) {
75     // Note that the base 64 conversion only works with arrays of single-byte
76     // values. If the source is empty or is not an array of single-byte values,
77     // return empty string.
78     if (size == 0 || sizeof(data[0]) != 1) {
79         return "";
80     }
81 
82     android::AString outputString;
83     encodeBase64(data, size, &outputString);
84     // Remove trailing equals padding if it exists.
85     while (outputString.size() > 0 && outputString.endsWith(kEqualsSign)) {
86         outputString.erase(outputString.size() - 1, 1);
87     }
88 
89     return std::string(outputString.c_str(), outputString.size());
90 }
91 
92 }  // anonymous namespace
93 
94 namespace android {
95 
96 #define INIT_CHECK()                             \
97     {                                            \
98         if (mInitCheck != OK) return mInitCheck; \
99     }
100 
101 template <typename Byte = uint8_t>
toStdVec(const Vector<uint8_t> & vector)102 static std::vector<Byte> toStdVec(const Vector<uint8_t>& vector) {
103     auto v = reinterpret_cast<const Byte*>(vector.array());
104     std::vector<Byte> vec(v, v + vector.size());
105     return vec;
106 }
107 
toVector(const std::vector<uint8_t> & vec)108 static const Vector<uint8_t> toVector(const std::vector<uint8_t>& vec) {
109     Vector<uint8_t> vector;
110     vector.appendArray(vec.data(), vec.size());
111     return *const_cast<const Vector<uint8_t>*>(&vector);
112 }
113 
toString8(const std::string & string)114 static String8 toString8(const std::string& string) {
115     return String8(string.c_str());
116 }
117 
toStdString(const String8 & string8)118 static std::string toStdString(const String8& string8) {
119     return std::string(string8.string());
120 }
121 
toKeyValueVector(const KeyedVector<String8,String8> & keyedVector)122 static std::vector<KeyValue> toKeyValueVector(const KeyedVector<String8, String8>& keyedVector) {
123     std::vector<KeyValue> stdKeyedVector;
124     for (size_t i = 0; i < keyedVector.size(); i++) {
125         KeyValue keyValue;
126         keyValue.key = toStdString(keyedVector.keyAt(i));
127         keyValue.value = toStdString(keyedVector.valueAt(i));
128         stdKeyedVector.push_back(keyValue);
129     }
130     return stdKeyedVector;
131 }
132 
toKeyedVector(const std::vector<KeyValue> & keyValueVec)133 static KeyedVector<String8, String8> toKeyedVector(const std::vector<KeyValue>& keyValueVec) {
134     KeyedVector<String8, String8> keyedVector;
135     for (size_t i = 0; i < keyValueVec.size(); i++) {
136         keyedVector.add(toString8(keyValueVec[i].key), toString8(keyValueVec[i].value));
137     }
138     return keyedVector;
139 }
140 
toKeyRequestType(KeyRequestType keyRequestType)141 static DrmPlugin::KeyRequestType toKeyRequestType(KeyRequestType keyRequestType) {
142     switch (keyRequestType) {
143         case KeyRequestType::INITIAL:
144             return DrmPlugin::kKeyRequestType_Initial;
145             break;
146         case KeyRequestType::RENEWAL:
147             return DrmPlugin::kKeyRequestType_Renewal;
148             break;
149         case KeyRequestType::RELEASE:
150             return DrmPlugin::kKeyRequestType_Release;
151             break;
152         case KeyRequestType::NONE:
153             return DrmPlugin::kKeyRequestType_None;
154             break;
155         case KeyRequestType::UPDATE:
156             return DrmPlugin::kKeyRequestType_Update;
157             break;
158         default:
159             return DrmPlugin::kKeyRequestType_Unknown;
160             break;
161     }
162 }
163 
toSecureStops(const std::vector<SecureStop> & aSecureStops)164 static List<Vector<uint8_t>> toSecureStops(const std::vector<SecureStop>& aSecureStops) {
165     List<Vector<uint8_t>> secureStops;
166     for (size_t i = 0; i < aSecureStops.size(); i++) {
167         secureStops.push_back(toVector(aSecureStops[i].opaqueData));
168     }
169     return secureStops;
170 }
171 
toSecureStopIds(const std::vector<SecureStopId> & aSecureStopIds)172 static List<Vector<uint8_t>> toSecureStopIds(const std::vector<SecureStopId>& aSecureStopIds) {
173     List<Vector<uint8_t>> secureStopIds;
174     for (size_t i = 0; i < aSecureStopIds.size(); i++) {
175         secureStopIds.push_back(toVector(aSecureStopIds[i].secureStopId));
176     }
177     return secureStopIds;
178 }
179 
toHdcpLevel(HdcpLevel level)180 static DrmPlugin::HdcpLevel toHdcpLevel(HdcpLevel level) {
181     switch (level) {
182         case HdcpLevel::HDCP_NONE:
183             return DrmPlugin::kHdcpNone;
184         case HdcpLevel::HDCP_V1:
185             return DrmPlugin::kHdcpV1;
186         case HdcpLevel::HDCP_V2:
187             return DrmPlugin::kHdcpV2;
188         case HdcpLevel::HDCP_V2_1:
189             return DrmPlugin::kHdcpV2_1;
190         case HdcpLevel::HDCP_V2_2:
191             return DrmPlugin::kHdcpV2_2;
192         case HdcpLevel::HDCP_V2_3:
193             return DrmPlugin::kHdcpV2_3;
194         case HdcpLevel::HDCP_NO_OUTPUT:
195             return DrmPlugin::kHdcpNoOutput;
196         default:
197             return DrmPlugin::kHdcpLevelUnknown;
198     }
199 }
200 
toSecurityLevel(SecurityLevel level)201 static DrmPlugin::SecurityLevel toSecurityLevel(SecurityLevel level) {
202     switch (level) {
203         case SecurityLevel::SW_SECURE_CRYPTO:
204             return DrmPlugin::kSecurityLevelSwSecureCrypto;
205         case SecurityLevel::SW_SECURE_DECODE:
206             return DrmPlugin::kSecurityLevelSwSecureDecode;
207         case SecurityLevel::HW_SECURE_CRYPTO:
208             return DrmPlugin::kSecurityLevelHwSecureCrypto;
209         case SecurityLevel::HW_SECURE_DECODE:
210             return DrmPlugin::kSecurityLevelHwSecureDecode;
211         case SecurityLevel::HW_SECURE_ALL:
212             return DrmPlugin::kSecurityLevelHwSecureAll;
213         case SecurityLevel::DEFAULT:
214             return DrmPlugin::kSecurityLevelMax;
215         default:
216             return DrmPlugin::kSecurityLevelUnknown;
217     }
218 }
219 
toAidlSecurityLevel(DrmPlugin::SecurityLevel level)220 static SecurityLevel toAidlSecurityLevel(DrmPlugin::SecurityLevel level) {
221     switch (level) {
222         case DrmPlugin::kSecurityLevelSwSecureCrypto:
223             return SecurityLevel::SW_SECURE_CRYPTO;
224         case DrmPlugin::kSecurityLevelSwSecureDecode:
225             return SecurityLevel::SW_SECURE_DECODE;
226         case DrmPlugin::kSecurityLevelHwSecureCrypto:
227             return SecurityLevel::HW_SECURE_CRYPTO;
228         case DrmPlugin::kSecurityLevelHwSecureDecode:
229             return SecurityLevel::HW_SECURE_DECODE;
230         case DrmPlugin::kSecurityLevelHwSecureAll:
231             return SecurityLevel::HW_SECURE_ALL;
232         case DrmPlugin::kSecurityLevelMax:
233             return SecurityLevel::DEFAULT;
234         default:
235             return SecurityLevel::UNKNOWN;
236     }
237 }
238 
toKeySetIds(const std::vector<KeySetId> & hKeySetIds)239 static List<Vector<uint8_t>> toKeySetIds(const std::vector<KeySetId>& hKeySetIds) {
240     List<Vector<uint8_t>> keySetIds;
241     for (size_t i = 0; i < hKeySetIds.size(); i++) {
242         keySetIds.push_back(toVector(hKeySetIds[i].keySetId));
243     }
244     return keySetIds;
245 }
246 
toHidlVec(const Vector<uint8_t> & vector)247 static hidl_vec<uint8_t> toHidlVec(const Vector<uint8_t>& vector) {
248     hidl_vec<uint8_t> vec;
249     vec.setToExternal(const_cast<uint8_t*>(vector.array()), vector.size());
250     return vec;
251 }
252 
toOfflineLicenseState(OfflineLicenseState licenseState)253 static DrmPlugin::OfflineLicenseState toOfflineLicenseState(OfflineLicenseState licenseState) {
254     switch (licenseState) {
255         case OfflineLicenseState::USABLE:
256             return DrmPlugin::kOfflineLicenseStateUsable;
257         case OfflineLicenseState::INACTIVE:
258             return DrmPlugin::kOfflineLicenseStateReleased;
259         default:
260             return DrmPlugin::kOfflineLicenseStateUnknown;
261     }
262 }
263 
264 Mutex DrmHalAidl::mLock;
265 
toDrmMetricGroupHidl(std::vector<DrmMetricGroupAidl> result)266 static hidl_vec<DrmMetricGroupHidl> toDrmMetricGroupHidl(std::vector<DrmMetricGroupAidl> result) {
267     std::vector<DrmMetricGroupHidl> resultHidl;
268     for (auto r : result) {
269         DrmMetricGroupHidl re;
270         std::vector<DrmMetricHidl> tmpMetric;
271         for (auto m : r.metrics) {
272             DrmMetricHidl me;
273             me.name = m.name;
274             std::vector<AttributeHidl> aTmp;
275             for (auto attr : m.attributes) {
276                 AttributeHidl attrHidl;
277                 attrHidl.name = attr.name;
278 
279                 switch (attr.value.getTag()) {
280                     case DrmMetricValue::Tag::int64Value:
281                         attrHidl.type = DrmMetricGroupHidl::ValueType::INT64_TYPE;
282                         attrHidl.int64Value = attr.value.get<DrmMetricValue::Tag::int64Value>();
283                         break;
284                     case DrmMetricValue::Tag::doubleValue:
285                         attrHidl.type = DrmMetricGroupHidl::ValueType::DOUBLE_TYPE;
286                         attrHidl.doubleValue = attr.value.get<DrmMetricValue::Tag::doubleValue>();
287                         break;
288                     case DrmMetricValue::Tag::stringValue:
289                         attrHidl.type = DrmMetricGroupHidl::ValueType::STRING_TYPE;
290                         attrHidl.stringValue = attr.value.get<DrmMetricValue::Tag::stringValue>();
291                         break;
292                     default:
293                         break;
294                 }
295 
296                 aTmp.push_back(attrHidl);
297             }
298 
299             me.attributes = aTmp;
300 
301             std::vector<ValueHidl> vTmp;
302             for (auto value : m.values) {
303                 ValueHidl valueHidl;
304                 valueHidl.componentName = value.name;
305                 switch (value.value.getTag()) {
306                     case DrmMetricValue::Tag::int64Value:
307                         valueHidl.type = DrmMetricGroupHidl::ValueType::INT64_TYPE;
308                         valueHidl.int64Value = value.value.get<DrmMetricValue::Tag::int64Value>();
309                         break;
310                     case DrmMetricValue::Tag::doubleValue:
311                         valueHidl.type = DrmMetricGroupHidl::ValueType::DOUBLE_TYPE;
312                         valueHidl.doubleValue = value.value.get<DrmMetricValue::Tag::doubleValue>();
313                         break;
314                     case DrmMetricValue::Tag::stringValue:
315                         valueHidl.type = DrmMetricGroupHidl::ValueType::STRING_TYPE;
316                         valueHidl.stringValue = value.value.get<DrmMetricValue::Tag::stringValue>();
317                         break;
318                     default:
319                         break;
320                 }
321 
322                 vTmp.push_back(valueHidl);
323             }
324 
325             me.values = vTmp;
326             tmpMetric.push_back(me);
327         }
328 
329         re.metrics = tmpMetric;
330         resultHidl.push_back(re);
331     }
332 
333     return resultHidl;
334 }
335 
336 // DrmSessionClient Definition
337 
338 struct DrmHalAidl::DrmSessionClient : public aidl::android::media::BnResourceManagerClient {
DrmSessionClientandroid::DrmHalAidl::DrmSessionClient339     explicit DrmSessionClient(DrmHalAidl* drm, const Vector<uint8_t>& sessionId)
340         : mSessionId(sessionId), mDrm(drm) {}
341 
342     ::ndk::ScopedAStatus reclaimResource(bool* _aidl_return) override;
343     ::ndk::ScopedAStatus getName(::std::string* _aidl_return) override;
344 
345     const Vector<uint8_t> mSessionId;
346 
347     virtual ~DrmSessionClient();
348 
349   private:
350     wp<DrmHalAidl> mDrm;
351 
352     DISALLOW_EVIL_CONSTRUCTORS(DrmSessionClient);
353 };
354 
reclaimResource(bool * _aidl_return)355 ::ndk::ScopedAStatus DrmHalAidl::DrmSessionClient::reclaimResource(bool* _aidl_return) {
356     auto sessionId = mSessionId;
357     sp<DrmHalAidl> drm = mDrm.promote();
358     if (drm == NULL) {
359         *_aidl_return = true;
360         return ::ndk::ScopedAStatus::ok();
361     }
362     status_t err = drm->closeSession(sessionId);
363     if (err != OK) {
364         *_aidl_return = false;
365         return ::ndk::ScopedAStatus::ok();
366     }
367     drm->onEvent(EventTypeAidl::SESSION_RECLAIMED, toHidlVec(sessionId), hidl_vec<uint8_t>());
368     *_aidl_return = true;
369     return ::ndk::ScopedAStatus::ok();
370 }
371 
getName(::std::string * _aidl_return)372 ::ndk::ScopedAStatus DrmHalAidl::DrmSessionClient::getName(::std::string* _aidl_return) {
373     String8 name;
374     sp<DrmHalAidl> drm = mDrm.promote();
375     if (drm == NULL) {
376         name.append("<deleted>");
377     } else if (drm->getPropertyStringInternal(String8("vendor"), name) != OK || name.isEmpty()) {
378         name.append("<Get vendor failed or is empty>");
379     }
380     name.append("[");
381     for (size_t i = 0; i < mSessionId.size(); ++i) {
382         name.appendFormat("%02x", mSessionId[i]);
383     }
384     name.append("]");
385     *_aidl_return = name;
386     return ::ndk::ScopedAStatus::ok();
387 }
388 
~DrmSessionClient()389 DrmHalAidl::DrmSessionClient::~DrmSessionClient() {
390     DrmSessionManager::Instance()->removeSession(mSessionId);
391 }
392 
393 // DrmHalAidl methods
DrmHalAidl()394 DrmHalAidl::DrmHalAidl()
395     : mListener(::ndk::SharedRefBase::make<DrmHalListener>(&mMetrics)),
396       mFactories(DrmUtils::makeDrmFactoriesAidl()),
397       mInitCheck((mFactories.size() == 0) ? ERROR_UNSUPPORTED : NO_INIT) {}
398 
initCheck() const399 status_t DrmHalAidl::initCheck() const {
400     return mInitCheck;
401 }
402 
~DrmHalAidl()403 DrmHalAidl::~DrmHalAidl() {}
404 
setListener(const sp<IDrmClient> & listener)405 status_t DrmHalAidl::setListener(const sp<IDrmClient>& listener) {
406     mListener->setListener(listener);
407     return NO_ERROR;
408 }
409 
isCryptoSchemeSupported(const uint8_t uuid[16],const String8 & mimeType,DrmPlugin::SecurityLevel level,bool * isSupported)410 status_t DrmHalAidl::isCryptoSchemeSupported(const uint8_t uuid[16], const String8& mimeType,
411                                              DrmPlugin::SecurityLevel level, bool* isSupported) {
412     Mutex::Autolock autoLock(mLock);
413     *isSupported = false;
414     Uuid uuidAidl = DrmUtils::toAidlUuid(uuid);
415     SecurityLevel levelAidl = toAidlSecurityLevel(level);
416     std::string mimeTypeStr = mimeType.string();
417 
418     for (ssize_t i = mFactories.size() - 1; i >= 0; i--) {
419         CryptoSchemes schemes{};
420         auto err = mFactories[i]->getSupportedCryptoSchemes(&schemes);
421         if (!err.isOk() || !std::count(schemes.uuids.begin(), schemes.uuids.end(), uuidAidl)) {
422             continue;
423         }
424 
425         ALOGV("supported schemes: %s; query: level %d mime %s",
426               schemes.toString().c_str(), levelAidl, mimeType.c_str());
427         std::map<std::string, SupportedContentType> contentTypes;
428         for (auto ct : schemes.mimeTypes) {
429             contentTypes[ct.mime] = ct;
430         }
431 
432         // handle default value cases
433         if (levelAidl == SecurityLevel::DEFAULT || levelAidl == SecurityLevel::UNKNOWN) {
434             if (mimeType == "") {
435                 // isCryptoSchemeSupported(uuid)
436                 *isSupported = true;
437             } else {
438                 // isCryptoSchemeSupported(uuid, mimeType)
439                 *isSupported = contentTypes.count(mimeTypeStr);
440             }
441             return OK;
442         } else if (mimeType == "") {
443             return BAD_VALUE;
444         }
445 
446         auto ct = contentTypes[mimeTypeStr];
447         if (levelAidl > ct.maxLevel || levelAidl < ct.minLevel) {
448               continue;
449         }
450 
451         *isSupported = true;
452         break;
453     }
454 
455     return OK;
456 }
457 
createPlugin(const uint8_t uuid[16],const String8 & appPackageName)458 status_t DrmHalAidl::createPlugin(const uint8_t uuid[16], const String8& appPackageName) {
459     Mutex::Autolock autoLock(mLock);
460 
461     Uuid uuidAidl = DrmUtils::toAidlUuid(uuid);
462     std::string appPackageNameAidl = toStdString(appPackageName);
463     std::shared_ptr<IDrmPluginAidl> pluginAidl;
464     mMetrics.SetAppPackageName(appPackageName);
465     mMetrics.SetAppUid(AIBinder_getCallingUid());
466     for (ssize_t i = mFactories.size() - 1; i >= 0; i--) {
467         ::ndk::ScopedAStatus status =
468                 mFactories[i]->createDrmPlugin(uuidAidl, appPackageNameAidl, &pluginAidl);
469         if (status.isOk()) {
470             if (pluginAidl != NULL) {
471                 mPlugin = pluginAidl;
472                 break;
473             }
474         } else {
475             DrmUtils::LOG2BE(uuid, "Failed to make drm plugin: %d",
476                              status.getServiceSpecificError());
477         }
478     }
479 
480     if (mPlugin == NULL) {
481         DrmUtils::LOG2BE(uuid, "No supported hal instance found");
482         mInitCheck = ERROR_UNSUPPORTED;
483     } else {
484         mInitCheck = OK;
485         // Stored pointer mListener upcast to base BnDrmPluginListener
486         ::ndk::ScopedAStatus status = mPlugin
487             ->setListener(std::static_pointer_cast<BnDrmPluginListener>(mListener));
488         if (!status.isOk()) {
489             mInitCheck = DEAD_OBJECT;
490             ALOGE("setListener failed: ex %d svc err %d",
491                 status.getExceptionCode(),
492                 status.getServiceSpecificError());
493         }
494 
495         if (mInitCheck != OK) {
496             mPlugin.reset();
497         }
498     }
499 
500     return mInitCheck;
501 }
502 
openSession(DrmPlugin::SecurityLevel level,Vector<uint8_t> & sessionId)503 status_t DrmHalAidl::openSession(DrmPlugin::SecurityLevel level, Vector<uint8_t>& sessionId) {
504     Mutex::Autolock autoLock(mLock);
505     INIT_CHECK();
506 
507     SecurityLevel aSecurityLevel = toAidlSecurityLevel(level);
508 
509     if (aSecurityLevel == SecurityLevel::UNKNOWN) {
510         return ERROR_DRM_CANNOT_HANDLE;
511     }
512 
513     status_t err = UNKNOWN_ERROR;
514     bool retry = true;
515     do {
516         std::vector<uint8_t> aSessionId;
517 
518         ::ndk::ScopedAStatus status = mPlugin->openSession(aSecurityLevel, &aSessionId);
519         if (status.isOk()) sessionId = toVector(aSessionId);
520         err = statusAidlToStatusT(status);
521 
522         if (err == ERROR_DRM_RESOURCE_BUSY && retry) {
523             mLock.unlock();
524             // reclaimSession may call back to closeSession, since mLock is
525             // shared between Drm instances, we should unlock here to avoid
526             // deadlock.
527             retry = DrmSessionManager::Instance()->reclaimSession(AIBinder_getCallingPid());
528             mLock.lock();
529         } else {
530             retry = false;
531         }
532     } while (retry);
533 
534     if (err == OK) {
535         std::shared_ptr<DrmSessionClient> client =
536                 ndk::SharedRefBase::make<DrmSessionClient>(this, sessionId);
537         DrmSessionManager::Instance()->addSession(
538                 AIBinder_getCallingPid(), std::static_pointer_cast<IResourceManagerClient>(client),
539                 sessionId);
540         mOpenSessions.push_back(client);
541         mMetrics.SetSessionStart(sessionId);
542     }
543 
544     mMetrics.mOpenSessionCounter.Increment(err);
545     return err;
546 }
547 
closeSession(Vector<uint8_t> const & sessionId)548 status_t DrmHalAidl::closeSession(Vector<uint8_t> const& sessionId) {
549     Mutex::Autolock autoLock(mLock);
550     INIT_CHECK();
551 
552     std::vector<uint8_t> sessionIdAidl = toStdVec(sessionId);
553     ::ndk::ScopedAStatus status = mPlugin->closeSession(sessionIdAidl);
554     status_t response = statusAidlToStatusT(status);
555     if (status.isOk()) {
556         DrmSessionManager::Instance()->removeSession(sessionId);
557         for (auto i = mOpenSessions.begin(); i != mOpenSessions.end(); i++) {
558             if (isEqualSessionId((*i)->mSessionId, sessionId)) {
559                 mOpenSessions.erase(i);
560                 break;
561             }
562         }
563 
564         mMetrics.SetSessionEnd(sessionId);
565     }
566 
567     mMetrics.mCloseSessionCounter.Increment(response);
568     return response;
569 }
570 
getKeyRequest(Vector<uint8_t> const & sessionId,Vector<uint8_t> const & initData,String8 const & mimeType,DrmPlugin::KeyType keyType,KeyedVector<String8,String8> const & optionalParameters,Vector<uint8_t> & request,String8 & defaultUrl,DrmPlugin::KeyRequestType * keyRequestType)571 status_t DrmHalAidl::getKeyRequest(Vector<uint8_t> const& sessionId,
572                                    Vector<uint8_t> const& initData, String8 const& mimeType,
573                                    DrmPlugin::KeyType keyType,
574                                    KeyedVector<String8, String8> const& optionalParameters,
575                                    Vector<uint8_t>& request, String8& defaultUrl,
576                                    DrmPlugin::KeyRequestType* keyRequestType) {
577     Mutex::Autolock autoLock(mLock);
578     INIT_CHECK();
579     EventTimer<status_t> keyRequestTimer(&mMetrics.mGetKeyRequestTimeUs);
580 
581     DrmSessionManager::Instance()->useSession(sessionId);
582 
583     KeyType aKeyType;
584     if (keyType == DrmPlugin::kKeyType_Streaming) {
585         aKeyType = KeyType::STREAMING;
586     } else if (keyType == DrmPlugin::kKeyType_Offline) {
587         aKeyType = KeyType::OFFLINE;
588     } else if (keyType == DrmPlugin::kKeyType_Release) {
589         aKeyType = KeyType::RELEASE;
590     } else {
591         keyRequestTimer.SetAttribute(BAD_VALUE);
592         return BAD_VALUE;
593     }
594 
595     status_t err = UNKNOWN_ERROR;
596 
597     std::vector<uint8_t> sessionIdAidl = toStdVec(sessionId);
598     std::vector<uint8_t> initDataAidl = toStdVec(initData);
599     KeyRequest keyRequest;
600 
601     ::ndk::ScopedAStatus status =
602             mPlugin->getKeyRequest(sessionIdAidl, initDataAidl, toStdString(mimeType), aKeyType,
603                                    toKeyValueVector(optionalParameters), &keyRequest);
604     if (status.isOk()) {
605         request = toVector(keyRequest.request);
606         defaultUrl = toString8(keyRequest.defaultUrl);
607         *keyRequestType = toKeyRequestType(keyRequest.requestType);
608     }
609 
610     err = statusAidlToStatusT(status);
611     keyRequestTimer.SetAttribute(err);
612     return err;
613 }
614 
provideKeyResponse(Vector<uint8_t> const & sessionId,Vector<uint8_t> const & response,Vector<uint8_t> & keySetId)615 status_t DrmHalAidl::provideKeyResponse(Vector<uint8_t> const& sessionId,
616                                         Vector<uint8_t> const& response,
617                                         Vector<uint8_t>& keySetId) {
618     Mutex::Autolock autoLock(mLock);
619     INIT_CHECK();
620     EventTimer<status_t> keyResponseTimer(&mMetrics.mProvideKeyResponseTimeUs);
621 
622     DrmSessionManager::Instance()->useSession(sessionId);
623 
624     status_t err = UNKNOWN_ERROR;
625 
626     std::vector<uint8_t> sessionIdAidl = toStdVec(sessionId);
627     std::vector<uint8_t> responseAidl = toStdVec(response);
628     KeySetId keySetIdsAidl;
629     ::ndk::ScopedAStatus status =
630             mPlugin->provideKeyResponse(sessionIdAidl, responseAidl, &keySetIdsAidl);
631 
632     if (status.isOk()) keySetId = toVector(keySetIdsAidl.keySetId);
633     err = statusAidlToStatusT(status);
634     keyResponseTimer.SetAttribute(err);
635     return err;
636 }
637 
removeKeys(Vector<uint8_t> const & keySetId)638 status_t DrmHalAidl::removeKeys(Vector<uint8_t> const& keySetId) {
639     Mutex::Autolock autoLock(mLock);
640     INIT_CHECK();
641 
642     ::ndk::ScopedAStatus status = mPlugin->removeKeys(toStdVec(keySetId));
643     return statusAidlToStatusT(status);
644 }
645 
restoreKeys(Vector<uint8_t> const & sessionId,Vector<uint8_t> const & keySetId)646 status_t DrmHalAidl::restoreKeys(Vector<uint8_t> const& sessionId,
647                                  Vector<uint8_t> const& keySetId) {
648     Mutex::Autolock autoLock(mLock);
649     INIT_CHECK();
650 
651     DrmSessionManager::Instance()->useSession(sessionId);
652 
653     KeySetId keySetIdsAidl;
654     keySetIdsAidl.keySetId = toStdVec(keySetId);
655     ::ndk::ScopedAStatus status = mPlugin->restoreKeys(toStdVec(sessionId), keySetIdsAidl);
656     return statusAidlToStatusT(status);
657 }
658 
queryKeyStatus(Vector<uint8_t> const & sessionId,KeyedVector<String8,String8> & infoMap) const659 status_t DrmHalAidl::queryKeyStatus(Vector<uint8_t> const& sessionId,
660                                     KeyedVector<String8, String8>& infoMap) const {
661     Mutex::Autolock autoLock(mLock);
662     INIT_CHECK();
663 
664     DrmSessionManager::Instance()->useSession(sessionId);
665 
666     std::vector<KeyValue> infoMapAidl;
667     ::ndk::ScopedAStatus status = mPlugin->queryKeyStatus(toStdVec(sessionId), &infoMapAidl);
668 
669     infoMap = toKeyedVector(infoMapAidl);
670 
671     return statusAidlToStatusT(status);
672 }
673 
getProvisionRequest(String8 const & certType,String8 const & certAuthority,Vector<uint8_t> & request,String8 & defaultUrl)674 status_t DrmHalAidl::getProvisionRequest(String8 const& certType, String8 const& certAuthority,
675                                          Vector<uint8_t>& request, String8& defaultUrl) {
676     Mutex::Autolock autoLock(mLock);
677     INIT_CHECK();
678 
679     status_t err = UNKNOWN_ERROR;
680 
681     ProvisionRequest requestAidl;
682     ::ndk::ScopedAStatus status = mPlugin->getProvisionRequest(
683             toStdString(certType), toStdString(certAuthority), &requestAidl);
684 
685     request = toVector(requestAidl.request);
686     defaultUrl = toString8(requestAidl.defaultUrl);
687 
688     err = statusAidlToStatusT(status);
689     mMetrics.mGetProvisionRequestCounter.Increment(err);
690     return err;
691 }
692 
provideProvisionResponse(Vector<uint8_t> const & response,Vector<uint8_t> & certificate,Vector<uint8_t> & wrappedKey)693 status_t DrmHalAidl::provideProvisionResponse(Vector<uint8_t> const& response,
694                                               Vector<uint8_t>& certificate,
695                                               Vector<uint8_t>& wrappedKey) {
696     Mutex::Autolock autoLock(mLock);
697     INIT_CHECK();
698 
699     status_t err = UNKNOWN_ERROR;
700     ProvideProvisionResponseResult result;
701     ::ndk::ScopedAStatus status = mPlugin->provideProvisionResponse(toStdVec(response), &result);
702 
703     certificate = toVector(result.certificate);
704     wrappedKey = toVector(result.wrappedKey);
705     err = statusAidlToStatusT(status);
706     mMetrics.mProvideProvisionResponseCounter.Increment(err);
707     return err;
708 }
709 
getSecureStops(List<Vector<uint8_t>> & secureStops)710 status_t DrmHalAidl::getSecureStops(List<Vector<uint8_t>>& secureStops) {
711     Mutex::Autolock autoLock(mLock);
712     INIT_CHECK();
713 
714     std::vector<SecureStop> result;
715     ::ndk::ScopedAStatus status = mPlugin->getSecureStops(&result);
716 
717     secureStops = toSecureStops(result);
718 
719     return statusAidlToStatusT(status);
720 }
721 
getSecureStopIds(List<Vector<uint8_t>> & secureStopIds)722 status_t DrmHalAidl::getSecureStopIds(List<Vector<uint8_t>>& secureStopIds) {
723     Mutex::Autolock autoLock(mLock);
724     INIT_CHECK();
725 
726     std::vector<SecureStopId> result;
727     ::ndk::ScopedAStatus status = mPlugin->getSecureStopIds(&result);
728 
729     secureStopIds = toSecureStopIds(result);
730 
731     return statusAidlToStatusT(status);
732 }
733 
getSecureStop(Vector<uint8_t> const & ssid,Vector<uint8_t> & secureStop)734 status_t DrmHalAidl::getSecureStop(Vector<uint8_t> const& ssid, Vector<uint8_t>& secureStop) {
735     Mutex::Autolock autoLock(mLock);
736     INIT_CHECK();
737 
738     SecureStopId ssidAidl;
739     ssidAidl.secureStopId = toStdVec(ssid);
740 
741     SecureStop result;
742     ::ndk::ScopedAStatus status = mPlugin->getSecureStop(ssidAidl, &result);
743 
744     secureStop = toVector(result.opaqueData);
745 
746     return statusAidlToStatusT(status);
747 }
748 
releaseSecureStops(Vector<uint8_t> const & ssRelease)749 status_t DrmHalAidl::releaseSecureStops(Vector<uint8_t> const& ssRelease) {
750     Mutex::Autolock autoLock(mLock);
751     INIT_CHECK();
752 
753     OpaqueData ssId;
754     ssId.opaqueData = toStdVec(ssRelease);
755     ::ndk::ScopedAStatus status = mPlugin->releaseSecureStops(ssId);
756 
757     return statusAidlToStatusT(status);
758 }
759 
removeSecureStop(Vector<uint8_t> const & ssid)760 status_t DrmHalAidl::removeSecureStop(Vector<uint8_t> const& ssid) {
761     Mutex::Autolock autoLock(mLock);
762 
763     INIT_CHECK();
764 
765     SecureStopId ssidAidl;
766     ssidAidl.secureStopId = toStdVec(ssid);
767     ::ndk::ScopedAStatus status = mPlugin->removeSecureStop(ssidAidl);
768     return statusAidlToStatusT(status);
769 }
770 
removeAllSecureStops()771 status_t DrmHalAidl::removeAllSecureStops() {
772     Mutex::Autolock autoLock(mLock);
773     INIT_CHECK();
774 
775     ::ndk::ScopedAStatus status = mPlugin->releaseAllSecureStops();
776     return statusAidlToStatusT(status);
777 }
778 
getHdcpLevels(DrmPlugin::HdcpLevel * connected,DrmPlugin::HdcpLevel * max) const779 status_t DrmHalAidl::getHdcpLevels(DrmPlugin::HdcpLevel* connected,
780                                    DrmPlugin::HdcpLevel* max) const {
781     Mutex::Autolock autoLock(mLock);
782     INIT_CHECK();
783 
784     if (connected == NULL || max == NULL) {
785         return BAD_VALUE;
786     }
787 
788     *connected = DrmPlugin::kHdcpLevelUnknown;
789     *max = DrmPlugin::kHdcpLevelUnknown;
790 
791     HdcpLevels lvlsAidl;
792     ::ndk::ScopedAStatus status = mPlugin->getHdcpLevels(&lvlsAidl);
793 
794     *connected = toHdcpLevel(lvlsAidl.connectedLevel);
795     *max = toHdcpLevel(lvlsAidl.maxLevel);
796 
797     return statusAidlToStatusT(status);
798 }
799 
getNumberOfSessions(uint32_t * open,uint32_t * max) const800 status_t DrmHalAidl::getNumberOfSessions(uint32_t* open, uint32_t* max) const {
801     Mutex::Autolock autoLock(mLock);
802     INIT_CHECK();
803 
804     if (open == NULL || max == NULL) {
805         return BAD_VALUE;
806     }
807 
808     *open = 0;
809     *max = 0;
810 
811     NumberOfSessions result;
812     ::ndk::ScopedAStatus status = mPlugin->getNumberOfSessions(&result);
813 
814     *open = result.currentSessions;
815     *max = result.maxSessions;
816 
817     return statusAidlToStatusT(status);
818 }
819 
getSecurityLevel(Vector<uint8_t> const & sessionId,DrmPlugin::SecurityLevel * level) const820 status_t DrmHalAidl::getSecurityLevel(Vector<uint8_t> const& sessionId,
821                                       DrmPlugin::SecurityLevel* level) const {
822     Mutex::Autolock autoLock(mLock);
823     INIT_CHECK();
824 
825     if (level == NULL) {
826         return BAD_VALUE;
827     }
828 
829     *level = DrmPlugin::kSecurityLevelUnknown;
830 
831     SecurityLevel result;
832     ::ndk::ScopedAStatus status = mPlugin->getSecurityLevel(toStdVec(sessionId), &result);
833 
834     *level = toSecurityLevel(result);
835 
836     return statusAidlToStatusT(status);
837 }
838 
getOfflineLicenseKeySetIds(List<Vector<uint8_t>> & keySetIds) const839 status_t DrmHalAidl::getOfflineLicenseKeySetIds(List<Vector<uint8_t>>& keySetIds) const {
840     Mutex::Autolock autoLock(mLock);
841     INIT_CHECK();
842 
843     std::vector<KeySetId> result;
844     ::ndk::ScopedAStatus status = mPlugin->getOfflineLicenseKeySetIds(&result);
845 
846     keySetIds = toKeySetIds(result);
847 
848     return statusAidlToStatusT(status);
849 }
850 
removeOfflineLicense(Vector<uint8_t> const & keySetId)851 status_t DrmHalAidl::removeOfflineLicense(Vector<uint8_t> const& keySetId) {
852     Mutex::Autolock autoLock(mLock);
853     INIT_CHECK();
854 
855     KeySetId keySetIdAidl;
856     keySetIdAidl.keySetId = toStdVec(keySetId);
857     ::ndk::ScopedAStatus status = mPlugin->removeOfflineLicense(keySetIdAidl);
858     return statusAidlToStatusT(status);
859 }
860 
getOfflineLicenseState(Vector<uint8_t> const & keySetId,DrmPlugin::OfflineLicenseState * licenseState) const861 status_t DrmHalAidl::getOfflineLicenseState(Vector<uint8_t> const& keySetId,
862                                             DrmPlugin::OfflineLicenseState* licenseState) const {
863     Mutex::Autolock autoLock(mLock);
864 
865     INIT_CHECK();
866     *licenseState = DrmPlugin::kOfflineLicenseStateUnknown;
867 
868     KeySetId keySetIdAidl;
869     keySetIdAidl.keySetId = toStdVec(keySetId);
870 
871     OfflineLicenseState result;
872     ::ndk::ScopedAStatus status = mPlugin->getOfflineLicenseState(keySetIdAidl, &result);
873 
874     *licenseState = toOfflineLicenseState(result);
875 
876     return statusAidlToStatusT(status);
877 }
878 
getPropertyString(String8 const & name,String8 & value) const879 status_t DrmHalAidl::getPropertyString(String8 const& name, String8& value) const {
880     Mutex::Autolock autoLock(mLock);
881     return getPropertyStringInternal(name, value);
882 }
883 
getPropertyStringInternal(String8 const & name,String8 & value) const884 status_t DrmHalAidl::getPropertyStringInternal(String8 const& name, String8& value) const {
885     // This function is internal to the class and should only be called while
886     // mLock is already held.
887     INIT_CHECK();
888 
889     std::string result;
890     ::ndk::ScopedAStatus status = mPlugin->getPropertyString(toStdString(name), &result);
891 
892     value = toString8(result);
893 
894     return statusAidlToStatusT(status);
895 }
896 
getPropertyByteArray(String8 const & name,Vector<uint8_t> & value) const897 status_t DrmHalAidl::getPropertyByteArray(String8 const& name, Vector<uint8_t>& value) const {
898     Mutex::Autolock autoLock(mLock);
899     return getPropertyByteArrayInternal(name, value);
900 }
901 
getPropertyByteArrayInternal(String8 const & name,Vector<uint8_t> & value) const902 status_t DrmHalAidl::getPropertyByteArrayInternal(String8 const& name,
903                                                   Vector<uint8_t>& value) const {
904     // This function is internal to the class and should only be called while
905     // mLock is already held.
906     INIT_CHECK();
907 
908     status_t err = UNKNOWN_ERROR;
909 
910     std::vector<uint8_t> result;
911     ::ndk::ScopedAStatus status = mPlugin->getPropertyByteArray(toStdString(name), &result);
912 
913     value = toVector(result);
914     err = statusAidlToStatusT(status);
915     if (name == kPropertyDeviceUniqueId) {
916         mMetrics.mGetDeviceUniqueIdCounter.Increment(err);
917     }
918     return err;
919 }
920 
setPropertyString(String8 const & name,String8 const & value) const921 status_t DrmHalAidl::setPropertyString(String8 const& name, String8 const& value) const {
922     Mutex::Autolock autoLock(mLock);
923     INIT_CHECK();
924 
925     ::ndk::ScopedAStatus status = mPlugin->setPropertyString(toStdString(name), toStdString(value));
926     return statusAidlToStatusT(status);
927 }
928 
setPropertyByteArray(String8 const & name,Vector<uint8_t> const & value) const929 status_t DrmHalAidl::setPropertyByteArray(String8 const& name, Vector<uint8_t> const& value) const {
930     Mutex::Autolock autoLock(mLock);
931     INIT_CHECK();
932 
933     ::ndk::ScopedAStatus status = mPlugin->setPropertyByteArray(toStdString(name), toStdVec(value));
934     return statusAidlToStatusT(status);
935 }
936 
getMetrics(const sp<IDrmMetricsConsumer> & consumer)937 status_t DrmHalAidl::getMetrics(const sp<IDrmMetricsConsumer>& consumer) {
938     if (consumer == nullptr) {
939         return UNEXPECTED_NULL;
940     }
941     consumer->consumeFrameworkMetrics(mMetrics);
942 
943     // Append vendor metrics if they are supported.
944 
945     String8 vendor;
946     String8 description;
947     if (getPropertyStringInternal(String8("vendor"), vendor) != OK || vendor.isEmpty()) {
948         ALOGE("Get vendor failed or is empty");
949         vendor = "NONE";
950     }
951     if (getPropertyStringInternal(String8("description"), description) != OK ||
952         description.isEmpty()) {
953         ALOGE("Get description failed or is empty.");
954         description = "NONE";
955     }
956     vendor += ".";
957     vendor += description;
958 
959     hidl_vec<DrmMetricGroupHidl> pluginMetrics;
960     status_t err = UNKNOWN_ERROR;
961 
962     std::vector<DrmMetricGroupAidl> result;
963     ::ndk::ScopedAStatus status = mPlugin->getMetrics(&result);
964 
965     if (status.isOk()) {
966         pluginMetrics = toDrmMetricGroupHidl(result);
967         consumer->consumeHidlMetrics(vendor, pluginMetrics);
968     }
969 
970     err = statusAidlToStatusT(status);
971 
972     return err;
973 }
974 
setCipherAlgorithm(Vector<uint8_t> const & sessionId,String8 const & algorithm)975 status_t DrmHalAidl::setCipherAlgorithm(Vector<uint8_t> const& sessionId,
976                                         String8 const& algorithm) {
977     Mutex::Autolock autoLock(mLock);
978     INIT_CHECK();
979 
980     DrmSessionManager::Instance()->useSession(sessionId);
981 
982     ::ndk::ScopedAStatus status =
983             mPlugin->setCipherAlgorithm(toStdVec(sessionId), toStdString(algorithm));
984     return statusAidlToStatusT(status);
985 }
986 
setMacAlgorithm(Vector<uint8_t> const & sessionId,String8 const & algorithm)987 status_t DrmHalAidl::setMacAlgorithm(Vector<uint8_t> const& sessionId, String8 const& algorithm) {
988     Mutex::Autolock autoLock(mLock);
989     INIT_CHECK();
990 
991     DrmSessionManager::Instance()->useSession(sessionId);
992 
993     ::ndk::ScopedAStatus status =
994             mPlugin->setMacAlgorithm(toStdVec(sessionId), toStdString(algorithm));
995     return statusAidlToStatusT(status);
996 }
997 
encrypt(Vector<uint8_t> const & sessionId,Vector<uint8_t> const & keyId,Vector<uint8_t> const & input,Vector<uint8_t> const & iv,Vector<uint8_t> & output)998 status_t DrmHalAidl::encrypt(Vector<uint8_t> const& sessionId, Vector<uint8_t> const& keyId,
999                              Vector<uint8_t> const& input, Vector<uint8_t> const& iv,
1000                              Vector<uint8_t>& output) {
1001     Mutex::Autolock autoLock(mLock);
1002     INIT_CHECK();
1003 
1004     DrmSessionManager::Instance()->useSession(sessionId);
1005 
1006     std::vector<uint8_t> result;
1007     ::ndk::ScopedAStatus status = mPlugin->encrypt(toStdVec(sessionId), toStdVec(keyId),
1008                                                    toStdVec(input), toStdVec(iv), &result);
1009 
1010     output = toVector(result);
1011 
1012     return statusAidlToStatusT(status);
1013 }
1014 
decrypt(Vector<uint8_t> const & sessionId,Vector<uint8_t> const & keyId,Vector<uint8_t> const & input,Vector<uint8_t> const & iv,Vector<uint8_t> & output)1015 status_t DrmHalAidl::decrypt(Vector<uint8_t> const& sessionId, Vector<uint8_t> const& keyId,
1016                              Vector<uint8_t> const& input, Vector<uint8_t> const& iv,
1017                              Vector<uint8_t>& output) {
1018     Mutex::Autolock autoLock(mLock);
1019     INIT_CHECK();
1020 
1021     DrmSessionManager::Instance()->useSession(sessionId);
1022 
1023     std::vector<uint8_t> result;
1024     ::ndk::ScopedAStatus status = mPlugin->decrypt(toStdVec(sessionId), toStdVec(keyId),
1025                                                    toStdVec(input), toStdVec(iv), &result);
1026 
1027     output = toVector(result);
1028 
1029     return statusAidlToStatusT(status);
1030 }
1031 
sign(Vector<uint8_t> const & sessionId,Vector<uint8_t> const & keyId,Vector<uint8_t> const & message,Vector<uint8_t> & signature)1032 status_t DrmHalAidl::sign(Vector<uint8_t> const& sessionId, Vector<uint8_t> const& keyId,
1033                           Vector<uint8_t> const& message, Vector<uint8_t>& signature) {
1034     Mutex::Autolock autoLock(mLock);
1035     INIT_CHECK();
1036 
1037     DrmSessionManager::Instance()->useSession(sessionId);
1038 
1039     std::vector<uint8_t> result;
1040     ::ndk::ScopedAStatus status =
1041             mPlugin->sign(toStdVec(sessionId), toStdVec(keyId), toStdVec(message), &result);
1042 
1043     signature = toVector(result);
1044 
1045     return statusAidlToStatusT(status);
1046 }
1047 
verify(Vector<uint8_t> const & sessionId,Vector<uint8_t> const & keyId,Vector<uint8_t> const & message,Vector<uint8_t> const & signature,bool & match)1048 status_t DrmHalAidl::verify(Vector<uint8_t> const& sessionId, Vector<uint8_t> const& keyId,
1049                             Vector<uint8_t> const& message, Vector<uint8_t> const& signature,
1050                             bool& match) {
1051     Mutex::Autolock autoLock(mLock);
1052     INIT_CHECK();
1053 
1054     DrmSessionManager::Instance()->useSession(sessionId);
1055 
1056     ::ndk::ScopedAStatus status = mPlugin->verify(toStdVec(sessionId), toStdVec(keyId),
1057                                                   toStdVec(message), toStdVec(signature), &match);
1058 
1059     return statusAidlToStatusT(status);
1060 }
1061 
signRSA(Vector<uint8_t> const & sessionId,String8 const & algorithm,Vector<uint8_t> const & message,Vector<uint8_t> const & wrappedKey,Vector<uint8_t> & signature)1062 status_t DrmHalAidl::signRSA(Vector<uint8_t> const& sessionId, String8 const& algorithm,
1063                              Vector<uint8_t> const& message, Vector<uint8_t> const& wrappedKey,
1064                              Vector<uint8_t>& signature) {
1065     Mutex::Autolock autoLock(mLock);
1066     INIT_CHECK();
1067 
1068     DrmSessionManager::Instance()->useSession(sessionId);
1069 
1070     std::vector<uint8_t> result;
1071     ::ndk::ScopedAStatus status =
1072             mPlugin->signRSA(toStdVec(sessionId), toStdString(algorithm), toStdVec(message),
1073                              toStdVec(wrappedKey), &result);
1074 
1075     signature = toVector(result);
1076 
1077     return statusAidlToStatusT(status);
1078 }
1079 
requiresSecureDecoder(const char * mime,bool * required) const1080 status_t DrmHalAidl::requiresSecureDecoder(const char* mime, bool* required) const {
1081     Mutex::Autolock autoLock(mLock);
1082     INIT_CHECK();
1083 
1084     std::string mimeAidl(mime);
1085     ::ndk::ScopedAStatus status =
1086         mPlugin->requiresSecureDecoder(mimeAidl, SecurityLevel::DEFAULT, required);
1087     if (!status.isOk()) {
1088         DrmUtils::LOG2BE("requiresSecureDecoder txn failed: %d", status.getServiceSpecificError());
1089         return DEAD_OBJECT;
1090     }
1091 
1092     return OK;
1093 }
1094 
requiresSecureDecoder(const char * mime,DrmPlugin::SecurityLevel securityLevel,bool * required) const1095 status_t DrmHalAidl::requiresSecureDecoder(const char* mime, DrmPlugin::SecurityLevel securityLevel,
1096                                            bool* required) const {
1097     Mutex::Autolock autoLock(mLock);
1098     INIT_CHECK();
1099 
1100     auto aLevel = toAidlSecurityLevel(securityLevel);
1101     std::string mimeAidl(mime);
1102     ::ndk::ScopedAStatus status = mPlugin->requiresSecureDecoder(mimeAidl, aLevel, required);
1103 
1104     status_t err = statusAidlToStatusT(status);
1105     if (!status.isOk()) {
1106         DrmUtils::LOG2BE("requiresSecureDecoder txn failed: %d", status.getServiceSpecificError());
1107     }
1108 
1109     return err;
1110 }
1111 
setPlaybackId(Vector<uint8_t> const & sessionId,const char * playbackId)1112 status_t DrmHalAidl::setPlaybackId(Vector<uint8_t> const& sessionId, const char* playbackId) {
1113     Mutex::Autolock autoLock(mLock);
1114     INIT_CHECK();
1115     std::string playbackIdAidl(playbackId);
1116     ::ndk::ScopedAStatus status = mPlugin->setPlaybackId(toStdVec(sessionId), playbackIdAidl);
1117     return statusAidlToStatusT(status);
1118 }
1119 
getLogMessages(Vector<drm::V1_4::LogMessage> & logs) const1120 status_t DrmHalAidl::getLogMessages(Vector<drm::V1_4::LogMessage>& logs) const {
1121     Mutex::Autolock autoLock(mLock);
1122     return DrmUtils::GetLogMessagesAidl<IDrmPluginAidl>(mPlugin, logs);
1123 }
1124 
closeOpenSessions()1125 void DrmHalAidl::closeOpenSessions() {
1126     Mutex::Autolock autoLock(mLock);
1127     auto openSessions = mOpenSessions;
1128     for (size_t i = 0; i < openSessions.size(); i++) {
1129         mLock.unlock();
1130         closeSession(openSessions[i]->mSessionId);
1131         mLock.lock();
1132     }
1133     mOpenSessions.clear();
1134 }
1135 
reportPluginMetrics() const1136 std::string DrmHalAidl::reportPluginMetrics() const {
1137     Vector<uint8_t> metricsVector;
1138     String8 vendor;
1139     String8 description;
1140     std::string metricsString;
1141     if (getPropertyStringInternal(String8("vendor"), vendor) == OK &&
1142         getPropertyStringInternal(String8("description"), description) == OK &&
1143         getPropertyByteArrayInternal(String8("metrics"), metricsVector) == OK) {
1144         metricsString = toBase64StringNoPad(metricsVector.array(), metricsVector.size());
1145         status_t res = android::reportDrmPluginMetrics(metricsString, vendor, description,
1146                                                        mMetrics.GetAppUid());
1147         if (res != OK) {
1148             ALOGE("Metrics were retrieved but could not be reported: %d", res);
1149         }
1150     }
1151     return metricsString;
1152 }
1153 
reportFrameworkMetrics(const std::string & pluginMetrics) const1154 std::string DrmHalAidl::reportFrameworkMetrics(const std::string& pluginMetrics) const {
1155     mediametrics_handle_t item(mediametrics_create("mediadrm"));
1156     mediametrics_setUid(item, mMetrics.GetAppUid());
1157     String8 vendor;
1158     String8 description;
1159     status_t result = getPropertyStringInternal(String8("vendor"), vendor);
1160     if (result != OK) {
1161         ALOGE("Failed to get vendor from drm plugin: %d", result);
1162     } else {
1163         mediametrics_setCString(item, "vendor", vendor.c_str());
1164     }
1165     result = getPropertyStringInternal(String8("description"), description);
1166     if (result != OK) {
1167         ALOGE("Failed to get description from drm plugin: %d", result);
1168     } else {
1169         mediametrics_setCString(item, "description", description.c_str());
1170     }
1171 
1172     std::string serializedMetrics;
1173     result = mMetrics.GetSerializedMetrics(&serializedMetrics);
1174     if (result != OK) {
1175         ALOGE("Failed to serialize framework metrics: %d", result);
1176     }
1177     std::string b64EncodedMetrics =
1178             toBase64StringNoPad(serializedMetrics.data(), serializedMetrics.size());
1179     if (!b64EncodedMetrics.empty()) {
1180         mediametrics_setCString(item, "serialized_metrics", b64EncodedMetrics.c_str());
1181     }
1182     if (!pluginMetrics.empty()) {
1183         mediametrics_setCString(item, "plugin_metrics", pluginMetrics.c_str());
1184     }
1185     if (!mediametrics_selfRecord(item)) {
1186         ALOGE("Failed to self record framework metrics");
1187     }
1188     mediametrics_delete(item);
1189     return serializedMetrics;
1190 }
1191 
getSupportedSchemes(std::vector<uint8_t> & schemes) const1192 status_t DrmHalAidl::getSupportedSchemes(std::vector<uint8_t> &schemes) const {
1193     Mutex::Autolock autoLock(mLock);
1194 
1195     if (mFactories.empty()) return UNKNOWN_ERROR;
1196     for (ssize_t i = mFactories.size() - 1; i >= 0; i--) {
1197         CryptoSchemes curSchemes{};
1198         auto err = mFactories[i]->getSupportedCryptoSchemes(&curSchemes);
1199         if (!err.isOk()) {
1200             continue;
1201         }
1202 
1203         for (auto uuidObj : curSchemes.uuids) {
1204             schemes.insert(schemes.end(), uuidObj.uuid.begin(), uuidObj.uuid.end());
1205         }
1206     }
1207 
1208     return OK;
1209 }
1210 
cleanup()1211 void DrmHalAidl::cleanup() {
1212     closeOpenSessions();
1213 
1214     Mutex::Autolock autoLock(mLock);
1215     reportFrameworkMetrics(reportPluginMetrics());
1216 
1217     setListener(NULL);
1218     mInitCheck = NO_INIT;
1219     if (mPlugin != NULL) {
1220         if (!mPlugin->setListener(NULL).isOk()) {
1221             mInitCheck = DEAD_OBJECT;
1222         }
1223     }
1224 
1225     mPlugin.reset();
1226 }
1227 
destroyPlugin()1228 status_t DrmHalAidl::destroyPlugin() {
1229     cleanup();
1230     return OK;
1231 }
1232 
onEvent(EventTypeAidl eventTypeAidl,const std::vector<uint8_t> & sessionId,const std::vector<uint8_t> & data)1233 ::ndk::ScopedAStatus DrmHalAidl::onEvent(EventTypeAidl eventTypeAidl,
1234                                          const std::vector<uint8_t>& sessionId,
1235                                          const std::vector<uint8_t>& data) {
1236     return mListener->onEvent(eventTypeAidl, sessionId, data);
1237 }
1238 
onExpirationUpdate(const std::vector<uint8_t> & sessionId,int64_t expiryTimeInMS)1239 ::ndk::ScopedAStatus DrmHalAidl::onExpirationUpdate(const std::vector<uint8_t>& sessionId,
1240                                                     int64_t expiryTimeInMS) {
1241     return mListener->onExpirationUpdate(sessionId, expiryTimeInMS);
1242 }
1243 
onKeysChange(const std::vector<uint8_t> & sessionId,const std::vector<KeyStatus> & keyStatusListAidl,bool hasNewUsableKey)1244 ::ndk::ScopedAStatus DrmHalAidl::onKeysChange(const std::vector<uint8_t>& sessionId,
1245                                               const std::vector<KeyStatus>& keyStatusListAidl,
1246                                               bool hasNewUsableKey) {
1247     return mListener->onKeysChange(sessionId, keyStatusListAidl, hasNewUsableKey);
1248 }
1249 
onSessionLostState(const std::vector<uint8_t> & sessionId)1250 ::ndk::ScopedAStatus DrmHalAidl::onSessionLostState(const std::vector<uint8_t>& sessionId) {
1251     return mListener->onSessionLostState(sessionId);
1252 }
1253 
1254 }  // namespace android