CasManager.cpp revision 3b2847fa5506dc265d2e46f067bfbb66ae209f74 
1/*
2 * Copyright (C) 2017 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 "CasManager"
19#include "CasManager.h"
20
21#include <android/media/ICas.h>
22#include <android/media/IDescrambler.h>
23#include <android/media/IMediaCasService.h>
24#include <binder/IServiceManager.h>
25#include <media/stagefright/foundation/ABitReader.h>
26#include <utils/Log.h>
27
28namespace android {
29using binder::Status;
30
31struct ATSParser::CasManager::ProgramCasManager : public RefBase {
32    ProgramCasManager(unsigned programNumber, const CADescriptor &descriptor);
33    ProgramCasManager(unsigned programNumber);
34
35    bool addStream(unsigned elementaryPID, const CADescriptor &descriptor);
36
37    status_t setMediaCas(const sp<ICas> &cas, PidToSessionMap &sessionMap);
38
39    bool getCasSession(unsigned elementaryPID,
40            sp<IDescrambler> *descrambler, std::vector<uint8_t> *sessionId) const;
41
42    void closeAllSessions(const sp<ICas>& cas);
43
44private:
45    struct CasSession {
46        CasSession() {}
47        CasSession(const CADescriptor &descriptor) :
48            mCADescriptor(descriptor) {}
49
50        CADescriptor mCADescriptor;
51        std::vector<uint8_t> mSessionId;
52        sp<IDescrambler> mDescrambler;
53    };
54    status_t initSession(
55             const sp<ICas>& cas, PidToSessionMap &sessionMap,
56             CasSession *session, unsigned programNumber, unsigned elementaryPID);
57    void closeSession(const sp<ICas>& cas, const CasSession &casSession);
58
59    unsigned mProgramNumber;
60    bool mHasProgramCas;
61    CasSession mProgramCas;
62    KeyedVector<unsigned, CasSession> mStreamPidToCasMap;
63};
64
65ATSParser::CasManager::ProgramCasManager::ProgramCasManager(
66        unsigned programNumber, const CADescriptor &descriptor) :
67    mProgramNumber(programNumber),
68    mHasProgramCas(true),
69    mProgramCas(descriptor) {}
70
71ATSParser::CasManager::ProgramCasManager::ProgramCasManager(
72        unsigned programNumber) :
73    mProgramNumber(programNumber),
74    mHasProgramCas(false) {}
75
76bool ATSParser::CasManager::ProgramCasManager::addStream(
77        unsigned elementaryPID, const CADescriptor &descriptor) {
78    ssize_t index = mStreamPidToCasMap.indexOfKey(elementaryPID);
79    if (index >= 0) {
80        return false;
81    }
82    ALOGV("addStream: program=%d, elementaryPID=%d, CA_system_ID=0x%x",
83            mProgramNumber, elementaryPID, descriptor.mSystemID);
84    mStreamPidToCasMap.add(elementaryPID, CasSession(descriptor));
85    return true;
86}
87
88status_t ATSParser::CasManager::ProgramCasManager::setMediaCas(
89        const sp<ICas> &cas, PidToSessionMap &sessionMap) {
90    if (mHasProgramCas) {
91        return initSession(cas, sessionMap, &mProgramCas, mProgramNumber, 0);
92    }
93    for (size_t index = 0; index < mStreamPidToCasMap.size(); index++) {
94        unsigned elementaryPID = mStreamPidToCasMap.keyAt(index);
95        status_t err;
96        if ((err = initSession(cas, sessionMap,
97                &mStreamPidToCasMap.editValueAt(index),
98                mProgramNumber, elementaryPID)) != OK) {
99            return err;
100        }
101    }
102    return OK;
103}
104
105bool ATSParser::CasManager::ProgramCasManager::getCasSession(
106        unsigned elementaryPID, sp<IDescrambler> *descrambler,
107        std::vector<uint8_t> *sessionId) const {
108    if (mHasProgramCas) {
109        *descrambler = mProgramCas.mDescrambler;
110        *sessionId = mProgramCas.mSessionId;
111        return true;
112    }
113    ssize_t index = mStreamPidToCasMap.indexOfKey(elementaryPID);
114    if (index < 0) {
115        return false;
116    }
117
118    *descrambler = mStreamPidToCasMap[index].mDescrambler;
119    *sessionId = mStreamPidToCasMap[index].mSessionId;
120    return true;
121}
122
123status_t ATSParser::CasManager::ProgramCasManager::initSession(
124         const sp<ICas>& cas, PidToSessionMap &sessionMap,
125         CasSession *session, unsigned programNumber, unsigned elementaryPID) {
126    sp<IServiceManager> sm = defaultServiceManager();
127    sp<IBinder> casServiceBinder = sm->getService(String16("media.cas"));
128    sp<IMediaCasService> casService =
129            interface_cast<IMediaCasService>(casServiceBinder);
130
131    if (casService == NULL) {
132        ALOGE("Cannot obtain IMediaCasService");
133        return NO_INIT;
134    }
135
136    sp<IDescrambler> descrambler;
137    std::vector<uint8_t> sessionId;
138    const CADescriptor &descriptor = session->mCADescriptor;
139
140    Status status;
141    if (elementaryPID == 0) {
142        status = cas->openSession(programNumber, &sessionId);
143    } else {
144        status = cas->openSessionForStream(
145                programNumber, elementaryPID, &sessionId);
146    }
147    if (!status.isOk()) {
148        ALOGE("Failed to open session: exception=%d, error=%d",
149                status.exceptionCode(), status.serviceSpecificErrorCode());
150        goto l_fail;
151    }
152
153    cas->setSessionPrivateData(sessionId, descriptor.mPrivateData);
154    if (!status.isOk()) {
155        ALOGE("Failed to set private data: exception=%d, error=%d",
156                status.exceptionCode(), status.serviceSpecificErrorCode());
157        goto l_fail;
158    }
159
160    status = casService->createDescrambler(descriptor.mSystemID, &descrambler);
161    if (!status.isOk() || descrambler == NULL) {
162        ALOGE("Failed to create descrambler: : exception=%d, error=%d",
163                status.exceptionCode(), status.serviceSpecificErrorCode());
164        goto l_fail;
165    }
166
167    status = descrambler->setMediaCasSession(sessionId);
168    if (!status.isOk()) {
169        ALOGE("Failed to init descrambler: : exception=%d, error=%d",
170                status.exceptionCode(), status.serviceSpecificErrorCode());
171        goto l_fail;
172    }
173
174    session->mSessionId = sessionId;
175    session->mDescrambler = descrambler;
176    sessionMap.add(descriptor.mPID, sessionId);
177
178    return OK;
179
180l_fail:
181    if (!sessionId.empty()) {
182        cas->closeSession(sessionId);
183    }
184    if (descrambler != NULL) {
185        descrambler->release();
186    }
187    return NO_INIT;
188}
189
190void ATSParser::CasManager::ProgramCasManager::closeSession(
191        const sp<ICas>& cas, const CasSession &casSession) {
192    if (casSession.mDescrambler != NULL) {
193        casSession.mDescrambler->release();
194    }
195    if (!casSession.mSessionId.empty()) {
196        cas->closeSession(casSession.mSessionId);
197    }
198}
199
200void ATSParser::CasManager::ProgramCasManager::closeAllSessions(
201        const sp<ICas>& cas) {
202    if (mHasProgramCas) {
203        closeSession(cas, mProgramCas);
204    }
205    for (size_t index = 0; index < mStreamPidToCasMap.size(); index++) {
206        closeSession(cas, mStreamPidToCasMap.editValueAt(index));
207    }
208}
209
210////////////////////////////////////////////////////////////////////////////////
211
212ATSParser::CasManager::CasManager() : mSystemId(-1) {}
213
214ATSParser::CasManager::~CasManager() {
215    // Explictly close the sessions opened by us, since the CAS object is owned
216    // by the app and may not go away after the parser is destroyed, and the app
217    // may not have information about the sessions.
218    if (mICas != NULL) {
219        for (size_t index = 0; index < mProgramCasMap.size(); index++) {
220            mProgramCasMap.editValueAt(index)->closeAllSessions(mICas);
221        }
222    }
223}
224
225bool ATSParser::CasManager::setSystemId(int32_t CA_system_ID) {
226    if (mSystemId == -1) {
227        // Verify the CA_system_ID is within range on the first program
228        if (CA_system_ID < 0 || CA_system_ID > 0xffff) {
229            ALOGE("Invalid CA_system_id: %d", CA_system_ID);
230            return false;
231        }
232        mSystemId = CA_system_ID;
233    } else if (mSystemId != CA_system_ID) {
234        // All sessions need to be under the same CA system
235        ALOGE("Multiple CA systems not allowed: %d vs %d",
236                mSystemId, CA_system_ID);
237        return false;
238    }
239    return true;
240}
241
242status_t ATSParser::CasManager::setMediaCas(const sp<ICas> &cas) {
243    if (cas == NULL) {
244        ALOGE("setMediaCas: received NULL object");
245        return BAD_VALUE;
246    }
247    if (mICas != NULL) {
248        ALOGW("setMediaCas: already set");
249        return ALREADY_EXISTS;
250    }
251    for (size_t index = 0; index < mProgramCasMap.size(); index++) {
252        status_t err;
253        if ((err = mProgramCasMap.editValueAt(
254                index)->setMediaCas(cas, mCAPidToSessionIdMap)) != OK) {
255            return err;
256        }
257    }
258    mICas = cas;
259    return OK;
260}
261
262bool ATSParser::CasManager::addProgram(
263        unsigned programNumber, const CADescriptor &descriptor) {
264    if (!setSystemId(descriptor.mSystemID)) {
265        return false;
266    }
267
268    ssize_t index = mProgramCasMap.indexOfKey(programNumber);
269    if (index < 0) {
270        ALOGV("addProgram: programNumber=%d, CA_system_ID=0x%x",
271                programNumber, descriptor.mSystemID);
272        mProgramCasMap.add(programNumber,
273                new ProgramCasManager(programNumber, descriptor));
274        mCAPidSet.insert(descriptor.mPID);
275    }
276    return true;
277}
278
279bool ATSParser::CasManager::addStream(
280        unsigned programNumber, unsigned elementaryPID,
281        const CADescriptor &descriptor) {
282    if (!setSystemId(descriptor.mSystemID)) {
283        return false;
284    }
285
286    ssize_t index = mProgramCasMap.indexOfKey(programNumber);
287    sp<ProgramCasManager> programCasManager;
288    if (index < 0) {
289        ALOGV("addProgram (no CADescriptor): programNumber=%d", programNumber);
290        programCasManager = new ProgramCasManager(programNumber);
291        mProgramCasMap.add(programNumber, programCasManager);
292    } else {
293        programCasManager = mProgramCasMap.editValueAt(index);
294    }
295    if (programCasManager->addStream(elementaryPID, descriptor)) {
296        mCAPidSet.insert(descriptor.mPID);
297    }
298    return true;
299}
300
301bool ATSParser::CasManager::getCasSession(
302        unsigned programNumber, unsigned elementaryPID,
303        sp<IDescrambler> *descrambler, std::vector<uint8_t> *sessionId) const {
304    ssize_t index = mProgramCasMap.indexOfKey(programNumber);
305    if (index < 0) {
306        return false;
307    }
308    return mProgramCasMap[index]->getCasSession(
309            elementaryPID, descrambler, sessionId);
310}
311
312bool ATSParser::CasManager::isCAPid(unsigned pid) {
313    return mCAPidSet.find(pid) != mCAPidSet.end();
314}
315
316bool ATSParser::CasManager::parsePID(ABitReader *br, unsigned pid) {
317    ssize_t index = mCAPidToSessionIdMap.indexOfKey(pid);
318    if (index < 0) {
319        return false;
320    }
321    MediaCas::ParcelableCasData ecm(br->data(), br->numBitsLeft() / 8);
322    Status status = mICas->processEcm(mCAPidToSessionIdMap[index], ecm);
323    if (!status.isOk()) {
324        ALOGE("Failed to process ECM: exception=%d, error=%d",
325                status.exceptionCode(), status.serviceSpecificErrorCode());
326    }
327    return true; // handled
328}
329
330}  // namespace android
331