android_os_Parcel.cpp revision ab3f9724035046d65124a72db2a09c824b3d5c67 
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
61namespace android {
62
63static struct parcel_offsets_t
64{
65    jclass clazz;
66    jfieldID mNativePtr;
67    jmethodID obtain;
68    jmethodID recycle;
69} gParcelOffsets;
70
71Parcel* 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
83jobject createJavaParcelObject(JNIEnv* env)
84{
85    return env->CallStaticObjectMethod(gParcelOffsets.clazz, gParcelOffsets.obtain);
86}
87
88void recycleJavaParcelObject(JNIEnv* env, jobject parcelObj)
89{
90    env->CallVoidMethod(parcelObj, gParcelOffsets.recycle);
91}
92
93static 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
99static 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
105static 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
111static 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
117static 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
130static 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
138static 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
149static 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
159static 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
167static 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
194static 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
233static 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
243static 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
254static 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
265static 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
276static 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
298static 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
309static 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
323static 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
349static 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
379static 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
388static 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
397static 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
406static 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
415static 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
429static 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
438static 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
451static 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
501static 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
525static 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
539static 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
551static jlong android_os_Parcel_create(JNIEnv* env, jclass clazz)
552{
553    Parcel* parcel = new Parcel();
554    return reinterpret_cast<jlong>(parcel);
555}
556
557static 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
567static void android_os_Parcel_destroy(JNIEnv* env, jclass clazz, jlong nativePtr)
568{
569    Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
570    delete parcel;
571}
572
573static 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
602static 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
624static 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
643static 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
655static 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
672static 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
707static jlong android_os_Parcel_getGlobalAllocSize(JNIEnv* env, jclass clazz)
708{
709    return Parcel::getGlobalAllocSize();
710}
711
712static jlong android_os_Parcel_getGlobalAllocCount(JNIEnv* env, jclass clazz)
713{
714    return Parcel::getGlobalAllocCount();
715}
716
717static 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
728static 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
782const char* const kParcelPathName = "android/os/Parcel";
783
784int 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