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_ENCRYPT,
34 HDCP_DECRYPT,
35 };
36
37 struct BpHDCPObserver : public BpInterface<IHDCPObserver> {
BpHDCPObserverandroid::BpHDCPObserver38 BpHDCPObserver(const sp<IBinder> &impl)
39 : BpInterface<IHDCPObserver>(impl) {
40 }
41
notifyandroid::BpHDCPObserver42 virtual void notify(
43 int msg, int ext1, int ext2, const Parcel *obj) {
44 Parcel data, reply;
45 data.writeInterfaceToken(IHDCPObserver::getInterfaceDescriptor());
46 data.writeInt32(msg);
47 data.writeInt32(ext1);
48 data.writeInt32(ext2);
49 if (obj && obj->dataSize() > 0) {
50 data.appendFrom(const_cast<Parcel *>(obj), 0, obj->dataSize());
51 }
52 remote()->transact(OBSERVER_NOTIFY, data, &reply, IBinder::FLAG_ONEWAY);
53 }
54 };
55
56 IMPLEMENT_META_INTERFACE(HDCPObserver, "android.hardware.IHDCPObserver");
57
58 struct BpHDCP : public BpInterface<IHDCP> {
BpHDCPandroid::BpHDCP59 BpHDCP(const sp<IBinder> &impl)
60 : BpInterface<IHDCP>(impl) {
61 }
62
setObserverandroid::BpHDCP63 virtual status_t setObserver(const sp<IHDCPObserver> &observer) {
64 Parcel data, reply;
65 data.writeInterfaceToken(IHDCP::getInterfaceDescriptor());
66 data.writeStrongBinder(observer->asBinder());
67 remote()->transact(HDCP_SET_OBSERVER, data, &reply);
68 return reply.readInt32();
69 }
70
initAsyncandroid::BpHDCP71 virtual status_t initAsync(const char *host, unsigned port) {
72 Parcel data, reply;
73 data.writeInterfaceToken(IHDCP::getInterfaceDescriptor());
74 data.writeCString(host);
75 data.writeInt32(port);
76 remote()->transact(HDCP_INIT_ASYNC, data, &reply);
77 return reply.readInt32();
78 }
79
shutdownAsyncandroid::BpHDCP80 virtual status_t shutdownAsync() {
81 Parcel data, reply;
82 data.writeInterfaceToken(IHDCP::getInterfaceDescriptor());
83 remote()->transact(HDCP_SHUTDOWN_ASYNC, data, &reply);
84 return reply.readInt32();
85 }
86
encryptandroid::BpHDCP87 virtual status_t encrypt(
88 const void *inData, size_t size, uint32_t streamCTR,
89 uint64_t *outInputCTR, void *outData) {
90 Parcel data, reply;
91 data.writeInterfaceToken(IHDCP::getInterfaceDescriptor());
92 data.writeInt32(size);
93 data.write(inData, size);
94 data.writeInt32(streamCTR);
95 remote()->transact(HDCP_ENCRYPT, data, &reply);
96
97 status_t err = reply.readInt32();
98
99 if (err != OK) {
100 *outInputCTR = 0;
101
102 return err;
103 }
104
105 *outInputCTR = reply.readInt64();
106 reply.read(outData, size);
107
108 return err;
109 }
110
decryptandroid::BpHDCP111 virtual status_t decrypt(
112 const void *inData, size_t size,
113 uint32_t streamCTR, uint64_t inputCTR,
114 void *outData) {
115 Parcel data, reply;
116 data.writeInterfaceToken(IHDCP::getInterfaceDescriptor());
117 data.writeInt32(size);
118 data.write(inData, size);
119 data.writeInt32(streamCTR);
120 data.writeInt64(inputCTR);
121 remote()->transact(HDCP_DECRYPT, data, &reply);
122
123 status_t err = reply.readInt32();
124
125 if (err != OK) {
126 return err;
127 }
128
129 reply.read(outData, size);
130
131 return err;
132 }
133 };
134
135 IMPLEMENT_META_INTERFACE(HDCP, "android.hardware.IHDCP");
136
onTransact(uint32_t code,const Parcel & data,Parcel * reply,uint32_t flags)137 status_t BnHDCPObserver::onTransact(
138 uint32_t code, const Parcel &data, Parcel *reply, uint32_t flags) {
139 switch (code) {
140 case OBSERVER_NOTIFY:
141 {
142 CHECK_INTERFACE(IHDCPObserver, data, reply);
143
144 int msg = data.readInt32();
145 int ext1 = data.readInt32();
146 int ext2 = data.readInt32();
147
148 Parcel obj;
149 if (data.dataAvail() > 0) {
150 obj.appendFrom(
151 const_cast<Parcel *>(&data),
152 data.dataPosition(),
153 data.dataAvail());
154 }
155
156 notify(msg, ext1, ext2, &obj);
157
158 return OK;
159 }
160
161 default:
162 return BBinder::onTransact(code, data, reply, flags);
163 }
164 }
165
onTransact(uint32_t code,const Parcel & data,Parcel * reply,uint32_t flags)166 status_t BnHDCP::onTransact(
167 uint32_t code, const Parcel &data, Parcel *reply, uint32_t flags) {
168 switch (code) {
169 case HDCP_SET_OBSERVER:
170 {
171 CHECK_INTERFACE(IHDCP, data, reply);
172
173 sp<IHDCPObserver> observer =
174 interface_cast<IHDCPObserver>(data.readStrongBinder());
175
176 reply->writeInt32(setObserver(observer));
177 return OK;
178 }
179
180 case HDCP_INIT_ASYNC:
181 {
182 CHECK_INTERFACE(IHDCP, data, reply);
183
184 const char *host = data.readCString();
185 unsigned port = data.readInt32();
186
187 reply->writeInt32(initAsync(host, port));
188 return OK;
189 }
190
191 case HDCP_SHUTDOWN_ASYNC:
192 {
193 CHECK_INTERFACE(IHDCP, data, reply);
194
195 reply->writeInt32(shutdownAsync());
196 return OK;
197 }
198
199 case HDCP_ENCRYPT:
200 {
201 size_t size = data.readInt32();
202
203 void *inData = malloc(2 * size);
204 void *outData = (uint8_t *)inData + size;
205
206 data.read(inData, size);
207
208 uint32_t streamCTR = data.readInt32();
209 uint64_t inputCTR;
210 status_t err = encrypt(inData, size, streamCTR, &inputCTR, outData);
211
212 reply->writeInt32(err);
213
214 if (err == OK) {
215 reply->writeInt64(inputCTR);
216 reply->write(outData, size);
217 }
218
219 free(inData);
220 inData = outData = NULL;
221
222 return OK;
223 }
224
225 case HDCP_DECRYPT:
226 {
227 size_t size = data.readInt32();
228
229 void *inData = malloc(2 * size);
230 void *outData = (uint8_t *)inData + size;
231
232 data.read(inData, size);
233
234 uint32_t streamCTR = data.readInt32();
235 uint64_t inputCTR = data.readInt64();
236 status_t err = decrypt(inData, size, streamCTR, inputCTR, outData);
237
238 reply->writeInt32(err);
239
240 if (err == OK) {
241 reply->write(outData, size);
242 }
243
244 free(inData);
245 inData = outData = NULL;
246
247 return OK;
248 }
249
250 default:
251 return BBinder::onTransact(code, data, reply, flags);
252 }
253 }
254
255 } // namespace android
256