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_TAG "Parcel"
18 //#define LOG_NDEBUG 0
19
20 #include "android_os_Parcel.h"
21 #include "android_util_Binder.h"
22
23 #include "JNIHelp.h"
24
25 #include <fcntl.h>
26 #include <stdio.h>
27 #include <sys/stat.h>
28 #include <sys/types.h>
29 #include <unistd.h>
30
31 #include <utils/Atomic.h>
32 #include <binder/IInterface.h>
33 #include <binder/IPCThreadState.h>
34 #include <utils/Log.h>
35 #include <utils/SystemClock.h>
36 #include <utils/List.h>
37 #include <utils/KeyedVector.h>
38 #include <binder/Parcel.h>
39 #include <binder/ProcessState.h>
40 #include <binder/IServiceManager.h>
41 #include <utils/threads.h>
42 #include <utils/String8.h>
43
44 #include <ScopedUtfChars.h>
45 #include <ScopedLocalRef.h>
46
47 #include <android_runtime/AndroidRuntime.h>
48
49 #include "core_jni_helpers.h"
50
51 //#undef ALOGV
52 //#define ALOGV(...) fprintf(stderr, __VA_ARGS__)
53
54 #define DEBUG_DEATH 0
55 #if DEBUG_DEATH
56 #define LOGDEATH ALOGD
57 #else
58 #define LOGDEATH ALOGV
59 #endif
60
61 namespace android {
62
63 static struct parcel_offsets_t
64 {
65 jclass clazz;
66 jfieldID mNativePtr;
67 jmethodID obtain;
68 jmethodID recycle;
69 } gParcelOffsets;
70
parcelForJavaObject(JNIEnv * env,jobject obj)71 Parcel* parcelForJavaObject(JNIEnv* env, jobject obj)
72 {
73 if (obj) {
74 Parcel* p = (Parcel*)env->GetLongField(obj, gParcelOffsets.mNativePtr);
75 if (p != NULL) {
76 return p;
77 }
78 jniThrowException(env, "java/lang/IllegalStateException", "Parcel has been finalized!");
79 }
80 return NULL;
81 }
82
createJavaParcelObject(JNIEnv * env)83 jobject createJavaParcelObject(JNIEnv* env)
84 {
85 return env->CallStaticObjectMethod(gParcelOffsets.clazz, gParcelOffsets.obtain);
86 }
87
recycleJavaParcelObject(JNIEnv * env,jobject parcelObj)88 void recycleJavaParcelObject(JNIEnv* env, jobject parcelObj)
89 {
90 env->CallVoidMethod(parcelObj, gParcelOffsets.recycle);
91 }
92
android_os_Parcel_dataSize(JNIEnv * env,jclass clazz,jlong nativePtr)93 static jint android_os_Parcel_dataSize(JNIEnv* env, jclass clazz, jlong nativePtr)
94 {
95 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
96 return parcel ? parcel->dataSize() : 0;
97 }
98
android_os_Parcel_dataAvail(JNIEnv * env,jclass clazz,jlong nativePtr)99 static jint android_os_Parcel_dataAvail(JNIEnv* env, jclass clazz, jlong nativePtr)
100 {
101 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
102 return parcel ? parcel->dataAvail() : 0;
103 }
104
android_os_Parcel_dataPosition(JNIEnv * env,jclass clazz,jlong nativePtr)105 static jint android_os_Parcel_dataPosition(JNIEnv* env, jclass clazz, jlong nativePtr)
106 {
107 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
108 return parcel ? parcel->dataPosition() : 0;
109 }
110
android_os_Parcel_dataCapacity(JNIEnv * env,jclass clazz,jlong nativePtr)111 static jint android_os_Parcel_dataCapacity(JNIEnv* env, jclass clazz, jlong nativePtr)
112 {
113 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
114 return parcel ? parcel->dataCapacity() : 0;
115 }
116
android_os_Parcel_setDataSize(JNIEnv * env,jclass clazz,jlong nativePtr,jint size)117 static jlong android_os_Parcel_setDataSize(JNIEnv* env, jclass clazz, jlong nativePtr, jint size)
118 {
119 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
120 if (parcel != NULL) {
121 const status_t err = parcel->setDataSize(size);
122 if (err != NO_ERROR) {
123 signalExceptionForError(env, clazz, err);
124 }
125 return parcel->getOpenAshmemSize();
126 }
127 return 0;
128 }
129
android_os_Parcel_setDataPosition(JNIEnv * env,jclass clazz,jlong nativePtr,jint pos)130 static void android_os_Parcel_setDataPosition(JNIEnv* env, jclass clazz, jlong nativePtr, jint pos)
131 {
132 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
133 if (parcel != NULL) {
134 parcel->setDataPosition(pos);
135 }
136 }
137
android_os_Parcel_setDataCapacity(JNIEnv * env,jclass clazz,jlong nativePtr,jint size)138 static void android_os_Parcel_setDataCapacity(JNIEnv* env, jclass clazz, jlong nativePtr, jint size)
139 {
140 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
141 if (parcel != NULL) {
142 const status_t err = parcel->setDataCapacity(size);
143 if (err != NO_ERROR) {
144 signalExceptionForError(env, clazz, err);
145 }
146 }
147 }
148
android_os_Parcel_pushAllowFds(JNIEnv * env,jclass clazz,jlong nativePtr,jboolean allowFds)149 static jboolean android_os_Parcel_pushAllowFds(JNIEnv* env, jclass clazz, jlong nativePtr, jboolean allowFds)
150 {
151 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
152 jboolean ret = JNI_TRUE;
153 if (parcel != NULL) {
154 ret = (jboolean)parcel->pushAllowFds(allowFds);
155 }
156 return ret;
157 }
158
android_os_Parcel_restoreAllowFds(JNIEnv * env,jclass clazz,jlong nativePtr,jboolean lastValue)159 static void android_os_Parcel_restoreAllowFds(JNIEnv* env, jclass clazz, jlong nativePtr, jboolean lastValue)
160 {
161 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
162 if (parcel != NULL) {
163 parcel->restoreAllowFds((bool)lastValue);
164 }
165 }
166
android_os_Parcel_writeNative(JNIEnv * env,jclass clazz,jlong nativePtr,jobject data,jint offset,jint length)167 static void android_os_Parcel_writeNative(JNIEnv* env, jclass clazz, jlong nativePtr, jobject data,
168 jint offset, jint length)
169 {
170 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
171 if (parcel == NULL) {
172 return;
173 }
174
175 const status_t err = parcel->writeInt32(length);
176 if (err != NO_ERROR) {
177 signalExceptionForError(env, clazz, err);
178 return;
179 }
180
181 void* dest = parcel->writeInplace(length);
182 if (dest == NULL) {
183 signalExceptionForError(env, clazz, NO_MEMORY);
184 return;
185 }
186
187 jbyte* ar = (jbyte*)env->GetPrimitiveArrayCritical((jarray)data, 0);
188 if (ar) {
189 memcpy(dest, ar + offset, length);
190 env->ReleasePrimitiveArrayCritical((jarray)data, ar, 0);
191 }
192 }
193
android_os_Parcel_writeBlob(JNIEnv * env,jclass clazz,jlong nativePtr,jobject data,jint offset,jint length)194 static void android_os_Parcel_writeBlob(JNIEnv* env, jclass clazz, jlong nativePtr, jobject data,
195 jint offset, jint length) {
196 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
197 if (parcel == NULL) {
198 return;
199 }
200
201 if (data == NULL) {
202 const status_t err = parcel->writeInt32(-1);
203 if (err != NO_ERROR) {
204 signalExceptionForError(env, clazz, err);
205 }
206 return;
207 }
208
209 const status_t err = parcel->writeInt32(length);
210 if (err != NO_ERROR) {
211 signalExceptionForError(env, clazz, err);
212 return;
213 }
214
215 android::Parcel::WritableBlob blob;
216 android::status_t err2 = parcel->writeBlob(length, false, &blob);
217 if (err2 != NO_ERROR) {
218 signalExceptionForError(env, clazz, err2);
219 return;
220 }
221
222 jbyte* ar = (jbyte*)env->GetPrimitiveArrayCritical((jarray)data, 0);
223 if (ar == NULL) {
224 memset(blob.data(), 0, length);
225 } else {
226 memcpy(blob.data(), ar + offset, length);
227 env->ReleasePrimitiveArrayCritical((jarray)data, ar, 0);
228 }
229
230 blob.release();
231 }
232
android_os_Parcel_writeInt(JNIEnv * env,jclass clazz,jlong nativePtr,jint val)233 static void android_os_Parcel_writeInt(JNIEnv* env, jclass clazz, jlong nativePtr, jint val) {
234 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
235 if (parcel != NULL) {
236 const status_t err = parcel->writeInt32(val);
237 if (err != NO_ERROR) {
238 signalExceptionForError(env, clazz, err);
239 }
240 }
241 }
242
android_os_Parcel_writeLong(JNIEnv * env,jclass clazz,jlong nativePtr,jlong val)243 static void android_os_Parcel_writeLong(JNIEnv* env, jclass clazz, jlong nativePtr, jlong val)
244 {
245 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
246 if (parcel != NULL) {
247 const status_t err = parcel->writeInt64(val);
248 if (err != NO_ERROR) {
249 signalExceptionForError(env, clazz, err);
250 }
251 }
252 }
253
android_os_Parcel_writeFloat(JNIEnv * env,jclass clazz,jlong nativePtr,jfloat val)254 static void android_os_Parcel_writeFloat(JNIEnv* env, jclass clazz, jlong nativePtr, jfloat val)
255 {
256 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
257 if (parcel != NULL) {
258 const status_t err = parcel->writeFloat(val);
259 if (err != NO_ERROR) {
260 signalExceptionForError(env, clazz, err);
261 }
262 }
263 }
264
android_os_Parcel_writeDouble(JNIEnv * env,jclass clazz,jlong nativePtr,jdouble val)265 static void android_os_Parcel_writeDouble(JNIEnv* env, jclass clazz, jlong nativePtr, jdouble val)
266 {
267 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
268 if (parcel != NULL) {
269 const status_t err = parcel->writeDouble(val);
270 if (err != NO_ERROR) {
271 signalExceptionForError(env, clazz, err);
272 }
273 }
274 }
275
android_os_Parcel_writeString(JNIEnv * env,jclass clazz,jlong nativePtr,jstring val)276 static void android_os_Parcel_writeString(JNIEnv* env, jclass clazz, jlong nativePtr, jstring val)
277 {
278 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
279 if (parcel != NULL) {
280 status_t err = NO_MEMORY;
281 if (val) {
282 const jchar* str = env->GetStringCritical(val, 0);
283 if (str) {
284 err = parcel->writeString16(
285 reinterpret_cast<const char16_t*>(str),
286 env->GetStringLength(val));
287 env->ReleaseStringCritical(val, str);
288 }
289 } else {
290 err = parcel->writeString16(NULL, 0);
291 }
292 if (err != NO_ERROR) {
293 signalExceptionForError(env, clazz, err);
294 }
295 }
296 }
297
android_os_Parcel_writeStrongBinder(JNIEnv * env,jclass clazz,jlong nativePtr,jobject object)298 static void android_os_Parcel_writeStrongBinder(JNIEnv* env, jclass clazz, jlong nativePtr, jobject object)
299 {
300 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
301 if (parcel != NULL) {
302 const status_t err = parcel->writeStrongBinder(ibinderForJavaObject(env, object));
303 if (err != NO_ERROR) {
304 signalExceptionForError(env, clazz, err);
305 }
306 }
307 }
308
android_os_Parcel_writeFileDescriptor(JNIEnv * env,jclass clazz,jlong nativePtr,jobject object)309 static jlong android_os_Parcel_writeFileDescriptor(JNIEnv* env, jclass clazz, jlong nativePtr, jobject object)
310 {
311 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
312 if (parcel != NULL) {
313 const status_t err =
314 parcel->writeDupFileDescriptor(jniGetFDFromFileDescriptor(env, object));
315 if (err != NO_ERROR) {
316 signalExceptionForError(env, clazz, err);
317 }
318 return parcel->getOpenAshmemSize();
319 }
320 return 0;
321 }
322
android_os_Parcel_createByteArray(JNIEnv * env,jclass clazz,jlong nativePtr)323 static jbyteArray android_os_Parcel_createByteArray(JNIEnv* env, jclass clazz, jlong nativePtr)
324 {
325 jbyteArray ret = NULL;
326
327 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
328 if (parcel != NULL) {
329 int32_t len = parcel->readInt32();
330
331 // sanity check the stored length against the true data size
332 if (len >= 0 && len <= (int32_t)parcel->dataAvail()) {
333 ret = env->NewByteArray(len);
334
335 if (ret != NULL) {
336 jbyte* a2 = (jbyte*)env->GetPrimitiveArrayCritical(ret, 0);
337 if (a2) {
338 const void* data = parcel->readInplace(len);
339 memcpy(a2, data, len);
340 env->ReleasePrimitiveArrayCritical(ret, a2, 0);
341 }
342 }
343 }
344 }
345
346 return ret;
347 }
348
android_os_Parcel_readBlob(JNIEnv * env,jclass clazz,jlong nativePtr)349 static jbyteArray android_os_Parcel_readBlob(JNIEnv* env, jclass clazz, jlong nativePtr)
350 {
351 jbyteArray ret = NULL;
352
353 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
354 if (parcel != NULL) {
355 int32_t len = parcel->readInt32();
356 if (len >= 0) {
357 android::Parcel::ReadableBlob blob;
358 android::status_t err = parcel->readBlob(len, &blob);
359 if (err != NO_ERROR) {
360 signalExceptionForError(env, clazz, err);
361 return NULL;
362 }
363
364 ret = env->NewByteArray(len);
365 if (ret != NULL) {
366 jbyte* a2 = (jbyte*)env->GetPrimitiveArrayCritical(ret, 0);
367 if (a2) {
368 memcpy(a2, blob.data(), len);
369 env->ReleasePrimitiveArrayCritical(ret, a2, 0);
370 }
371 }
372 blob.release();
373 }
374 }
375
376 return ret;
377 }
378
android_os_Parcel_readInt(JNIEnv * env,jclass clazz,jlong nativePtr)379 static jint android_os_Parcel_readInt(JNIEnv* env, jclass clazz, jlong nativePtr)
380 {
381 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
382 if (parcel != NULL) {
383 return parcel->readInt32();
384 }
385 return 0;
386 }
387
android_os_Parcel_readLong(JNIEnv * env,jclass clazz,jlong nativePtr)388 static jlong android_os_Parcel_readLong(JNIEnv* env, jclass clazz, jlong nativePtr)
389 {
390 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
391 if (parcel != NULL) {
392 return parcel->readInt64();
393 }
394 return 0;
395 }
396
android_os_Parcel_readFloat(JNIEnv * env,jclass clazz,jlong nativePtr)397 static jfloat android_os_Parcel_readFloat(JNIEnv* env, jclass clazz, jlong nativePtr)
398 {
399 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
400 if (parcel != NULL) {
401 return parcel->readFloat();
402 }
403 return 0;
404 }
405
android_os_Parcel_readDouble(JNIEnv * env,jclass clazz,jlong nativePtr)406 static jdouble android_os_Parcel_readDouble(JNIEnv* env, jclass clazz, jlong nativePtr)
407 {
408 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
409 if (parcel != NULL) {
410 return parcel->readDouble();
411 }
412 return 0;
413 }
414
android_os_Parcel_readString(JNIEnv * env,jclass clazz,jlong nativePtr)415 static jstring android_os_Parcel_readString(JNIEnv* env, jclass clazz, jlong nativePtr)
416 {
417 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
418 if (parcel != NULL) {
419 size_t len;
420 const char16_t* str = parcel->readString16Inplace(&len);
421 if (str) {
422 return env->NewString(reinterpret_cast<const jchar*>(str), len);
423 }
424 return NULL;
425 }
426 return NULL;
427 }
428
android_os_Parcel_readStrongBinder(JNIEnv * env,jclass clazz,jlong nativePtr)429 static jobject android_os_Parcel_readStrongBinder(JNIEnv* env, jclass clazz, jlong nativePtr)
430 {
431 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
432 if (parcel != NULL) {
433 return javaObjectForIBinder(env, parcel->readStrongBinder());
434 }
435 return NULL;
436 }
437
android_os_Parcel_readFileDescriptor(JNIEnv * env,jclass clazz,jlong nativePtr)438 static jobject android_os_Parcel_readFileDescriptor(JNIEnv* env, jclass clazz, jlong nativePtr)
439 {
440 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
441 if (parcel != NULL) {
442 int fd = parcel->readFileDescriptor();
443 if (fd < 0) return NULL;
444 fd = dup(fd);
445 if (fd < 0) return NULL;
446 return jniCreateFileDescriptor(env, fd);
447 }
448 return NULL;
449 }
450
android_os_Parcel_openFileDescriptor(JNIEnv * env,jclass clazz,jstring name,jint mode)451 static jobject android_os_Parcel_openFileDescriptor(JNIEnv* env, jclass clazz,
452 jstring name, jint mode)
453 {
454 if (name == NULL) {
455 jniThrowNullPointerException(env, NULL);
456 return NULL;
457 }
458 const jchar* str = env->GetStringCritical(name, 0);
459 if (str == NULL) {
460 // Whatever, whatever.
461 jniThrowException(env, "java/lang/IllegalStateException", NULL);
462 return NULL;
463 }
464 String8 name8(reinterpret_cast<const char16_t*>(str),
465 env->GetStringLength(name));
466 env->ReleaseStringCritical(name, str);
467 int flags=0;
468 switch (mode&0x30000000) {
469 case 0:
470 case 0x10000000:
471 flags = O_RDONLY;
472 break;
473 case 0x20000000:
474 flags = O_WRONLY;
475 break;
476 case 0x30000000:
477 flags = O_RDWR;
478 break;
479 }
480
481 if (mode&0x08000000) flags |= O_CREAT;
482 if (mode&0x04000000) flags |= O_TRUNC;
483 if (mode&0x02000000) flags |= O_APPEND;
484
485 int realMode = S_IRWXU|S_IRWXG;
486 if (mode&0x00000001) realMode |= S_IROTH;
487 if (mode&0x00000002) realMode |= S_IWOTH;
488
489 int fd = open(name8.string(), flags, realMode);
490 if (fd < 0) {
491 jniThrowException(env, "java/io/FileNotFoundException", strerror(errno));
492 return NULL;
493 }
494 jobject object = jniCreateFileDescriptor(env, fd);
495 if (object == NULL) {
496 close(fd);
497 }
498 return object;
499 }
500
android_os_Parcel_dupFileDescriptor(JNIEnv * env,jclass clazz,jobject orig)501 static jobject android_os_Parcel_dupFileDescriptor(JNIEnv* env, jclass clazz, jobject orig)
502 {
503 if (orig == NULL) {
504 jniThrowNullPointerException(env, NULL);
505 return NULL;
506 }
507 int origfd = jniGetFDFromFileDescriptor(env, orig);
508 if (origfd < 0) {
509 jniThrowException(env, "java/lang/IllegalArgumentException", "bad FileDescriptor");
510 return NULL;
511 }
512
513 int fd = dup(origfd);
514 if (fd < 0) {
515 jniThrowIOException(env, errno);
516 return NULL;
517 }
518 jobject object = jniCreateFileDescriptor(env, fd);
519 if (object == NULL) {
520 close(fd);
521 }
522 return object;
523 }
524
android_os_Parcel_closeFileDescriptor(JNIEnv * env,jclass clazz,jobject object)525 static void android_os_Parcel_closeFileDescriptor(JNIEnv* env, jclass clazz, jobject object)
526 {
527 if (object == NULL) {
528 jniThrowNullPointerException(env, NULL);
529 return;
530 }
531 int fd = jniGetFDFromFileDescriptor(env, object);
532 if (fd >= 0) {
533 jniSetFileDescriptorOfFD(env, object, -1);
534 //ALOGI("Closing ParcelFileDescriptor %d\n", fd);
535 close(fd);
536 }
537 }
538
android_os_Parcel_clearFileDescriptor(JNIEnv * env,jclass clazz,jobject object)539 static void android_os_Parcel_clearFileDescriptor(JNIEnv* env, jclass clazz, jobject object)
540 {
541 if (object == NULL) {
542 jniThrowNullPointerException(env, NULL);
543 return;
544 }
545 int fd = jniGetFDFromFileDescriptor(env, object);
546 if (fd >= 0) {
547 jniSetFileDescriptorOfFD(env, object, -1);
548 }
549 }
550
android_os_Parcel_create(JNIEnv * env,jclass clazz)551 static jlong android_os_Parcel_create(JNIEnv* env, jclass clazz)
552 {
553 Parcel* parcel = new Parcel();
554 return reinterpret_cast<jlong>(parcel);
555 }
556
android_os_Parcel_freeBuffer(JNIEnv * env,jclass clazz,jlong nativePtr)557 static jlong android_os_Parcel_freeBuffer(JNIEnv* env, jclass clazz, jlong nativePtr)
558 {
559 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
560 if (parcel != NULL) {
561 parcel->freeData();
562 return parcel->getOpenAshmemSize();
563 }
564 return 0;
565 }
566
android_os_Parcel_destroy(JNIEnv * env,jclass clazz,jlong nativePtr)567 static void android_os_Parcel_destroy(JNIEnv* env, jclass clazz, jlong nativePtr)
568 {
569 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
570 delete parcel;
571 }
572
android_os_Parcel_marshall(JNIEnv * env,jclass clazz,jlong nativePtr)573 static jbyteArray android_os_Parcel_marshall(JNIEnv* env, jclass clazz, jlong nativePtr)
574 {
575 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
576 if (parcel == NULL) {
577 return NULL;
578 }
579
580 // do not marshall if there are binder objects in the parcel
581 if (parcel->objectsCount())
582 {
583 jniThrowException(env, "java/lang/RuntimeException", "Tried to marshall a Parcel that contained Binder objects.");
584 return NULL;
585 }
586
587 jbyteArray ret = env->NewByteArray(parcel->dataSize());
588
589 if (ret != NULL)
590 {
591 jbyte* array = (jbyte*)env->GetPrimitiveArrayCritical(ret, 0);
592 if (array != NULL)
593 {
594 memcpy(array, parcel->data(), parcel->dataSize());
595 env->ReleasePrimitiveArrayCritical(ret, array, 0);
596 }
597 }
598
599 return ret;
600 }
601
android_os_Parcel_unmarshall(JNIEnv * env,jclass clazz,jlong nativePtr,jbyteArray data,jint offset,jint length)602 static jlong android_os_Parcel_unmarshall(JNIEnv* env, jclass clazz, jlong nativePtr,
603 jbyteArray data, jint offset, jint length)
604 {
605 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
606 if (parcel == NULL || length < 0) {
607 return 0;
608 }
609
610 jbyte* array = (jbyte*)env->GetPrimitiveArrayCritical(data, 0);
611 if (array)
612 {
613 parcel->setDataSize(length);
614 parcel->setDataPosition(0);
615
616 void* raw = parcel->writeInplace(length);
617 memcpy(raw, (array + offset), length);
618
619 env->ReleasePrimitiveArrayCritical(data, array, 0);
620 }
621 return parcel->getOpenAshmemSize();
622 }
623
android_os_Parcel_appendFrom(JNIEnv * env,jclass clazz,jlong thisNativePtr,jlong otherNativePtr,jint offset,jint length)624 static jlong android_os_Parcel_appendFrom(JNIEnv* env, jclass clazz, jlong thisNativePtr,
625 jlong otherNativePtr, jint offset, jint length)
626 {
627 Parcel* thisParcel = reinterpret_cast<Parcel*>(thisNativePtr);
628 if (thisParcel == NULL) {
629 return 0;
630 }
631 Parcel* otherParcel = reinterpret_cast<Parcel*>(otherNativePtr);
632 if (otherParcel == NULL) {
633 return thisParcel->getOpenAshmemSize();
634 }
635
636 status_t err = thisParcel->appendFrom(otherParcel, offset, length);
637 if (err != NO_ERROR) {
638 signalExceptionForError(env, clazz, err);
639 }
640 return thisParcel->getOpenAshmemSize();
641 }
642
android_os_Parcel_hasFileDescriptors(JNIEnv * env,jclass clazz,jlong nativePtr)643 static jboolean android_os_Parcel_hasFileDescriptors(JNIEnv* env, jclass clazz, jlong nativePtr)
644 {
645 jboolean ret = JNI_FALSE;
646 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
647 if (parcel != NULL) {
648 if (parcel->hasFileDescriptors()) {
649 ret = JNI_TRUE;
650 }
651 }
652 return ret;
653 }
654
android_os_Parcel_writeInterfaceToken(JNIEnv * env,jclass clazz,jlong nativePtr,jstring name)655 static void android_os_Parcel_writeInterfaceToken(JNIEnv* env, jclass clazz, jlong nativePtr,
656 jstring name)
657 {
658 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
659 if (parcel != NULL) {
660 // In the current implementation, the token is just the serialized interface name that
661 // the caller expects to be invoking
662 const jchar* str = env->GetStringCritical(name, 0);
663 if (str != NULL) {
664 parcel->writeInterfaceToken(String16(
665 reinterpret_cast<const char16_t*>(str),
666 env->GetStringLength(name)));
667 env->ReleaseStringCritical(name, str);
668 }
669 }
670 }
671
android_os_Parcel_enforceInterface(JNIEnv * env,jclass clazz,jlong nativePtr,jstring name)672 static void android_os_Parcel_enforceInterface(JNIEnv* env, jclass clazz, jlong nativePtr, jstring name)
673 {
674 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
675 if (parcel != NULL) {
676 const jchar* str = env->GetStringCritical(name, 0);
677 if (str) {
678 IPCThreadState* threadState = IPCThreadState::self();
679 const int32_t oldPolicy = threadState->getStrictModePolicy();
680 const bool isValid = parcel->enforceInterface(
681 String16(reinterpret_cast<const char16_t*>(str),
682 env->GetStringLength(name)),
683 threadState);
684 env->ReleaseStringCritical(name, str);
685 if (isValid) {
686 const int32_t newPolicy = threadState->getStrictModePolicy();
687 if (oldPolicy != newPolicy) {
688 // Need to keep the Java-level thread-local strict
689 // mode policy in sync for the libcore
690 // enforcements, which involves an upcall back
691 // into Java. (We can't modify the
692 // Parcel.enforceInterface signature, as it's
693 // pseudo-public, and used via AIDL
694 // auto-generation...)
695 set_dalvik_blockguard_policy(env, newPolicy);
696 }
697 return; // everything was correct -> return silently
698 }
699 }
700 }
701
702 // all error conditions wind up here
703 jniThrowException(env, "java/lang/SecurityException",
704 "Binder invocation to an incorrect interface");
705 }
706
android_os_Parcel_getGlobalAllocSize(JNIEnv * env,jclass clazz)707 static jlong android_os_Parcel_getGlobalAllocSize(JNIEnv* env, jclass clazz)
708 {
709 return Parcel::getGlobalAllocSize();
710 }
711
android_os_Parcel_getGlobalAllocCount(JNIEnv * env,jclass clazz)712 static jlong android_os_Parcel_getGlobalAllocCount(JNIEnv* env, jclass clazz)
713 {
714 return Parcel::getGlobalAllocCount();
715 }
716
android_os_Parcel_getBlobAshmemSize(JNIEnv * env,jclass clazz,jlong nativePtr)717 static jlong android_os_Parcel_getBlobAshmemSize(JNIEnv* env, jclass clazz, jlong nativePtr)
718 {
719 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
720 if (parcel != NULL) {
721 return parcel->getBlobAshmemSize();
722 }
723 return 0;
724 }
725
726 // ----------------------------------------------------------------------------
727
728 static const JNINativeMethod gParcelMethods[] = {
729 {"nativeDataSize", "(J)I", (void*)android_os_Parcel_dataSize},
730 {"nativeDataAvail", "(J)I", (void*)android_os_Parcel_dataAvail},
731 {"nativeDataPosition", "(J)I", (void*)android_os_Parcel_dataPosition},
732 {"nativeDataCapacity", "(J)I", (void*)android_os_Parcel_dataCapacity},
733 {"nativeSetDataSize", "(JI)J", (void*)android_os_Parcel_setDataSize},
734 {"nativeSetDataPosition", "(JI)V", (void*)android_os_Parcel_setDataPosition},
735 {"nativeSetDataCapacity", "(JI)V", (void*)android_os_Parcel_setDataCapacity},
736
737 {"nativePushAllowFds", "(JZ)Z", (void*)android_os_Parcel_pushAllowFds},
738 {"nativeRestoreAllowFds", "(JZ)V", (void*)android_os_Parcel_restoreAllowFds},
739
740 {"nativeWriteByteArray", "(J[BII)V", (void*)android_os_Parcel_writeNative},
741 {"nativeWriteBlob", "(J[BII)V", (void*)android_os_Parcel_writeBlob},
742 {"nativeWriteInt", "(JI)V", (void*)android_os_Parcel_writeInt},
743 {"nativeWriteLong", "(JJ)V", (void*)android_os_Parcel_writeLong},
744 {"nativeWriteFloat", "(JF)V", (void*)android_os_Parcel_writeFloat},
745 {"nativeWriteDouble", "(JD)V", (void*)android_os_Parcel_writeDouble},
746 {"nativeWriteString", "(JLjava/lang/String;)V", (void*)android_os_Parcel_writeString},
747 {"nativeWriteStrongBinder", "(JLandroid/os/IBinder;)V", (void*)android_os_Parcel_writeStrongBinder},
748 {"nativeWriteFileDescriptor", "(JLjava/io/FileDescriptor;)J", (void*)android_os_Parcel_writeFileDescriptor},
749
750 {"nativeCreateByteArray", "(J)[B", (void*)android_os_Parcel_createByteArray},
751 {"nativeReadBlob", "(J)[B", (void*)android_os_Parcel_readBlob},
752 {"nativeReadInt", "(J)I", (void*)android_os_Parcel_readInt},
753 {"nativeReadLong", "(J)J", (void*)android_os_Parcel_readLong},
754 {"nativeReadFloat", "(J)F", (void*)android_os_Parcel_readFloat},
755 {"nativeReadDouble", "(J)D", (void*)android_os_Parcel_readDouble},
756 {"nativeReadString", "(J)Ljava/lang/String;", (void*)android_os_Parcel_readString},
757 {"nativeReadStrongBinder", "(J)Landroid/os/IBinder;", (void*)android_os_Parcel_readStrongBinder},
758 {"nativeReadFileDescriptor", "(J)Ljava/io/FileDescriptor;", (void*)android_os_Parcel_readFileDescriptor},
759
760 {"openFileDescriptor", "(Ljava/lang/String;I)Ljava/io/FileDescriptor;", (void*)android_os_Parcel_openFileDescriptor},
761 {"dupFileDescriptor", "(Ljava/io/FileDescriptor;)Ljava/io/FileDescriptor;", (void*)android_os_Parcel_dupFileDescriptor},
762 {"closeFileDescriptor", "(Ljava/io/FileDescriptor;)V", (void*)android_os_Parcel_closeFileDescriptor},
763 {"clearFileDescriptor", "(Ljava/io/FileDescriptor;)V", (void*)android_os_Parcel_clearFileDescriptor},
764
765 {"nativeCreate", "()J", (void*)android_os_Parcel_create},
766 {"nativeFreeBuffer", "(J)J", (void*)android_os_Parcel_freeBuffer},
767 {"nativeDestroy", "(J)V", (void*)android_os_Parcel_destroy},
768
769 {"nativeMarshall", "(J)[B", (void*)android_os_Parcel_marshall},
770 {"nativeUnmarshall", "(J[BII)J", (void*)android_os_Parcel_unmarshall},
771 {"nativeAppendFrom", "(JJII)J", (void*)android_os_Parcel_appendFrom},
772 {"nativeHasFileDescriptors", "(J)Z", (void*)android_os_Parcel_hasFileDescriptors},
773 {"nativeWriteInterfaceToken", "(JLjava/lang/String;)V", (void*)android_os_Parcel_writeInterfaceToken},
774 {"nativeEnforceInterface", "(JLjava/lang/String;)V", (void*)android_os_Parcel_enforceInterface},
775
776 {"getGlobalAllocSize", "()J", (void*)android_os_Parcel_getGlobalAllocSize},
777 {"getGlobalAllocCount", "()J", (void*)android_os_Parcel_getGlobalAllocCount},
778
779 {"nativeGetBlobAshmemSize", "(J)J", (void*)android_os_Parcel_getBlobAshmemSize},
780 };
781
782 const char* const kParcelPathName = "android/os/Parcel";
783
register_android_os_Parcel(JNIEnv * env)784 int register_android_os_Parcel(JNIEnv* env)
785 {
786 jclass clazz = FindClassOrDie(env, kParcelPathName);
787
788 gParcelOffsets.clazz = MakeGlobalRefOrDie(env, clazz);
789 gParcelOffsets.mNativePtr = GetFieldIDOrDie(env, clazz, "mNativePtr", "J");
790 gParcelOffsets.obtain = GetStaticMethodIDOrDie(env, clazz, "obtain", "()Landroid/os/Parcel;");
791 gParcelOffsets.recycle = GetMethodIDOrDie(env, clazz, "recycle", "()V");
792
793 return RegisterMethodsOrDie(env, kParcelPathName, gParcelMethods, NELEM(gParcelMethods));
794 }
795
796 };
797