Home | History | Annotate | Download | only in default 
      1 /*
      2  * Copyright (C) 2016 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 #define LOG_TAG "android.hardware.drm (at) 1.0-impl"
     17 
     18 #include <utils/KeyedVector.h>
     19 #include <utils/String8.h>
     20 
     21 #include "DrmPlugin.h"
     22 #include "TypeConvert.h"
     23 
     24 namespace android {
     25 namespace hardware {
     26 namespace drm {
     27 namespace V1_0 {
     28 namespace implementation {
     29 
     30     // Methods from ::android::hardware::drm::V1_0::IDrmPlugin follow.
     31 
     32     Return<void> DrmPlugin::openSession(openSession_cb _hidl_cb) {
     33         Vector<uint8_t> legacySessionId;
     34         status_t status = mLegacyPlugin->openSession(legacySessionId);
     35         _hidl_cb(toStatus(status), toHidlVec(legacySessionId));
     36         return Void();
     37     }
     38 
     39     Return<Status> DrmPlugin::closeSession(const hidl_vec<uint8_t>& sessionId) {
     40         return toStatus(mLegacyPlugin->closeSession(toVector(sessionId)));
     41     }
     42 
     43     Return<void> DrmPlugin::getKeyRequest(const hidl_vec<uint8_t>& scope,
     44             const hidl_vec<uint8_t>& initData, const hidl_string& mimeType,
     45             KeyType keyType, const hidl_vec<KeyValue>& optionalParameters,
     46             getKeyRequest_cb _hidl_cb) {
     47 
     48         status_t status = android::OK;
     49 
     50         android::DrmPlugin::KeyType legacyKeyType;
     51         switch(keyType) {
     52         case KeyType::OFFLINE:
     53             legacyKeyType = android::DrmPlugin::kKeyType_Offline;
     54             break;
     55         case KeyType::STREAMING:
     56             legacyKeyType = android::DrmPlugin::kKeyType_Streaming;
     57             break;
     58         case KeyType::RELEASE:
     59             legacyKeyType = android::DrmPlugin::kKeyType_Release;
     60             break;
     61         default:
     62             status = android::BAD_VALUE;
     63             break;
     64         }
     65 
     66         Vector<uint8_t> legacyRequest;
     67         KeyRequestType requestType = KeyRequestType::UNKNOWN;
     68         String8 defaultUrl;
     69 
     70         if (status == android::OK) {
     71             android::KeyedVector<String8, String8> legacyOptionalParameters;
     72             for (size_t i = 0; i < optionalParameters.size(); i++) {
     73                 legacyOptionalParameters.add(String8(optionalParameters[i].key.c_str()),
     74                         String8(optionalParameters[i].value.c_str()));
     75             }
     76 
     77             android::DrmPlugin::KeyRequestType legacyRequestType =
     78                     android::DrmPlugin::kKeyRequestType_Unknown;
     79 
     80             status = mLegacyPlugin->getKeyRequest(toVector(scope),
     81                     toVector(initData), String8(mimeType.c_str()), legacyKeyType,
     82                     legacyOptionalParameters, legacyRequest, defaultUrl,
     83                     &legacyRequestType);
     84 
     85             switch(legacyRequestType) {
     86             case android::DrmPlugin::kKeyRequestType_Initial:
     87                 requestType = KeyRequestType::INITIAL;
     88                 break;
     89             case android::DrmPlugin::kKeyRequestType_Renewal:
     90                 requestType = KeyRequestType::RENEWAL;
     91                 break;
     92             case android::DrmPlugin::kKeyRequestType_Release:
     93                 requestType = KeyRequestType::RELEASE;
     94                 break;
     95             case android::DrmPlugin::kKeyRequestType_Unknown:
     96             default:
     97                 requestType = KeyRequestType::UNKNOWN;
     98                 break;
     99             }
    100         }
    101         _hidl_cb(toStatus(status), toHidlVec(legacyRequest), requestType,
    102                  defaultUrl.string());
    103         return Void();
    104     }
    105 
    106     Return<void> DrmPlugin::provideKeyResponse(const hidl_vec<uint8_t>& scope,
    107             const hidl_vec<uint8_t>& response, provideKeyResponse_cb _hidl_cb) {
    108 
    109         Vector<uint8_t> keySetId;
    110         status_t status = mLegacyPlugin->provideKeyResponse(toVector(scope),
    111                 toVector(response), keySetId);
    112         _hidl_cb(toStatus(status), toHidlVec(keySetId));
    113         return Void();
    114     }
    115 
    116     Return<Status> DrmPlugin::removeKeys(const hidl_vec<uint8_t>& sessionId) {
    117         return toStatus(mLegacyPlugin->removeKeys(toVector(sessionId)));
    118     }
    119 
    120     Return<Status> DrmPlugin::restoreKeys(const hidl_vec<uint8_t>& sessionId,
    121             const hidl_vec<uint8_t>& keySetId) {
    122         status_t legacyStatus = mLegacyPlugin->restoreKeys(toVector(sessionId),
    123                 toVector(keySetId));
    124         return toStatus(legacyStatus);
    125     }
    126 
    127     Return<void> DrmPlugin::queryKeyStatus(const hidl_vec<uint8_t>& sessionId,
    128             queryKeyStatus_cb _hidl_cb) {
    129 
    130         android::KeyedVector<String8, String8> legacyInfoMap;
    131         status_t status = mLegacyPlugin->queryKeyStatus(toVector(sessionId),
    132                 legacyInfoMap);
    133 
    134         Vector<KeyValue> infoMapVec;
    135         for (size_t i = 0; i < legacyInfoMap.size(); i++) {
    136             KeyValue keyValuePair;
    137             keyValuePair.key = String8(legacyInfoMap.keyAt(i));
    138             keyValuePair.value = String8(legacyInfoMap.valueAt(i));
    139             infoMapVec.push_back(keyValuePair);
    140         }
    141         _hidl_cb(toStatus(status), toHidlVec(infoMapVec));
    142         return Void();
    143     }
    144 
    145     Return<void> DrmPlugin::getProvisionRequest(
    146             const hidl_string& certificateType,
    147             const hidl_string& certificateAuthority,
    148             getProvisionRequest_cb _hidl_cb) {
    149 
    150         Vector<uint8_t> legacyRequest;
    151         String8 legacyDefaultUrl;
    152         status_t status = mLegacyPlugin->getProvisionRequest(
    153                 String8(certificateType.c_str()), String8(certificateAuthority.c_str()),
    154                 legacyRequest, legacyDefaultUrl);
    155 
    156         _hidl_cb(toStatus(status), toHidlVec(legacyRequest),
    157                 hidl_string(legacyDefaultUrl));
    158         return Void();
    159     }
    160 
    161     Return<void> DrmPlugin::provideProvisionResponse(
    162             const hidl_vec<uint8_t>& response,
    163             provideProvisionResponse_cb _hidl_cb) {
    164 
    165         Vector<uint8_t> certificate;
    166         Vector<uint8_t> wrappedKey;
    167 
    168         status_t legacyStatus = mLegacyPlugin->provideProvisionResponse(
    169                 toVector(response), certificate, wrappedKey);
    170 
    171         _hidl_cb(toStatus(legacyStatus), toHidlVec(certificate),
    172                 toHidlVec(wrappedKey));
    173         return Void();
    174     }
    175 
    176     Return<void> DrmPlugin::getSecureStops(getSecureStops_cb _hidl_cb) {
    177         List<Vector<uint8_t> > legacySecureStops;
    178         status_t status = mLegacyPlugin->getSecureStops(legacySecureStops);
    179 
    180         Vector<SecureStop> secureStopsVec;
    181         List<Vector<uint8_t> >::iterator iter = legacySecureStops.begin();
    182 
    183         while (iter != legacySecureStops.end()) {
    184             SecureStop secureStop;
    185             secureStop.opaqueData = toHidlVec(*iter++);
    186             secureStopsVec.push_back(secureStop);
    187         }
    188 
    189         _hidl_cb(toStatus(status), toHidlVec(secureStopsVec));
    190         return Void();
    191     }
    192 
    193     Return<void> DrmPlugin::getSecureStop(const hidl_vec<uint8_t>& secureStopId,
    194             getSecureStop_cb _hidl_cb) {
    195 
    196         Vector<uint8_t> legacySecureStop;
    197         status_t status = mLegacyPlugin->getSecureStop(toVector(secureStopId),
    198                 legacySecureStop);
    199 
    200         SecureStop secureStop;
    201         secureStop.opaqueData = toHidlVec(legacySecureStop);
    202         _hidl_cb(toStatus(status), secureStop);
    203         return Void();
    204     }
    205 
    206     Return<Status> DrmPlugin::releaseAllSecureStops() {
    207         return toStatus(mLegacyPlugin->releaseAllSecureStops());
    208     }
    209 
    210     Return<Status> DrmPlugin::releaseSecureStop(
    211             const hidl_vec<uint8_t>& secureStopId) {
    212         status_t legacyStatus =
    213             mLegacyPlugin->releaseSecureStops(toVector(secureStopId));
    214         return toStatus(legacyStatus);
    215     }
    216 
    217     Return<void> DrmPlugin::getPropertyString(const hidl_string& propertyName,
    218             getPropertyString_cb _hidl_cb) {
    219         String8 legacyValue;
    220         status_t status = mLegacyPlugin->getPropertyString(
    221                 String8(propertyName.c_str()), legacyValue);
    222         _hidl_cb(toStatus(status), legacyValue.string());
    223         return Void();
    224     }
    225 
    226     Return<void> DrmPlugin::getPropertyByteArray(const hidl_string& propertyName,
    227             getPropertyByteArray_cb _hidl_cb) {
    228         Vector<uint8_t> legacyValue;
    229         status_t status = mLegacyPlugin->getPropertyByteArray(
    230                 String8(propertyName.c_str()), legacyValue);
    231         _hidl_cb(toStatus(status), toHidlVec(legacyValue));
    232         return Void();
    233     }
    234 
    235     Return<Status> DrmPlugin::setPropertyString(const hidl_string& propertyName,
    236             const hidl_string& value) {
    237         status_t legacyStatus =
    238             mLegacyPlugin->setPropertyString(String8(propertyName.c_str()),
    239                     String8(value.c_str()));
    240         return toStatus(legacyStatus);
    241     }
    242 
    243     Return<Status> DrmPlugin::setPropertyByteArray(
    244             const hidl_string& propertyName, const hidl_vec<uint8_t>& value) {
    245         status_t legacyStatus =
    246             mLegacyPlugin->setPropertyByteArray(String8(propertyName.c_str()),
    247                     toVector(value));
    248         return toStatus(legacyStatus);
    249     }
    250 
    251     Return<Status> DrmPlugin::setCipherAlgorithm(
    252             const hidl_vec<uint8_t>& sessionId, const hidl_string& algorithm) {
    253         status_t legacyStatus =
    254             mLegacyPlugin->setCipherAlgorithm(toVector(sessionId),
    255                 String8(algorithm.c_str()));
    256         return toStatus(legacyStatus);
    257     }
    258 
    259     Return<Status> DrmPlugin::setMacAlgorithm(
    260             const hidl_vec<uint8_t>& sessionId, const hidl_string& algorithm) {
    261         status_t legacyStatus =
    262             mLegacyPlugin->setMacAlgorithm(toVector(sessionId),
    263                 String8(algorithm.c_str()));
    264         return toStatus(legacyStatus);
    265     }
    266 
    267     Return<void> DrmPlugin::encrypt(const hidl_vec<uint8_t>& sessionId,
    268             const hidl_vec<uint8_t>& keyId, const hidl_vec<uint8_t>& input,
    269             const hidl_vec<uint8_t>& iv, encrypt_cb _hidl_cb) {
    270 
    271         Vector<uint8_t> legacyOutput;
    272         status_t status = mLegacyPlugin->encrypt(toVector(sessionId),
    273                 toVector(keyId), toVector(input), toVector(iv), legacyOutput);
    274         _hidl_cb(toStatus(status), toHidlVec(legacyOutput));
    275         return Void();
    276     }
    277 
    278     Return<void> DrmPlugin::decrypt(const hidl_vec<uint8_t>& sessionId,
    279             const hidl_vec<uint8_t>& keyId, const hidl_vec<uint8_t>& input,
    280             const hidl_vec<uint8_t>& iv, decrypt_cb _hidl_cb) {
    281 
    282         Vector<uint8_t> legacyOutput;
    283         status_t status = mLegacyPlugin->decrypt(toVector(sessionId),
    284                 toVector(keyId), toVector(input), toVector(iv), legacyOutput);
    285         _hidl_cb(toStatus(status), toHidlVec(legacyOutput));
    286         return Void();
    287     }
    288 
    289     Return<void> DrmPlugin::sign(const hidl_vec<uint8_t>& sessionId,
    290             const hidl_vec<uint8_t>& keyId, const hidl_vec<uint8_t>& message,
    291             sign_cb _hidl_cb) {
    292         Vector<uint8_t> legacySignature;
    293         status_t status = mLegacyPlugin->sign(toVector(sessionId),
    294                 toVector(keyId), toVector(message), legacySignature);
    295         _hidl_cb(toStatus(status), toHidlVec(legacySignature));
    296         return Void();
    297     }
    298 
    299     Return<void> DrmPlugin::verify(const hidl_vec<uint8_t>& sessionId,
    300             const hidl_vec<uint8_t>& keyId, const hidl_vec<uint8_t>& message,
    301             const hidl_vec<uint8_t>& signature, verify_cb _hidl_cb) {
    302 
    303         bool match;
    304         status_t status = mLegacyPlugin->verify(toVector(sessionId),
    305                 toVector(keyId), toVector(message), toVector(signature),
    306                 match);
    307         _hidl_cb(toStatus(status), match);
    308         return Void();
    309     }
    310 
    311     Return<void> DrmPlugin::signRSA(const hidl_vec<uint8_t>& sessionId,
    312             const hidl_string& algorithm, const hidl_vec<uint8_t>& message,
    313             const hidl_vec<uint8_t>& wrappedKey, signRSA_cb _hidl_cb) {
    314 
    315         Vector<uint8_t> legacySignature;
    316         status_t status = mLegacyPlugin->signRSA(toVector(sessionId),
    317                 String8(algorithm.c_str()), toVector(message), toVector(wrappedKey),
    318                 legacySignature);
    319         _hidl_cb(toStatus(status), toHidlVec(legacySignature));
    320         return Void();
    321     }
    322 
    323     Return<void> DrmPlugin::setListener(const sp<IDrmPluginListener>& listener) {
    324         mListener = listener;
    325         mLegacyPlugin->setListener(listener == NULL ? NULL : this);
    326         return Void();
    327     }
    328 
    329     Return<void> DrmPlugin::sendEvent(EventType eventType,
    330             const hidl_vec<uint8_t>& sessionId, const hidl_vec<uint8_t>& data) {
    331         if (mListener != nullptr) {
    332             mListener->sendEvent(eventType, sessionId, data);
    333         }
    334         return Void();
    335     }
    336 
    337     Return<void> DrmPlugin::sendExpirationUpdate(
    338             const hidl_vec<uint8_t>& sessionId, int64_t expiryTimeInMS) {
    339         if (mListener != nullptr) {
    340             mListener->sendExpirationUpdate(sessionId, expiryTimeInMS);
    341         }
    342         return Void();
    343     }
    344 
    345     Return<void> DrmPlugin::sendKeysChange(const hidl_vec<uint8_t>& sessionId,
    346             const hidl_vec<KeyStatus>& keyStatusList, bool hasNewUsableKey) {
    347         if (mListener != nullptr) {
    348             mListener->sendKeysChange(sessionId, keyStatusList, hasNewUsableKey);
    349         }
    350         return Void();
    351     }
    352 
    353 
    354     // Methods from android::DrmPluginListener
    355 
    356     void DrmPlugin::sendEvent(android::DrmPlugin::EventType legacyEventType,
    357             int /*unused*/, Vector<uint8_t> const *sessionId,
    358             Vector<uint8_t> const *data) {
    359 
    360         EventType eventType;
    361         bool sendEvent = true;
    362         switch(legacyEventType) {
    363         case android::DrmPlugin::kDrmPluginEventProvisionRequired:
    364             eventType = EventType::PROVISION_REQUIRED;
    365             break;
    366         case android::DrmPlugin::kDrmPluginEventKeyNeeded:
    367             eventType = EventType::KEY_NEEDED;
    368             break;
    369         case android::DrmPlugin::kDrmPluginEventKeyExpired:
    370             eventType = EventType::KEY_EXPIRED;
    371             break;
    372         case android::DrmPlugin::kDrmPluginEventVendorDefined:
    373             eventType = EventType::VENDOR_DEFINED;
    374             break;
    375         case android::DrmPlugin::kDrmPluginEventSessionReclaimed:
    376             eventType = EventType::SESSION_RECLAIMED;
    377             break;
    378         default:
    379             sendEvent = false;
    380             break;
    381         }
    382         if (sendEvent) {
    383             Vector<uint8_t> emptyVector;
    384             mListener->sendEvent(eventType,
    385                     toHidlVec(sessionId == NULL ? emptyVector: *sessionId),
    386                     toHidlVec(data == NULL ? emptyVector: *data));
    387         }
    388     }
    389 
    390     void DrmPlugin::sendExpirationUpdate(Vector<uint8_t> const *sessionId,
    391             int64_t expiryTimeInMS) {
    392         mListener->sendExpirationUpdate(toHidlVec(*sessionId), expiryTimeInMS);
    393     }
    394 
    395     void DrmPlugin::sendKeysChange(Vector<uint8_t> const *sessionId,
    396             Vector<android::DrmPlugin::KeyStatus> const *legacyKeyStatusList,
    397             bool hasNewUsableKey) {
    398 
    399         Vector<KeyStatus> keyStatusVec;
    400         for (size_t i = 0; i < legacyKeyStatusList->size(); i++) {
    401             const android::DrmPlugin::KeyStatus &legacyKeyStatus =
    402                 legacyKeyStatusList->itemAt(i);
    403 
    404             KeyStatus keyStatus;
    405 
    406             switch(legacyKeyStatus.mType) {
    407             case android::DrmPlugin::kKeyStatusType_Usable:
    408                 keyStatus.type = KeyStatusType::USABLE;
    409                 break;
    410             case android::DrmPlugin::kKeyStatusType_Expired:
    411                 keyStatus.type = KeyStatusType::EXPIRED;
    412                 break;
    413             case android::DrmPlugin::kKeyStatusType_OutputNotAllowed:
    414                 keyStatus.type = KeyStatusType::OUTPUTNOTALLOWED;
    415                 break;
    416             case android::DrmPlugin::kKeyStatusType_StatusPending:
    417                 keyStatus.type = KeyStatusType::STATUSPENDING;
    418                 break;
    419             case android::DrmPlugin::kKeyStatusType_InternalError:
    420             default:
    421                 keyStatus.type = KeyStatusType::INTERNALERROR;
    422                 break;
    423             }
    424 
    425             keyStatus.keyId = toHidlVec(legacyKeyStatus.mKeyId);
    426             keyStatusVec.push_back(keyStatus);
    427         }
    428         mListener->sendKeysChange(toHidlVec(*sessionId),
    429                 toHidlVec(keyStatusVec), hasNewUsableKey);
    430     }
    431 
    432 }  // namespace implementation
    433 }  // namespace V1_0
    434 }  // namespace drm
    435 }  // namespace hardware
    436 }  // namespace android
    437