1 /*
2  * Copyright (C) 2005 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 #ifndef ANDROID_PARCEL_H
18 #define ANDROID_PARCEL_H
19 
20 #include <string>
21 #include <vector>
22 
23 #include <android-base/unique_fd.h>
24 #include <cutils/native_handle.h>
25 #include <utils/Errors.h>
26 #include <utils/RefBase.h>
27 #include <utils/String16.h>
28 #include <utils/Vector.h>
29 #include <utils/Flattenable.h>
30 #include <linux/android/binder.h>
31 
32 #include <binder/IInterface.h>
33 #include <binder/Parcelable.h>
34 #include <binder/Map.h>
35 
36 // ---------------------------------------------------------------------------
37 namespace android {
38 
39 template <typename T> class Flattenable;
40 template <typename T> class LightFlattenable;
41 class IBinder;
42 class IPCThreadState;
43 class ProcessState;
44 class String8;
45 class TextOutput;
46 
47 namespace binder {
48 class Value;
49 };
50 
51 class Parcel {
52     friend class IPCThreadState;
53 public:
54     class ReadableBlob;
55     class WritableBlob;
56 
57                         Parcel();
58                         ~Parcel();
59 
60     const uint8_t*      data() const;
61     size_t              dataSize() const;
62     size_t              dataAvail() const;
63     size_t              dataPosition() const;
64     size_t              dataCapacity() const;
65 
66     status_t            setDataSize(size_t size);
67     void                setDataPosition(size_t pos) const;
68     status_t            setDataCapacity(size_t size);
69 
70     status_t            setData(const uint8_t* buffer, size_t len);
71 
72     status_t            appendFrom(const Parcel *parcel,
73                                    size_t start, size_t len);
74 
75     int                 compareData(const Parcel& other);
76 
77     bool                allowFds() const;
78     bool                pushAllowFds(bool allowFds);
79     void                restoreAllowFds(bool lastValue);
80 
81     bool                hasFileDescriptors() const;
82 
83     // Writes the RPC header.
84     status_t            writeInterfaceToken(const String16& interface);
85 
86     // Parses the RPC header, returning true if the interface name
87     // in the header matches the expected interface from the caller.
88     //
89     // Additionally, enforceInterface does part of the work of
90     // propagating the StrictMode policy mask, populating the current
91     // IPCThreadState, which as an optimization may optionally be
92     // passed in.
93     bool                enforceInterface(const String16& interface,
94                                          IPCThreadState* threadState = NULL) const;
95     bool                checkInterface(IBinder*) const;
96 
97     void                freeData();
98 
99 private:
100     const binder_size_t* objects() const;
101 
102 public:
103     size_t              objectsCount() const;
104 
105     status_t            errorCheck() const;
106     void                setError(status_t err);
107 
108     status_t            write(const void* data, size_t len);
109     void*               writeInplace(size_t len);
110     status_t            writeUnpadded(const void* data, size_t len);
111     status_t            writeInt32(int32_t val);
112     status_t            writeUint32(uint32_t val);
113     status_t            writeInt64(int64_t val);
114     status_t            writeUint64(uint64_t val);
115     status_t            writeFloat(float val);
116     status_t            writeDouble(double val);
117     status_t            writeCString(const char* str);
118     status_t            writeString8(const String8& str);
119     status_t            writeString16(const String16& str);
120     status_t            writeString16(const std::unique_ptr<String16>& str);
121     status_t            writeString16(const char16_t* str, size_t len);
122     status_t            writeStrongBinder(const sp<IBinder>& val);
123     status_t            writeWeakBinder(const wp<IBinder>& val);
124     status_t            writeInt32Array(size_t len, const int32_t *val);
125     status_t            writeByteArray(size_t len, const uint8_t *val);
126     status_t            writeBool(bool val);
127     status_t            writeChar(char16_t val);
128     status_t            writeByte(int8_t val);
129 
130     // Take a UTF8 encoded string, convert to UTF16, write it to the parcel.
131     status_t            writeUtf8AsUtf16(const std::string& str);
132     status_t            writeUtf8AsUtf16(const std::unique_ptr<std::string>& str);
133 
134     status_t            writeByteVector(const std::unique_ptr<std::vector<int8_t>>& val);
135     status_t            writeByteVector(const std::vector<int8_t>& val);
136     status_t            writeByteVector(const std::unique_ptr<std::vector<uint8_t>>& val);
137     status_t            writeByteVector(const std::vector<uint8_t>& val);
138     status_t            writeInt32Vector(const std::unique_ptr<std::vector<int32_t>>& val);
139     status_t            writeInt32Vector(const std::vector<int32_t>& val);
140     status_t            writeInt64Vector(const std::unique_ptr<std::vector<int64_t>>& val);
141     status_t            writeInt64Vector(const std::vector<int64_t>& val);
142     status_t            writeFloatVector(const std::unique_ptr<std::vector<float>>& val);
143     status_t            writeFloatVector(const std::vector<float>& val);
144     status_t            writeDoubleVector(const std::unique_ptr<std::vector<double>>& val);
145     status_t            writeDoubleVector(const std::vector<double>& val);
146     status_t            writeBoolVector(const std::unique_ptr<std::vector<bool>>& val);
147     status_t            writeBoolVector(const std::vector<bool>& val);
148     status_t            writeCharVector(const std::unique_ptr<std::vector<char16_t>>& val);
149     status_t            writeCharVector(const std::vector<char16_t>& val);
150     status_t            writeString16Vector(
151                             const std::unique_ptr<std::vector<std::unique_ptr<String16>>>& val);
152     status_t            writeString16Vector(const std::vector<String16>& val);
153     status_t            writeUtf8VectorAsUtf16Vector(
154                             const std::unique_ptr<std::vector<std::unique_ptr<std::string>>>& val);
155     status_t            writeUtf8VectorAsUtf16Vector(const std::vector<std::string>& val);
156 
157     status_t            writeStrongBinderVector(const std::unique_ptr<std::vector<sp<IBinder>>>& val);
158     status_t            writeStrongBinderVector(const std::vector<sp<IBinder>>& val);
159 
160     template<typename T>
161     status_t            writeParcelableVector(const std::unique_ptr<std::vector<std::unique_ptr<T>>>& val);
162     template<typename T>
163     status_t            writeParcelableVector(const std::shared_ptr<std::vector<std::unique_ptr<T>>>& val);
164     template<typename T>
165     status_t            writeParcelableVector(const std::vector<T>& val);
166 
167     template<typename T>
168     status_t            writeNullableParcelable(const std::unique_ptr<T>& parcelable);
169 
170     status_t            writeParcelable(const Parcelable& parcelable);
171 
172     status_t            writeValue(const binder::Value& value);
173 
174     template<typename T>
175     status_t            write(const Flattenable<T>& val);
176 
177     template<typename T>
178     status_t            write(const LightFlattenable<T>& val);
179 
180     template<typename T>
181     status_t            writeVectorSize(const std::vector<T>& val);
182     template<typename T>
183     status_t            writeVectorSize(const std::unique_ptr<std::vector<T>>& val);
184 
185     status_t            writeMap(const binder::Map& map);
186     status_t            writeNullableMap(const std::unique_ptr<binder::Map>& map);
187 
188     // Place a native_handle into the parcel (the native_handle's file-
189     // descriptors are dup'ed, so it is safe to delete the native_handle
190     // when this function returns).
191     // Doesn't take ownership of the native_handle.
192     status_t            writeNativeHandle(const native_handle* handle);
193 
194     // Place a file descriptor into the parcel.  The given fd must remain
195     // valid for the lifetime of the parcel.
196     // The Parcel does not take ownership of the given fd unless you ask it to.
197     status_t            writeFileDescriptor(int fd, bool takeOwnership = false);
198 
199     // Place a file descriptor into the parcel.  A dup of the fd is made, which
200     // will be closed once the parcel is destroyed.
201     status_t            writeDupFileDescriptor(int fd);
202 
203     // Place a Java "parcel file descriptor" into the parcel.  The given fd must remain
204     // valid for the lifetime of the parcel.
205     // The Parcel does not take ownership of the given fd unless you ask it to.
206     status_t            writeParcelFileDescriptor(int fd, bool takeOwnership = false);
207 
208     // Place a file descriptor into the parcel.  This will not affect the
209     // semantics of the smart file descriptor. A new descriptor will be
210     // created, and will be closed when the parcel is destroyed.
211     status_t            writeUniqueFileDescriptor(
212                             const base::unique_fd& fd);
213 
214     // Place a vector of file desciptors into the parcel. Each descriptor is
215     // dup'd as in writeDupFileDescriptor
216     status_t            writeUniqueFileDescriptorVector(
217                             const std::unique_ptr<std::vector<base::unique_fd>>& val);
218     status_t            writeUniqueFileDescriptorVector(
219                             const std::vector<base::unique_fd>& val);
220 
221     // Writes a blob to the parcel.
222     // If the blob is small, then it is stored in-place, otherwise it is
223     // transferred by way of an anonymous shared memory region.  Prefer sending
224     // immutable blobs if possible since they may be subsequently transferred between
225     // processes without further copying whereas mutable blobs always need to be copied.
226     // The caller should call release() on the blob after writing its contents.
227     status_t            writeBlob(size_t len, bool mutableCopy, WritableBlob* outBlob);
228 
229     // Write an existing immutable blob file descriptor to the parcel.
230     // This allows the client to send the same blob to multiple processes
231     // as long as it keeps a dup of the blob file descriptor handy for later.
232     status_t            writeDupImmutableBlobFileDescriptor(int fd);
233 
234     status_t            writeObject(const flat_binder_object& val, bool nullMetaData);
235 
236     // Like Parcel.java's writeNoException().  Just writes a zero int32.
237     // Currently the native implementation doesn't do any of the StrictMode
238     // stack gathering and serialization that the Java implementation does.
239     status_t            writeNoException();
240 
241     void                remove(size_t start, size_t amt);
242 
243     status_t            read(void* outData, size_t len) const;
244     const void*         readInplace(size_t len) const;
245     int32_t             readInt32() const;
246     status_t            readInt32(int32_t *pArg) const;
247     uint32_t            readUint32() const;
248     status_t            readUint32(uint32_t *pArg) const;
249     int64_t             readInt64() const;
250     status_t            readInt64(int64_t *pArg) const;
251     uint64_t            readUint64() const;
252     status_t            readUint64(uint64_t *pArg) const;
253     float               readFloat() const;
254     status_t            readFloat(float *pArg) const;
255     double              readDouble() const;
256     status_t            readDouble(double *pArg) const;
257     intptr_t            readIntPtr() const;
258     status_t            readIntPtr(intptr_t *pArg) const;
259     bool                readBool() const;
260     status_t            readBool(bool *pArg) const;
261     char16_t            readChar() const;
262     status_t            readChar(char16_t *pArg) const;
263     int8_t              readByte() const;
264     status_t            readByte(int8_t *pArg) const;
265 
266     // Read a UTF16 encoded string, convert to UTF8
267     status_t            readUtf8FromUtf16(std::string* str) const;
268     status_t            readUtf8FromUtf16(std::unique_ptr<std::string>* str) const;
269 
270     const char*         readCString() const;
271     String8             readString8() const;
272     status_t            readString8(String8* pArg) const;
273     String16            readString16() const;
274     status_t            readString16(String16* pArg) const;
275     status_t            readString16(std::unique_ptr<String16>* pArg) const;
276     const char16_t*     readString16Inplace(size_t* outLen) const;
277     sp<IBinder>         readStrongBinder() const;
278     status_t            readStrongBinder(sp<IBinder>* val) const;
279     status_t            readNullableStrongBinder(sp<IBinder>* val) const;
280     wp<IBinder>         readWeakBinder() const;
281 
282     template<typename T>
283     status_t            readParcelableVector(
284                             std::unique_ptr<std::vector<std::unique_ptr<T>>>* val) const;
285     template<typename T>
286     status_t            readParcelableVector(std::vector<T>* val) const;
287 
288     status_t            readParcelable(Parcelable* parcelable) const;
289 
290     template<typename T>
291     status_t            readParcelable(std::unique_ptr<T>* parcelable) const;
292 
293     status_t            readValue(binder::Value* value) const;
294 
295     template<typename T>
296     status_t            readStrongBinder(sp<T>* val) const;
297 
298     template<typename T>
299     status_t            readNullableStrongBinder(sp<T>* val) const;
300 
301     status_t            readStrongBinderVector(std::unique_ptr<std::vector<sp<IBinder>>>* val) const;
302     status_t            readStrongBinderVector(std::vector<sp<IBinder>>* val) const;
303 
304     status_t            readByteVector(std::unique_ptr<std::vector<int8_t>>* val) const;
305     status_t            readByteVector(std::vector<int8_t>* val) const;
306     status_t            readByteVector(std::unique_ptr<std::vector<uint8_t>>* val) const;
307     status_t            readByteVector(std::vector<uint8_t>* val) const;
308     status_t            readInt32Vector(std::unique_ptr<std::vector<int32_t>>* val) const;
309     status_t            readInt32Vector(std::vector<int32_t>* val) const;
310     status_t            readInt64Vector(std::unique_ptr<std::vector<int64_t>>* val) const;
311     status_t            readInt64Vector(std::vector<int64_t>* val) const;
312     status_t            readFloatVector(std::unique_ptr<std::vector<float>>* val) const;
313     status_t            readFloatVector(std::vector<float>* val) const;
314     status_t            readDoubleVector(std::unique_ptr<std::vector<double>>* val) const;
315     status_t            readDoubleVector(std::vector<double>* val) const;
316     status_t            readBoolVector(std::unique_ptr<std::vector<bool>>* val) const;
317     status_t            readBoolVector(std::vector<bool>* val) const;
318     status_t            readCharVector(std::unique_ptr<std::vector<char16_t>>* val) const;
319     status_t            readCharVector(std::vector<char16_t>* val) const;
320     status_t            readString16Vector(
321                             std::unique_ptr<std::vector<std::unique_ptr<String16>>>* val) const;
322     status_t            readString16Vector(std::vector<String16>* val) const;
323     status_t            readUtf8VectorFromUtf16Vector(
324                             std::unique_ptr<std::vector<std::unique_ptr<std::string>>>* val) const;
325     status_t            readUtf8VectorFromUtf16Vector(std::vector<std::string>* val) const;
326 
327     template<typename T>
328     status_t            read(Flattenable<T>& val) const;
329 
330     template<typename T>
331     status_t            read(LightFlattenable<T>& val) const;
332 
333     template<typename T>
334     status_t            resizeOutVector(std::vector<T>* val) const;
335     template<typename T>
336     status_t            resizeOutVector(std::unique_ptr<std::vector<T>>* val) const;
337 
338     status_t            readMap(binder::Map* map)const;
339     status_t            readNullableMap(std::unique_ptr<binder::Map>* map) const;
340 
341     // Like Parcel.java's readExceptionCode().  Reads the first int32
342     // off of a Parcel's header, returning 0 or the negative error
343     // code on exceptions, but also deals with skipping over rich
344     // response headers.  Callers should use this to read & parse the
345     // response headers rather than doing it by hand.
346     int32_t             readExceptionCode() const;
347 
348     // Retrieve native_handle from the parcel. This returns a copy of the
349     // parcel's native_handle (the caller takes ownership). The caller
350     // must free the native_handle with native_handle_close() and
351     // native_handle_delete().
352     native_handle*     readNativeHandle() const;
353 
354 
355     // Retrieve a file descriptor from the parcel.  This returns the raw fd
356     // in the parcel, which you do not own -- use dup() to get your own copy.
357     int                 readFileDescriptor() const;
358 
359     // Retrieve a Java "parcel file descriptor" from the parcel.  This returns the raw fd
360     // in the parcel, which you do not own -- use dup() to get your own copy.
361     int                 readParcelFileDescriptor() const;
362 
363     // Retrieve a smart file descriptor from the parcel.
364     status_t            readUniqueFileDescriptor(
365                             base::unique_fd* val) const;
366 
367 
368     // Retrieve a vector of smart file descriptors from the parcel.
369     status_t            readUniqueFileDescriptorVector(
370                             std::unique_ptr<std::vector<base::unique_fd>>* val) const;
371     status_t            readUniqueFileDescriptorVector(
372                             std::vector<base::unique_fd>* val) const;
373 
374     // Reads a blob from the parcel.
375     // The caller should call release() on the blob after reading its contents.
376     status_t            readBlob(size_t len, ReadableBlob* outBlob) const;
377 
378     const flat_binder_object* readObject(bool nullMetaData) const;
379 
380     // Explicitly close all file descriptors in the parcel.
381     void                closeFileDescriptors();
382 
383     // Debugging: get metrics on current allocations.
384     static size_t       getGlobalAllocSize();
385     static size_t       getGlobalAllocCount();
386 
387 private:
388     typedef void        (*release_func)(Parcel* parcel,
389                                         const uint8_t* data, size_t dataSize,
390                                         const binder_size_t* objects, size_t objectsSize,
391                                         void* cookie);
392 
393     uintptr_t           ipcData() const;
394     size_t              ipcDataSize() const;
395     uintptr_t           ipcObjects() const;
396     size_t              ipcObjectsCount() const;
397     void                ipcSetDataReference(const uint8_t* data, size_t dataSize,
398                                             const binder_size_t* objects, size_t objectsCount,
399                                             release_func relFunc, void* relCookie);
400 
401 public:
402     void                print(TextOutput& to, uint32_t flags = 0) const;
403 
404 private:
405                         Parcel(const Parcel& o);
406     Parcel&             operator=(const Parcel& o);
407 
408     status_t            finishWrite(size_t len);
409     void                releaseObjects();
410     void                acquireObjects();
411     status_t            growData(size_t len);
412     status_t            restartWrite(size_t desired);
413     status_t            continueWrite(size_t desired);
414     status_t            writePointer(uintptr_t val);
415     status_t            readPointer(uintptr_t *pArg) const;
416     uintptr_t           readPointer() const;
417     void                freeDataNoInit();
418     void                initState();
419     void                scanForFds() const;
420 
421     template<class T>
422     status_t            readAligned(T *pArg) const;
423 
424     template<class T>   T readAligned() const;
425 
426     template<class T>
427     status_t            writeAligned(T val);
428 
429     status_t            writeRawNullableParcelable(const Parcelable*
430                                                    parcelable);
431 
432     template<typename T, typename U>
433     status_t            unsafeReadTypedVector(std::vector<T>* val,
434                                               status_t(Parcel::*read_func)(U*) const) const;
435     template<typename T>
436     status_t            readNullableTypedVector(std::unique_ptr<std::vector<T>>* val,
437                                                 status_t(Parcel::*read_func)(T*) const) const;
438     template<typename T>
439     status_t            readTypedVector(std::vector<T>* val,
440                                         status_t(Parcel::*read_func)(T*) const) const;
441     template<typename T, typename U>
442     status_t            unsafeWriteTypedVector(const std::vector<T>& val,
443                                                status_t(Parcel::*write_func)(U));
444     template<typename T>
445     status_t            writeNullableTypedVector(const std::unique_ptr<std::vector<T>>& val,
446                                                  status_t(Parcel::*write_func)(const T&));
447     template<typename T>
448     status_t            writeNullableTypedVector(const std::unique_ptr<std::vector<T>>& val,
449                                                  status_t(Parcel::*write_func)(T));
450     template<typename T>
451     status_t            writeTypedVector(const std::vector<T>& val,
452                                          status_t(Parcel::*write_func)(const T&));
453     template<typename T>
454     status_t            writeTypedVector(const std::vector<T>& val,
455                                          status_t(Parcel::*write_func)(T));
456 
457     status_t            mError;
458     uint8_t*            mData;
459     size_t              mDataSize;
460     size_t              mDataCapacity;
461     mutable size_t      mDataPos;
462     binder_size_t*      mObjects;
463     size_t              mObjectsSize;
464     size_t              mObjectsCapacity;
465     mutable size_t      mNextObjectHint;
466 
467     mutable bool        mFdsKnown;
468     mutable bool        mHasFds;
469     bool                mAllowFds;
470 
471     release_func        mOwner;
472     void*               mOwnerCookie;
473 
474     class Blob {
475     public:
476         Blob();
477         ~Blob();
478 
479         void clear();
480         void release();
size()481         inline size_t size() const { return mSize; }
fd()482         inline int fd() const { return mFd; }
isMutable()483         inline bool isMutable() const { return mMutable; }
484 
485     protected:
486         void init(int fd, void* data, size_t size, bool isMutable);
487 
488         int mFd; // owned by parcel so not closed when released
489         void* mData;
490         size_t mSize;
491         bool mMutable;
492     };
493 
494     #if defined(__clang__)
495     #pragma clang diagnostic push
496     #pragma clang diagnostic ignored "-Wweak-vtables"
497     #endif
498 
499     // FlattenableHelperInterface and FlattenableHelper avoid generating a vtable entry in objects
500     // following Flattenable template/protocol.
501     class FlattenableHelperInterface {
502     protected:
~FlattenableHelperInterface()503         ~FlattenableHelperInterface() { }
504     public:
505         virtual size_t getFlattenedSize() const = 0;
506         virtual size_t getFdCount() const = 0;
507         virtual status_t flatten(void* buffer, size_t size, int* fds, size_t count) const = 0;
508         virtual status_t unflatten(void const* buffer, size_t size, int const* fds, size_t count) = 0;
509     };
510 
511     #if defined(__clang__)
512     #pragma clang diagnostic pop
513     #endif
514 
515     // Concrete implementation of FlattenableHelperInterface that delegates virtual calls to the
516     // specified class T implementing the Flattenable protocol. It "virtualizes" a compile-time
517     // protocol.
518     template<typename T>
519     class FlattenableHelper : public FlattenableHelperInterface {
520         friend class Parcel;
521         const Flattenable<T>& val;
FlattenableHelper(const Flattenable<T> & _val)522         explicit FlattenableHelper(const Flattenable<T>& _val) : val(_val) { }
523 
524     protected:
525         ~FlattenableHelper() = default;
526     public:
getFlattenedSize()527         virtual size_t getFlattenedSize() const {
528             return val.getFlattenedSize();
529         }
getFdCount()530         virtual size_t getFdCount() const {
531             return val.getFdCount();
532         }
flatten(void * buffer,size_t size,int * fds,size_t count)533         virtual status_t flatten(void* buffer, size_t size, int* fds, size_t count) const {
534             return val.flatten(buffer, size, fds, count);
535         }
unflatten(void const * buffer,size_t size,int const * fds,size_t count)536         virtual status_t unflatten(void const* buffer, size_t size, int const* fds, size_t count) {
537             return const_cast<Flattenable<T>&>(val).unflatten(buffer, size, fds, count);
538         }
539     };
540     status_t write(const FlattenableHelperInterface& val);
541     status_t read(FlattenableHelperInterface& val) const;
542 
543 public:
544     class ReadableBlob : public Blob {
545         friend class Parcel;
546     public:
data()547         inline const void* data() const { return mData; }
mutableData()548         inline void* mutableData() { return isMutable() ? mData : NULL; }
549     };
550 
551     class WritableBlob : public Blob {
552         friend class Parcel;
553     public:
data()554         inline void* data() { return mData; }
555     };
556 
557 private:
558     size_t mOpenAshmemSize;
559 
560 public:
561     // TODO: Remove once ABI can be changed.
562     size_t getBlobAshmemSize() const;
563     size_t getOpenAshmemSize() const;
564 };
565 
566 // ---------------------------------------------------------------------------
567 
568 template<typename T>
write(const Flattenable<T> & val)569 status_t Parcel::write(const Flattenable<T>& val) {
570     const FlattenableHelper<T> helper(val);
571     return write(helper);
572 }
573 
574 template<typename T>
write(const LightFlattenable<T> & val)575 status_t Parcel::write(const LightFlattenable<T>& val) {
576     size_t size(val.getFlattenedSize());
577     if (!val.isFixedSize()) {
578         if (size > INT32_MAX) {
579             return BAD_VALUE;
580         }
581         status_t err = writeInt32(static_cast<int32_t>(size));
582         if (err != NO_ERROR) {
583             return err;
584         }
585     }
586     if (size) {
587         void* buffer = writeInplace(size);
588         if (buffer == NULL)
589             return NO_MEMORY;
590         return val.flatten(buffer, size);
591     }
592     return NO_ERROR;
593 }
594 
595 template<typename T>
read(Flattenable<T> & val)596 status_t Parcel::read(Flattenable<T>& val) const {
597     FlattenableHelper<T> helper(val);
598     return read(helper);
599 }
600 
601 template<typename T>
read(LightFlattenable<T> & val)602 status_t Parcel::read(LightFlattenable<T>& val) const {
603     size_t size;
604     if (val.isFixedSize()) {
605         size = val.getFlattenedSize();
606     } else {
607         int32_t s;
608         status_t err = readInt32(&s);
609         if (err != NO_ERROR) {
610             return err;
611         }
612         size = static_cast<size_t>(s);
613     }
614     if (size) {
615         void const* buffer = readInplace(size);
616         return buffer == NULL ? NO_MEMORY :
617                 val.unflatten(buffer, size);
618     }
619     return NO_ERROR;
620 }
621 
622 template<typename T>
writeVectorSize(const std::vector<T> & val)623 status_t Parcel::writeVectorSize(const std::vector<T>& val) {
624     if (val.size() > INT32_MAX) {
625         return BAD_VALUE;
626     }
627     return writeInt32(static_cast<int32_t>(val.size()));
628 }
629 
630 template<typename T>
writeVectorSize(const std::unique_ptr<std::vector<T>> & val)631 status_t Parcel::writeVectorSize(const std::unique_ptr<std::vector<T>>& val) {
632     if (!val) {
633         return writeInt32(-1);
634     }
635 
636     return writeVectorSize(*val);
637 }
638 
639 template<typename T>
resizeOutVector(std::vector<T> * val)640 status_t Parcel::resizeOutVector(std::vector<T>* val) const {
641     int32_t size;
642     status_t err = readInt32(&size);
643     if (err != NO_ERROR) {
644         return err;
645     }
646 
647     if (size < 0) {
648         return UNEXPECTED_NULL;
649     }
650     val->resize(size_t(size));
651     return OK;
652 }
653 
654 template<typename T>
resizeOutVector(std::unique_ptr<std::vector<T>> * val)655 status_t Parcel::resizeOutVector(std::unique_ptr<std::vector<T>>* val) const {
656     int32_t size;
657     status_t err = readInt32(&size);
658     if (err != NO_ERROR) {
659         return err;
660     }
661 
662     val->reset();
663     if (size >= 0) {
664         val->reset(new std::vector<T>(size_t(size)));
665     }
666 
667     return OK;
668 }
669 
670 template<typename T>
readStrongBinder(sp<T> * val)671 status_t Parcel::readStrongBinder(sp<T>* val) const {
672     sp<IBinder> tmp;
673     status_t ret = readStrongBinder(&tmp);
674 
675     if (ret == OK) {
676         *val = interface_cast<T>(tmp);
677 
678         if (val->get() == nullptr) {
679             return UNKNOWN_ERROR;
680         }
681     }
682 
683     return ret;
684 }
685 
686 template<typename T>
readNullableStrongBinder(sp<T> * val)687 status_t Parcel::readNullableStrongBinder(sp<T>* val) const {
688     sp<IBinder> tmp;
689     status_t ret = readNullableStrongBinder(&tmp);
690 
691     if (ret == OK) {
692         *val = interface_cast<T>(tmp);
693 
694         if (val->get() == nullptr && tmp.get() != nullptr) {
695             ret = UNKNOWN_ERROR;
696         }
697     }
698 
699     return ret;
700 }
701 
702 template<typename T, typename U>
unsafeReadTypedVector(std::vector<T> * val,status_t (Parcel::* read_func)(U *)const)703 status_t Parcel::unsafeReadTypedVector(
704         std::vector<T>* val,
705         status_t(Parcel::*read_func)(U*) const) const {
706     int32_t size;
707     status_t status = this->readInt32(&size);
708 
709     if (status != OK) {
710         return status;
711     }
712 
713     if (size < 0) {
714         return UNEXPECTED_NULL;
715     }
716 
717     if (val->max_size() < static_cast<size_t>(size)) {
718         return NO_MEMORY;
719     }
720 
721     val->resize(static_cast<size_t>(size));
722 
723     if (val->size() < static_cast<size_t>(size)) {
724         return NO_MEMORY;
725     }
726 
727     for (auto& v: *val) {
728         status = (this->*read_func)(&v);
729 
730         if (status != OK) {
731             return status;
732         }
733     }
734 
735     return OK;
736 }
737 
738 template<typename T>
readTypedVector(std::vector<T> * val,status_t (Parcel::* read_func)(T *)const)739 status_t Parcel::readTypedVector(std::vector<T>* val,
740                                  status_t(Parcel::*read_func)(T*) const) const {
741     return unsafeReadTypedVector(val, read_func);
742 }
743 
744 template<typename T>
readNullableTypedVector(std::unique_ptr<std::vector<T>> * val,status_t (Parcel::* read_func)(T *)const)745 status_t Parcel::readNullableTypedVector(std::unique_ptr<std::vector<T>>* val,
746                                          status_t(Parcel::*read_func)(T*) const) const {
747     const size_t start = dataPosition();
748     int32_t size;
749     status_t status = readInt32(&size);
750     val->reset();
751 
752     if (status != OK || size < 0) {
753         return status;
754     }
755 
756     setDataPosition(start);
757     val->reset(new std::vector<T>());
758 
759     status = unsafeReadTypedVector(val->get(), read_func);
760 
761     if (status != OK) {
762         val->reset();
763     }
764 
765     return status;
766 }
767 
768 template<typename T, typename U>
unsafeWriteTypedVector(const std::vector<T> & val,status_t (Parcel::* write_func)(U))769 status_t Parcel::unsafeWriteTypedVector(const std::vector<T>& val,
770                                         status_t(Parcel::*write_func)(U)) {
771     if (val.size() > std::numeric_limits<int32_t>::max()) {
772         return BAD_VALUE;
773     }
774 
775     status_t status = this->writeInt32(static_cast<int32_t>(val.size()));
776 
777     if (status != OK) {
778         return status;
779     }
780 
781     for (const auto& item : val) {
782         status = (this->*write_func)(item);
783 
784         if (status != OK) {
785             return status;
786         }
787     }
788 
789     return OK;
790 }
791 
792 template<typename T>
writeTypedVector(const std::vector<T> & val,status_t (Parcel::* write_func)(const T &))793 status_t Parcel::writeTypedVector(const std::vector<T>& val,
794                                   status_t(Parcel::*write_func)(const T&)) {
795     return unsafeWriteTypedVector(val, write_func);
796 }
797 
798 template<typename T>
writeTypedVector(const std::vector<T> & val,status_t (Parcel::* write_func)(T))799 status_t Parcel::writeTypedVector(const std::vector<T>& val,
800                                   status_t(Parcel::*write_func)(T)) {
801     return unsafeWriteTypedVector(val, write_func);
802 }
803 
804 template<typename T>
writeNullableTypedVector(const std::unique_ptr<std::vector<T>> & val,status_t (Parcel::* write_func)(const T &))805 status_t Parcel::writeNullableTypedVector(const std::unique_ptr<std::vector<T>>& val,
806                                           status_t(Parcel::*write_func)(const T&)) {
807     if (val.get() == nullptr) {
808         return this->writeInt32(-1);
809     }
810 
811     return unsafeWriteTypedVector(*val, write_func);
812 }
813 
814 template<typename T>
writeNullableTypedVector(const std::unique_ptr<std::vector<T>> & val,status_t (Parcel::* write_func)(T))815 status_t Parcel::writeNullableTypedVector(const std::unique_ptr<std::vector<T>>& val,
816                                           status_t(Parcel::*write_func)(T)) {
817     if (val.get() == nullptr) {
818         return this->writeInt32(-1);
819     }
820 
821     return unsafeWriteTypedVector(*val, write_func);
822 }
823 
824 template<typename T>
readParcelableVector(std::vector<T> * val)825 status_t Parcel::readParcelableVector(std::vector<T>* val) const {
826     return unsafeReadTypedVector<T, Parcelable>(val, &Parcel::readParcelable);
827 }
828 
829 template<typename T>
readParcelableVector(std::unique_ptr<std::vector<std::unique_ptr<T>>> * val)830 status_t Parcel::readParcelableVector(std::unique_ptr<std::vector<std::unique_ptr<T>>>* val) const {
831     const size_t start = dataPosition();
832     int32_t size;
833     status_t status = readInt32(&size);
834     val->reset();
835 
836     if (status != OK || size < 0) {
837         return status;
838     }
839 
840     setDataPosition(start);
841     val->reset(new std::vector<std::unique_ptr<T>>());
842 
843     status = unsafeReadTypedVector(val->get(), &Parcel::readParcelable<T>);
844 
845     if (status != OK) {
846         val->reset();
847     }
848 
849     return status;
850 }
851 
852 template<typename T>
readParcelable(std::unique_ptr<T> * parcelable)853 status_t Parcel::readParcelable(std::unique_ptr<T>* parcelable) const {
854     const size_t start = dataPosition();
855     int32_t present;
856     status_t status = readInt32(&present);
857     parcelable->reset();
858 
859     if (status != OK || !present) {
860         return status;
861     }
862 
863     setDataPosition(start);
864     parcelable->reset(new T());
865 
866     status = readParcelable(parcelable->get());
867 
868     if (status != OK) {
869         parcelable->reset();
870     }
871 
872     return status;
873 }
874 
875 template<typename T>
writeNullableParcelable(const std::unique_ptr<T> & parcelable)876 status_t Parcel::writeNullableParcelable(const std::unique_ptr<T>& parcelable) {
877     return writeRawNullableParcelable(parcelable.get());
878 }
879 
880 template<typename T>
writeParcelableVector(const std::vector<T> & val)881 status_t Parcel::writeParcelableVector(const std::vector<T>& val) {
882     return unsafeWriteTypedVector<T,const Parcelable&>(val, &Parcel::writeParcelable);
883 }
884 
885 template<typename T>
writeParcelableVector(const std::unique_ptr<std::vector<std::unique_ptr<T>>> & val)886 status_t Parcel::writeParcelableVector(const std::unique_ptr<std::vector<std::unique_ptr<T>>>& val) {
887     if (val.get() == nullptr) {
888         return this->writeInt32(-1);
889     }
890 
891     return unsafeWriteTypedVector(*val, &Parcel::writeNullableParcelable<T>);
892 }
893 
894 template<typename T>
writeParcelableVector(const std::shared_ptr<std::vector<std::unique_ptr<T>>> & val)895 status_t Parcel::writeParcelableVector(const std::shared_ptr<std::vector<std::unique_ptr<T>>>& val) {
896     if (val.get() == nullptr) {
897         return this->writeInt32(-1);
898     }
899 
900     return unsafeWriteTypedVector(*val, &Parcel::writeNullableParcelable<T>);
901 }
902 
903 // ---------------------------------------------------------------------------
904 
905 inline TextOutput& operator<<(TextOutput& to, const Parcel& parcel)
906 {
907     parcel.print(to);
908     return to;
909 }
910 
911 // ---------------------------------------------------------------------------
912 
913 // Generic acquire and release of objects.
914 void acquire_object(const sp<ProcessState>& proc,
915                     const flat_binder_object& obj, const void* who);
916 void release_object(const sp<ProcessState>& proc,
917                     const flat_binder_object& obj, const void* who);
918 
919 void flatten_binder(const sp<ProcessState>& proc,
920                     const sp<IBinder>& binder, flat_binder_object* out);
921 void flatten_binder(const sp<ProcessState>& proc,
922                     const wp<IBinder>& binder, flat_binder_object* out);
923 status_t unflatten_binder(const sp<ProcessState>& proc,
924                           const flat_binder_object& flat, sp<IBinder>* out);
925 status_t unflatten_binder(const sp<ProcessState>& proc,
926                           const flat_binder_object& flat, wp<IBinder>* out);
927 
928 }; // namespace android
929 
930 // ---------------------------------------------------------------------------
931 
932 #endif // ANDROID_PARCEL_H
933