1 /*
2 * Copyright (C) 2012 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 "IHDCP"
19 #include <utils/Log.h>
20
21 #include <binder/Parcel.h>
22 #include <media/IHDCP.h>
23 #include <media/stagefright/MediaErrors.h>
24 #include <media/stagefright/foundation/ADebug.h>
25
26 namespace android {
27
28 enum {
29 OBSERVER_NOTIFY = IBinder::FIRST_CALL_TRANSACTION,
30 HDCP_SET_OBSERVER,
31 HDCP_INIT_ASYNC,
32 HDCP_SHUTDOWN_ASYNC,
33 HDCP_GET_CAPS,
34 HDCP_ENCRYPT,
35 HDCP_ENCRYPT_NATIVE,
36 HDCP_DECRYPT,
37 };
38
39 struct BpHDCPObserver : public BpInterface<IHDCPObserver> {
BpHDCPObserverandroid::BpHDCPObserver40 explicit BpHDCPObserver(const sp<IBinder> &impl)
41 : BpInterface<IHDCPObserver>(impl) {
42 }
43
notifyandroid::BpHDCPObserver44 virtual void notify(
45 int msg, int ext1, int ext2, const Parcel *obj) {
46 Parcel data, reply;
47 data.writeInterfaceToken(IHDCPObserver::getInterfaceDescriptor());
48 data.writeInt32(msg);
49 data.writeInt32(ext1);
50 data.writeInt32(ext2);
51 if (obj && obj->dataSize() > 0) {
52 data.appendFrom(const_cast<Parcel *>(obj), 0, obj->dataSize());
53 }
54 remote()->transact(OBSERVER_NOTIFY, data, &reply, IBinder::FLAG_ONEWAY);
55 }
56 };
57
58 IMPLEMENT_META_INTERFACE(HDCPObserver, "android.hardware.IHDCPObserver");
59
60 struct BpHDCP : public BpInterface<IHDCP> {
BpHDCPandroid::BpHDCP61 explicit BpHDCP(const sp<IBinder> &impl)
62 : BpInterface<IHDCP>(impl) {
63 }
64
setObserverandroid::BpHDCP65 virtual status_t setObserver(const sp<IHDCPObserver> &observer) {
66 Parcel data, reply;
67 data.writeInterfaceToken(IHDCP::getInterfaceDescriptor());
68 data.writeStrongBinder(IInterface::asBinder(observer));
69 remote()->transact(HDCP_SET_OBSERVER, data, &reply);
70 return reply.readInt32();
71 }
72
initAsyncandroid::BpHDCP73 virtual status_t initAsync(const char *host, unsigned port) {
74 Parcel data, reply;
75 data.writeInterfaceToken(IHDCP::getInterfaceDescriptor());
76 data.writeCString(host);
77 data.writeInt32(port);
78 remote()->transact(HDCP_INIT_ASYNC, data, &reply);
79 return reply.readInt32();
80 }
81
shutdownAsyncandroid::BpHDCP82 virtual status_t shutdownAsync() {
83 Parcel data, reply;
84 data.writeInterfaceToken(IHDCP::getInterfaceDescriptor());
85 remote()->transact(HDCP_SHUTDOWN_ASYNC, data, &reply);
86 return reply.readInt32();
87 }
88
getCapsandroid::BpHDCP89 virtual uint32_t getCaps() {
90 Parcel data, reply;
91 data.writeInterfaceToken(IHDCP::getInterfaceDescriptor());
92 remote()->transact(HDCP_GET_CAPS, data, &reply);
93 return reply.readInt32();
94 }
95
encryptandroid::BpHDCP96 virtual status_t encrypt(
97 const void *inData, size_t size, uint32_t streamCTR,
98 uint64_t *outInputCTR, void *outData) {
99 Parcel data, reply;
100 data.writeInterfaceToken(IHDCP::getInterfaceDescriptor());
101 data.writeInt32(size);
102 data.write(inData, size);
103 data.writeInt32(streamCTR);
104 remote()->transact(HDCP_ENCRYPT, data, &reply);
105
106 status_t err = reply.readInt32();
107
108 if (err != OK) {
109 *outInputCTR = 0;
110
111 return err;
112 }
113
114 *outInputCTR = reply.readInt64();
115 reply.read(outData, size);
116
117 return err;
118 }
119
encryptNativeandroid::BpHDCP120 virtual status_t encryptNative(
121 const sp<GraphicBuffer> &graphicBuffer,
122 size_t offset, size_t size, uint32_t streamCTR,
123 uint64_t *outInputCTR, void *outData) {
124 Parcel data, reply;
125 data.writeInterfaceToken(IHDCP::getInterfaceDescriptor());
126 data.write(*graphicBuffer);
127 data.writeInt32(offset);
128 data.writeInt32(size);
129 data.writeInt32(streamCTR);
130 remote()->transact(HDCP_ENCRYPT_NATIVE, data, &reply);
131
132 status_t err = reply.readInt32();
133
134 if (err != OK) {
135 *outInputCTR = 0;
136 return err;
137 }
138
139 *outInputCTR = reply.readInt64();
140 reply.read(outData, size);
141
142 return err;
143 }
144
decryptandroid::BpHDCP145 virtual status_t decrypt(
146 const void *inData, size_t size,
147 uint32_t streamCTR, uint64_t inputCTR,
148 void *outData) {
149 Parcel data, reply;
150 data.writeInterfaceToken(IHDCP::getInterfaceDescriptor());
151 data.writeInt32(size);
152 data.write(inData, size);
153 data.writeInt32(streamCTR);
154 data.writeInt64(inputCTR);
155 remote()->transact(HDCP_DECRYPT, data, &reply);
156
157 status_t err = reply.readInt32();
158
159 if (err != OK) {
160 return err;
161 }
162
163 reply.read(outData, size);
164
165 return err;
166 }
167 };
168
169 IMPLEMENT_META_INTERFACE(HDCP, "android.hardware.IHDCP");
170
onTransact(uint32_t code,const Parcel & data,Parcel * reply,uint32_t flags)171 status_t BnHDCPObserver::onTransact(
172 uint32_t code, const Parcel &data, Parcel *reply, uint32_t flags) {
173 switch (code) {
174 case OBSERVER_NOTIFY:
175 {
176 CHECK_INTERFACE(IHDCPObserver, data, reply);
177
178 int msg = data.readInt32();
179 int ext1 = data.readInt32();
180 int ext2 = data.readInt32();
181
182 Parcel obj;
183 if (data.dataAvail() > 0) {
184 obj.appendFrom(
185 const_cast<Parcel *>(&data),
186 data.dataPosition(),
187 data.dataAvail());
188 }
189
190 notify(msg, ext1, ext2, &obj);
191
192 return OK;
193 }
194
195 default:
196 return BBinder::onTransact(code, data, reply, flags);
197 }
198 }
199
onTransact(uint32_t code,const Parcel & data,Parcel * reply,uint32_t flags)200 status_t BnHDCP::onTransact(
201 uint32_t code, const Parcel &data, Parcel *reply, uint32_t flags) {
202 switch (code) {
203 case HDCP_SET_OBSERVER:
204 {
205 CHECK_INTERFACE(IHDCP, data, reply);
206
207 sp<IHDCPObserver> observer =
208 interface_cast<IHDCPObserver>(data.readStrongBinder());
209
210 reply->writeInt32(setObserver(observer));
211 return OK;
212 }
213
214 case HDCP_INIT_ASYNC:
215 {
216 CHECK_INTERFACE(IHDCP, data, reply);
217
218 const char *host = data.readCString();
219 unsigned port = data.readInt32();
220
221 reply->writeInt32(initAsync(host, port));
222 return OK;
223 }
224
225 case HDCP_SHUTDOWN_ASYNC:
226 {
227 CHECK_INTERFACE(IHDCP, data, reply);
228
229 reply->writeInt32(shutdownAsync());
230 return OK;
231 }
232
233 case HDCP_GET_CAPS:
234 {
235 CHECK_INTERFACE(IHDCP, data, reply);
236
237 reply->writeInt32(getCaps());
238 return OK;
239 }
240
241 case HDCP_ENCRYPT:
242 {
243 CHECK_INTERFACE(IHDCP, data, reply);
244
245 size_t size = data.readInt32();
246 void *inData = NULL;
247 // watch out for overflow
248 if (size <= SIZE_MAX / 2) {
249 inData = malloc(2 * size);
250 }
251 if (inData == NULL) {
252 reply->writeInt32(ERROR_OUT_OF_RANGE);
253 return OK;
254 }
255
256 void *outData = (uint8_t *)inData + size;
257
258 status_t err = data.read(inData, size);
259 if (err != OK) {
260 free(inData);
261 reply->writeInt32(err);
262 return OK;
263 }
264
265 uint32_t streamCTR = data.readInt32();
266 uint64_t inputCTR;
267 err = encrypt(inData, size, streamCTR, &inputCTR, outData);
268
269 reply->writeInt32(err);
270
271 if (err == OK) {
272 reply->writeInt64(inputCTR);
273 reply->write(outData, size);
274 }
275
276 free(inData);
277 inData = outData = NULL;
278
279 return OK;
280 }
281
282 case HDCP_ENCRYPT_NATIVE:
283 {
284 CHECK_INTERFACE(IHDCP, data, reply);
285
286 sp<GraphicBuffer> graphicBuffer = new GraphicBuffer();
287 data.read(*graphicBuffer);
288 size_t offset = data.readInt32();
289 size_t size = data.readInt32();
290 uint32_t streamCTR = data.readInt32();
291 void *outData = NULL;
292 uint64_t inputCTR;
293
294 status_t err = ERROR_OUT_OF_RANGE;
295
296 outData = malloc(size);
297
298 if (outData != NULL) {
299 err = encryptNative(graphicBuffer, offset, size,
300 streamCTR, &inputCTR, outData);
301 }
302
303 reply->writeInt32(err);
304
305 if (err == OK) {
306 reply->writeInt64(inputCTR);
307 reply->write(outData, size);
308 }
309
310 free(outData);
311 outData = NULL;
312
313 return OK;
314 }
315
316 case HDCP_DECRYPT:
317 {
318 CHECK_INTERFACE(IHDCP, data, reply);
319
320 size_t size = data.readInt32();
321 size_t bufSize = 2 * size;
322
323 // watch out for overflow
324 void *inData = NULL;
325 if (bufSize > size) {
326 inData = malloc(bufSize);
327 }
328
329 if (inData == NULL) {
330 reply->writeInt32(ERROR_OUT_OF_RANGE);
331 return OK;
332 }
333
334 void *outData = (uint8_t *)inData + size;
335
336 data.read(inData, size);
337
338 uint32_t streamCTR = data.readInt32();
339 uint64_t inputCTR = data.readInt64();
340 status_t err = decrypt(inData, size, streamCTR, inputCTR, outData);
341
342 reply->writeInt32(err);
343
344 if (err == OK) {
345 reply->write(outData, size);
346 }
347
348 free(inData);
349 inData = outData = NULL;
350
351 return OK;
352 }
353
354 default:
355 return BBinder::onTransact(code, data, reply, flags);
356 }
357 }
358
359 } // namespace android
360