925 lines
32 KiB
Rust
925 lines
32 KiB
Rust
/*
|
|
* Copyright (C) 2020 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
//! Container for messages that are sent via binder.
|
|
|
|
use crate::binder::AsNative;
|
|
use crate::error::{status_result, Result, StatusCode};
|
|
use crate::proxy::SpIBinder;
|
|
use crate::sys;
|
|
|
|
use std::convert::TryInto;
|
|
use std::fmt;
|
|
use std::marker::PhantomData;
|
|
use std::mem::ManuallyDrop;
|
|
use std::ptr::{self, NonNull};
|
|
|
|
mod file_descriptor;
|
|
mod parcelable;
|
|
mod parcelable_holder;
|
|
|
|
pub use self::file_descriptor::ParcelFileDescriptor;
|
|
pub use self::parcelable::{
|
|
Deserialize, DeserializeArray, DeserializeOption, Parcelable, Serialize, SerializeArray,
|
|
SerializeOption, NON_NULL_PARCELABLE_FLAG, NULL_PARCELABLE_FLAG,
|
|
};
|
|
pub use self::parcelable_holder::{ParcelableHolder, ParcelableMetadata};
|
|
|
|
/// Container for a message (data and object references) that can be sent
|
|
/// through Binder.
|
|
///
|
|
/// A Parcel can contain both serialized data that will be deserialized on the
|
|
/// other side of the IPC, and references to live Binder objects that will
|
|
/// result in the other side receiving a proxy Binder connected with the
|
|
/// original Binder in the Parcel.
|
|
///
|
|
/// This type represents a parcel that is owned by Rust code.
|
|
#[repr(transparent)]
|
|
pub struct Parcel {
|
|
ptr: NonNull<sys::AParcel>,
|
|
}
|
|
|
|
/// # Safety
|
|
///
|
|
/// This type guarantees that it owns the AParcel and that all access to
|
|
/// the AParcel happens through the Parcel, so it is ok to send across
|
|
/// threads.
|
|
unsafe impl Send for Parcel {}
|
|
|
|
/// Container for a message (data and object references) that can be sent
|
|
/// through Binder.
|
|
///
|
|
/// This object is a borrowed variant of [`Parcel`]. It is a separate type from
|
|
/// `&mut Parcel` because it is not valid to `mem::swap` two parcels.
|
|
#[repr(transparent)]
|
|
pub struct BorrowedParcel<'a> {
|
|
ptr: NonNull<sys::AParcel>,
|
|
_lifetime: PhantomData<&'a mut Parcel>,
|
|
}
|
|
|
|
impl Parcel {
|
|
/// Create a new empty `Parcel`.
|
|
pub fn new() -> Parcel {
|
|
let ptr = unsafe {
|
|
// Safety: If `AParcel_create` succeeds, it always returns
|
|
// a valid pointer. If it fails, the process will crash.
|
|
sys::AParcel_create()
|
|
};
|
|
Self { ptr: NonNull::new(ptr).expect("AParcel_create returned null pointer") }
|
|
}
|
|
|
|
/// Create an owned reference to a parcel object from a raw pointer.
|
|
///
|
|
/// # Safety
|
|
///
|
|
/// This constructor is safe if the raw pointer parameter is either null
|
|
/// (resulting in `None`), or a valid pointer to an `AParcel` object. The
|
|
/// parcel object must be owned by the caller prior to this call, as this
|
|
/// constructor takes ownership of the parcel and will destroy it on drop.
|
|
///
|
|
/// Additionally, the caller must guarantee that it is valid to take
|
|
/// ownership of the AParcel object. All future access to the AParcel
|
|
/// must happen through this `Parcel`.
|
|
///
|
|
/// Because `Parcel` implements `Send`, the pointer must never point to any
|
|
/// thread-local data, e.g., a variable on the stack, either directly or
|
|
/// indirectly.
|
|
pub unsafe fn from_raw(ptr: *mut sys::AParcel) -> Option<Parcel> {
|
|
NonNull::new(ptr).map(|ptr| Self { ptr })
|
|
}
|
|
|
|
/// Consume the parcel, transferring ownership to the caller.
|
|
pub(crate) fn into_raw(self) -> *mut sys::AParcel {
|
|
let ptr = self.ptr.as_ptr();
|
|
let _ = ManuallyDrop::new(self);
|
|
ptr
|
|
}
|
|
|
|
/// Get a borrowed view into the contents of this `Parcel`.
|
|
pub fn borrowed(&mut self) -> BorrowedParcel<'_> {
|
|
// Safety: The raw pointer is a valid pointer to an AParcel, and the
|
|
// lifetime of the returned `BorrowedParcel` is tied to `self`, so the
|
|
// borrow checker will ensure that the `AParcel` can only be accessed
|
|
// via the `BorrowParcel` until it goes out of scope.
|
|
BorrowedParcel { ptr: self.ptr, _lifetime: PhantomData }
|
|
}
|
|
|
|
/// Get an immutable borrowed view into the contents of this `Parcel`.
|
|
pub fn borrowed_ref(&self) -> &BorrowedParcel<'_> {
|
|
// Safety: Parcel and BorrowedParcel are both represented in the same
|
|
// way as a NonNull<sys::AParcel> due to their use of repr(transparent),
|
|
// so casting references as done here is valid.
|
|
unsafe { &*(self as *const Parcel as *const BorrowedParcel<'_>) }
|
|
}
|
|
}
|
|
|
|
impl Default for Parcel {
|
|
fn default() -> Self {
|
|
Self::new()
|
|
}
|
|
}
|
|
|
|
impl Clone for Parcel {
|
|
fn clone(&self) -> Self {
|
|
let mut new_parcel = Self::new();
|
|
new_parcel
|
|
.borrowed()
|
|
.append_all_from(self.borrowed_ref())
|
|
.expect("Failed to append from Parcel");
|
|
new_parcel
|
|
}
|
|
}
|
|
|
|
impl<'a> BorrowedParcel<'a> {
|
|
/// Create a borrowed reference to a parcel object from a raw pointer.
|
|
///
|
|
/// # Safety
|
|
///
|
|
/// This constructor is safe if the raw pointer parameter is either null
|
|
/// (resulting in `None`), or a valid pointer to an `AParcel` object.
|
|
///
|
|
/// Since the raw pointer is not restricted by any lifetime, the lifetime on
|
|
/// the returned `BorrowedParcel` object can be chosen arbitrarily by the
|
|
/// caller. The caller must ensure it is valid to mutably borrow the AParcel
|
|
/// for the duration of the lifetime that the caller chooses. Note that
|
|
/// since this is a mutable borrow, it must have exclusive access to the
|
|
/// AParcel for the duration of the borrow.
|
|
pub unsafe fn from_raw(ptr: *mut sys::AParcel) -> Option<BorrowedParcel<'a>> {
|
|
Some(Self { ptr: NonNull::new(ptr)?, _lifetime: PhantomData })
|
|
}
|
|
|
|
/// Get a sub-reference to this reference to the parcel.
|
|
pub fn reborrow(&mut self) -> BorrowedParcel<'_> {
|
|
// Safety: The raw pointer is a valid pointer to an AParcel, and the
|
|
// lifetime of the returned `BorrowedParcel` is tied to `self`, so the
|
|
// borrow checker will ensure that the `AParcel` can only be accessed
|
|
// via the `BorrowParcel` until it goes out of scope.
|
|
BorrowedParcel { ptr: self.ptr, _lifetime: PhantomData }
|
|
}
|
|
}
|
|
|
|
/// # Safety
|
|
///
|
|
/// The `Parcel` constructors guarantee that a `Parcel` object will always
|
|
/// contain a valid pointer to an `AParcel`.
|
|
unsafe impl AsNative<sys::AParcel> for Parcel {
|
|
fn as_native(&self) -> *const sys::AParcel {
|
|
self.ptr.as_ptr()
|
|
}
|
|
|
|
fn as_native_mut(&mut self) -> *mut sys::AParcel {
|
|
self.ptr.as_ptr()
|
|
}
|
|
}
|
|
|
|
/// # Safety
|
|
///
|
|
/// The `BorrowedParcel` constructors guarantee that a `BorrowedParcel` object
|
|
/// will always contain a valid pointer to an `AParcel`.
|
|
unsafe impl<'a> AsNative<sys::AParcel> for BorrowedParcel<'a> {
|
|
fn as_native(&self) -> *const sys::AParcel {
|
|
self.ptr.as_ptr()
|
|
}
|
|
|
|
fn as_native_mut(&mut self) -> *mut sys::AParcel {
|
|
self.ptr.as_ptr()
|
|
}
|
|
}
|
|
|
|
// Data serialization methods
|
|
impl<'a> BorrowedParcel<'a> {
|
|
/// Data written to parcelable is zero'd before being deleted or reallocated.
|
|
pub fn mark_sensitive(&mut self) {
|
|
unsafe {
|
|
// Safety: guaranteed to have a parcel object, and this method never fails
|
|
sys::AParcel_markSensitive(self.as_native())
|
|
}
|
|
}
|
|
|
|
/// Write a type that implements [`Serialize`] to the parcel.
|
|
pub fn write<S: Serialize + ?Sized>(&mut self, parcelable: &S) -> Result<()> {
|
|
parcelable.serialize(self)
|
|
}
|
|
|
|
/// Writes the length of a slice to the parcel.
|
|
///
|
|
/// This is used in AIDL-generated client side code to indicate the
|
|
/// allocated space for an output array parameter.
|
|
pub fn write_slice_size<T>(&mut self, slice: Option<&[T]>) -> Result<()> {
|
|
if let Some(slice) = slice {
|
|
let len: i32 = slice.len().try_into().or(Err(StatusCode::BAD_VALUE))?;
|
|
self.write(&len)
|
|
} else {
|
|
self.write(&-1i32)
|
|
}
|
|
}
|
|
|
|
/// Perform a series of writes to the parcel, prepended with the length
|
|
/// (in bytes) of the written data.
|
|
///
|
|
/// The length `0i32` will be written to the parcel first, followed by the
|
|
/// writes performed by the callback. The initial length will then be
|
|
/// updated to the length of all data written by the callback, plus the
|
|
/// size of the length elemement itself (4 bytes).
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// After the following call:
|
|
///
|
|
/// ```
|
|
/// # use binder::{Binder, Interface, Parcel};
|
|
/// # let mut parcel = Parcel::new();
|
|
/// parcel.sized_write(|subparcel| {
|
|
/// subparcel.write(&1u32)?;
|
|
/// subparcel.write(&2u32)?;
|
|
/// subparcel.write(&3u32)
|
|
/// });
|
|
/// ```
|
|
///
|
|
/// `parcel` will contain the following:
|
|
///
|
|
/// ```ignore
|
|
/// [16i32, 1u32, 2u32, 3u32]
|
|
/// ```
|
|
pub fn sized_write<F>(&mut self, f: F) -> Result<()>
|
|
where
|
|
for<'b> F: FnOnce(&'b mut WritableSubParcel<'b>) -> Result<()>,
|
|
{
|
|
let start = self.get_data_position();
|
|
self.write(&0i32)?;
|
|
{
|
|
let mut subparcel = WritableSubParcel(self.reborrow());
|
|
f(&mut subparcel)?;
|
|
}
|
|
let end = self.get_data_position();
|
|
unsafe {
|
|
self.set_data_position(start)?;
|
|
}
|
|
assert!(end >= start);
|
|
self.write(&(end - start))?;
|
|
unsafe {
|
|
self.set_data_position(end)?;
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
/// Returns the current position in the parcel data.
|
|
pub fn get_data_position(&self) -> i32 {
|
|
unsafe {
|
|
// Safety: `BorrowedParcel` always contains a valid pointer to an
|
|
// `AParcel`, and this call is otherwise safe.
|
|
sys::AParcel_getDataPosition(self.as_native())
|
|
}
|
|
}
|
|
|
|
/// Returns the total size of the parcel.
|
|
pub fn get_data_size(&self) -> i32 {
|
|
unsafe {
|
|
// Safety: `BorrowedParcel` always contains a valid pointer to an
|
|
// `AParcel`, and this call is otherwise safe.
|
|
sys::AParcel_getDataSize(self.as_native())
|
|
}
|
|
}
|
|
|
|
/// Move the current read/write position in the parcel.
|
|
///
|
|
/// # Safety
|
|
///
|
|
/// This method is safe if `pos` is less than the current size of the parcel
|
|
/// data buffer. Otherwise, we are relying on correct bounds checking in the
|
|
/// Parcel C++ code on every subsequent read or write to this parcel. If all
|
|
/// accesses are bounds checked, this call is still safe, but we can't rely
|
|
/// on that.
|
|
pub unsafe fn set_data_position(&self, pos: i32) -> Result<()> {
|
|
status_result(sys::AParcel_setDataPosition(self.as_native(), pos))
|
|
}
|
|
|
|
/// Append a subset of another parcel.
|
|
///
|
|
/// This appends `size` bytes of data from `other` starting at offset
|
|
/// `start` to the current parcel, or returns an error if not possible.
|
|
pub fn append_from(
|
|
&mut self,
|
|
other: &impl AsNative<sys::AParcel>,
|
|
start: i32,
|
|
size: i32,
|
|
) -> Result<()> {
|
|
let status = unsafe {
|
|
// Safety: `Parcel::appendFrom` from C++ checks that `start`
|
|
// and `size` are in bounds, and returns an error otherwise.
|
|
// Both `self` and `other` always contain valid pointers.
|
|
sys::AParcel_appendFrom(other.as_native(), self.as_native_mut(), start, size)
|
|
};
|
|
status_result(status)
|
|
}
|
|
|
|
/// Append the contents of another parcel.
|
|
pub fn append_all_from(&mut self, other: &impl AsNative<sys::AParcel>) -> Result<()> {
|
|
// Safety: `BorrowedParcel` always contains a valid pointer to an
|
|
// `AParcel`, and this call is otherwise safe.
|
|
let size = unsafe { sys::AParcel_getDataSize(other.as_native()) };
|
|
self.append_from(other, 0, size)
|
|
}
|
|
}
|
|
|
|
/// A segment of a writable parcel, used for [`BorrowedParcel::sized_write`].
|
|
pub struct WritableSubParcel<'a>(BorrowedParcel<'a>);
|
|
|
|
impl<'a> WritableSubParcel<'a> {
|
|
/// Write a type that implements [`Serialize`] to the sub-parcel.
|
|
pub fn write<S: Serialize + ?Sized>(&mut self, parcelable: &S) -> Result<()> {
|
|
parcelable.serialize(&mut self.0)
|
|
}
|
|
}
|
|
|
|
impl Parcel {
|
|
/// Data written to parcelable is zero'd before being deleted or reallocated.
|
|
pub fn mark_sensitive(&mut self) {
|
|
self.borrowed().mark_sensitive()
|
|
}
|
|
|
|
/// Write a type that implements [`Serialize`] to the parcel.
|
|
pub fn write<S: Serialize + ?Sized>(&mut self, parcelable: &S) -> Result<()> {
|
|
self.borrowed().write(parcelable)
|
|
}
|
|
|
|
/// Writes the length of a slice to the parcel.
|
|
///
|
|
/// This is used in AIDL-generated client side code to indicate the
|
|
/// allocated space for an output array parameter.
|
|
pub fn write_slice_size<T>(&mut self, slice: Option<&[T]>) -> Result<()> {
|
|
self.borrowed().write_slice_size(slice)
|
|
}
|
|
|
|
/// Perform a series of writes to the parcel, prepended with the length
|
|
/// (in bytes) of the written data.
|
|
///
|
|
/// The length `0i32` will be written to the parcel first, followed by the
|
|
/// writes performed by the callback. The initial length will then be
|
|
/// updated to the length of all data written by the callback, plus the
|
|
/// size of the length elemement itself (4 bytes).
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// After the following call:
|
|
///
|
|
/// ```
|
|
/// # use binder::{Binder, Interface, Parcel};
|
|
/// # let mut parcel = Parcel::new();
|
|
/// parcel.sized_write(|subparcel| {
|
|
/// subparcel.write(&1u32)?;
|
|
/// subparcel.write(&2u32)?;
|
|
/// subparcel.write(&3u32)
|
|
/// });
|
|
/// ```
|
|
///
|
|
/// `parcel` will contain the following:
|
|
///
|
|
/// ```ignore
|
|
/// [16i32, 1u32, 2u32, 3u32]
|
|
/// ```
|
|
pub fn sized_write<F>(&mut self, f: F) -> Result<()>
|
|
where
|
|
for<'b> F: FnOnce(&'b mut WritableSubParcel<'b>) -> Result<()>,
|
|
{
|
|
self.borrowed().sized_write(f)
|
|
}
|
|
|
|
/// Returns the current position in the parcel data.
|
|
pub fn get_data_position(&self) -> i32 {
|
|
self.borrowed_ref().get_data_position()
|
|
}
|
|
|
|
/// Returns the total size of the parcel.
|
|
pub fn get_data_size(&self) -> i32 {
|
|
self.borrowed_ref().get_data_size()
|
|
}
|
|
|
|
/// Move the current read/write position in the parcel.
|
|
///
|
|
/// # Safety
|
|
///
|
|
/// This method is safe if `pos` is less than the current size of the parcel
|
|
/// data buffer. Otherwise, we are relying on correct bounds checking in the
|
|
/// Parcel C++ code on every subsequent read or write to this parcel. If all
|
|
/// accesses are bounds checked, this call is still safe, but we can't rely
|
|
/// on that.
|
|
pub unsafe fn set_data_position(&self, pos: i32) -> Result<()> {
|
|
self.borrowed_ref().set_data_position(pos)
|
|
}
|
|
|
|
/// Append a subset of another parcel.
|
|
///
|
|
/// This appends `size` bytes of data from `other` starting at offset
|
|
/// `start` to the current parcel, or returns an error if not possible.
|
|
pub fn append_from(
|
|
&mut self,
|
|
other: &impl AsNative<sys::AParcel>,
|
|
start: i32,
|
|
size: i32,
|
|
) -> Result<()> {
|
|
self.borrowed().append_from(other, start, size)
|
|
}
|
|
|
|
/// Append the contents of another parcel.
|
|
pub fn append_all_from(&mut self, other: &impl AsNative<sys::AParcel>) -> Result<()> {
|
|
self.borrowed().append_all_from(other)
|
|
}
|
|
}
|
|
|
|
// Data deserialization methods
|
|
impl<'a> BorrowedParcel<'a> {
|
|
/// Attempt to read a type that implements [`Deserialize`] from this parcel.
|
|
pub fn read<D: Deserialize>(&self) -> Result<D> {
|
|
D::deserialize(self)
|
|
}
|
|
|
|
/// Attempt to read a type that implements [`Deserialize`] from this parcel
|
|
/// onto an existing value. This operation will overwrite the old value
|
|
/// partially or completely, depending on how much data is available.
|
|
pub fn read_onto<D: Deserialize>(&self, x: &mut D) -> Result<()> {
|
|
x.deserialize_from(self)
|
|
}
|
|
|
|
/// Safely read a sized parcelable.
|
|
///
|
|
/// Read the size of a parcelable, compute the end position
|
|
/// of that parcelable, then build a sized readable sub-parcel
|
|
/// and call a closure with the sub-parcel as its parameter.
|
|
/// The closure can keep reading data from the sub-parcel
|
|
/// until it runs out of input data. The closure is responsible
|
|
/// for calling [`ReadableSubParcel::has_more_data`] to check for
|
|
/// more data before every read, at least until Rust generators
|
|
/// are stabilized.
|
|
/// After the closure returns, skip to the end of the current
|
|
/// parcelable regardless of how much the closure has read.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```no_run
|
|
/// let mut parcelable = Default::default();
|
|
/// parcel.sized_read(|subparcel| {
|
|
/// if subparcel.has_more_data() {
|
|
/// parcelable.a = subparcel.read()?;
|
|
/// }
|
|
/// if subparcel.has_more_data() {
|
|
/// parcelable.b = subparcel.read()?;
|
|
/// }
|
|
/// Ok(())
|
|
/// });
|
|
/// ```
|
|
///
|
|
pub fn sized_read<F>(&self, f: F) -> Result<()>
|
|
where
|
|
for<'b> F: FnOnce(ReadableSubParcel<'b>) -> Result<()>,
|
|
{
|
|
let start = self.get_data_position();
|
|
let parcelable_size: i32 = self.read()?;
|
|
if parcelable_size < 4 {
|
|
return Err(StatusCode::BAD_VALUE);
|
|
}
|
|
|
|
let end = start.checked_add(parcelable_size).ok_or(StatusCode::BAD_VALUE)?;
|
|
if end > self.get_data_size() {
|
|
return Err(StatusCode::NOT_ENOUGH_DATA);
|
|
}
|
|
|
|
let subparcel = ReadableSubParcel {
|
|
parcel: BorrowedParcel { ptr: self.ptr, _lifetime: PhantomData },
|
|
end_position: end,
|
|
};
|
|
f(subparcel)?;
|
|
|
|
// Advance the data position to the actual end,
|
|
// in case the closure read less data than was available
|
|
unsafe {
|
|
self.set_data_position(end)?;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Read a vector size from the parcel and resize the given output vector to
|
|
/// be correctly sized for that amount of data.
|
|
///
|
|
/// This method is used in AIDL-generated server side code for methods that
|
|
/// take a mutable slice reference parameter.
|
|
pub fn resize_out_vec<D: Default + Deserialize>(&self, out_vec: &mut Vec<D>) -> Result<()> {
|
|
let len: i32 = self.read()?;
|
|
|
|
if len < 0 {
|
|
return Err(StatusCode::UNEXPECTED_NULL);
|
|
}
|
|
|
|
// usize in Rust may be 16-bit, so i32 may not fit
|
|
let len = len.try_into().unwrap();
|
|
out_vec.resize_with(len, Default::default);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Read a vector size from the parcel and either create a correctly sized
|
|
/// vector for that amount of data or set the output parameter to None if
|
|
/// the vector should be null.
|
|
///
|
|
/// This method is used in AIDL-generated server side code for methods that
|
|
/// take a mutable slice reference parameter.
|
|
pub fn resize_nullable_out_vec<D: Default + Deserialize>(
|
|
&self,
|
|
out_vec: &mut Option<Vec<D>>,
|
|
) -> Result<()> {
|
|
let len: i32 = self.read()?;
|
|
|
|
if len < 0 {
|
|
*out_vec = None;
|
|
} else {
|
|
// usize in Rust may be 16-bit, so i32 may not fit
|
|
let len = len.try_into().unwrap();
|
|
let mut vec = Vec::with_capacity(len);
|
|
vec.resize_with(len, Default::default);
|
|
*out_vec = Some(vec);
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
/// A segment of a readable parcel, used for [`Parcel::sized_read`].
|
|
pub struct ReadableSubParcel<'a> {
|
|
parcel: BorrowedParcel<'a>,
|
|
end_position: i32,
|
|
}
|
|
|
|
impl<'a> ReadableSubParcel<'a> {
|
|
/// Read a type that implements [`Deserialize`] from the sub-parcel.
|
|
pub fn read<D: Deserialize>(&self) -> Result<D> {
|
|
D::deserialize(&self.parcel)
|
|
}
|
|
|
|
/// Check if the sub-parcel has more data to read
|
|
pub fn has_more_data(&self) -> bool {
|
|
self.parcel.get_data_position() < self.end_position
|
|
}
|
|
}
|
|
|
|
impl Parcel {
|
|
/// Attempt to read a type that implements [`Deserialize`] from this parcel.
|
|
pub fn read<D: Deserialize>(&self) -> Result<D> {
|
|
self.borrowed_ref().read()
|
|
}
|
|
|
|
/// Attempt to read a type that implements [`Deserialize`] from this parcel
|
|
/// onto an existing value. This operation will overwrite the old value
|
|
/// partially or completely, depending on how much data is available.
|
|
pub fn read_onto<D: Deserialize>(&self, x: &mut D) -> Result<()> {
|
|
self.borrowed_ref().read_onto(x)
|
|
}
|
|
|
|
/// Safely read a sized parcelable.
|
|
///
|
|
/// Read the size of a parcelable, compute the end position
|
|
/// of that parcelable, then build a sized readable sub-parcel
|
|
/// and call a closure with the sub-parcel as its parameter.
|
|
/// The closure can keep reading data from the sub-parcel
|
|
/// until it runs out of input data. The closure is responsible
|
|
/// for calling [`ReadableSubParcel::has_more_data`] to check for
|
|
/// more data before every read, at least until Rust generators
|
|
/// are stabilized.
|
|
/// After the closure returns, skip to the end of the current
|
|
/// parcelable regardless of how much the closure has read.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```no_run
|
|
/// let mut parcelable = Default::default();
|
|
/// parcel.sized_read(|subparcel| {
|
|
/// if subparcel.has_more_data() {
|
|
/// parcelable.a = subparcel.read()?;
|
|
/// }
|
|
/// if subparcel.has_more_data() {
|
|
/// parcelable.b = subparcel.read()?;
|
|
/// }
|
|
/// Ok(())
|
|
/// });
|
|
/// ```
|
|
///
|
|
pub fn sized_read<F>(&self, f: F) -> Result<()>
|
|
where
|
|
for<'b> F: FnOnce(ReadableSubParcel<'b>) -> Result<()>,
|
|
{
|
|
self.borrowed_ref().sized_read(f)
|
|
}
|
|
|
|
/// Read a vector size from the parcel and resize the given output vector to
|
|
/// be correctly sized for that amount of data.
|
|
///
|
|
/// This method is used in AIDL-generated server side code for methods that
|
|
/// take a mutable slice reference parameter.
|
|
pub fn resize_out_vec<D: Default + Deserialize>(&self, out_vec: &mut Vec<D>) -> Result<()> {
|
|
self.borrowed_ref().resize_out_vec(out_vec)
|
|
}
|
|
|
|
/// Read a vector size from the parcel and either create a correctly sized
|
|
/// vector for that amount of data or set the output parameter to None if
|
|
/// the vector should be null.
|
|
///
|
|
/// This method is used in AIDL-generated server side code for methods that
|
|
/// take a mutable slice reference parameter.
|
|
pub fn resize_nullable_out_vec<D: Default + Deserialize>(
|
|
&self,
|
|
out_vec: &mut Option<Vec<D>>,
|
|
) -> Result<()> {
|
|
self.borrowed_ref().resize_nullable_out_vec(out_vec)
|
|
}
|
|
}
|
|
|
|
// Internal APIs
|
|
impl<'a> BorrowedParcel<'a> {
|
|
pub(crate) fn write_binder(&mut self, binder: Option<&SpIBinder>) -> Result<()> {
|
|
unsafe {
|
|
// Safety: `BorrowedParcel` always contains a valid pointer to an
|
|
// `AParcel`. `AsNative` for `Option<SpIBinder`> will either return
|
|
// null or a valid pointer to an `AIBinder`, both of which are
|
|
// valid, safe inputs to `AParcel_writeStrongBinder`.
|
|
//
|
|
// This call does not take ownership of the binder. However, it does
|
|
// require a mutable pointer, which we cannot extract from an
|
|
// immutable reference, so we clone the binder, incrementing the
|
|
// refcount before the call. The refcount will be immediately
|
|
// decremented when this temporary is dropped.
|
|
status_result(sys::AParcel_writeStrongBinder(
|
|
self.as_native_mut(),
|
|
binder.cloned().as_native_mut(),
|
|
))
|
|
}
|
|
}
|
|
|
|
pub(crate) fn read_binder(&self) -> Result<Option<SpIBinder>> {
|
|
let mut binder = ptr::null_mut();
|
|
let status = unsafe {
|
|
// Safety: `BorrowedParcel` always contains a valid pointer to an
|
|
// `AParcel`. We pass a valid, mutable out pointer to the `binder`
|
|
// parameter. After this call, `binder` will be either null or a
|
|
// valid pointer to an `AIBinder` owned by the caller.
|
|
sys::AParcel_readStrongBinder(self.as_native(), &mut binder)
|
|
};
|
|
|
|
status_result(status)?;
|
|
|
|
Ok(unsafe {
|
|
// Safety: `binder` is either null or a valid, owned pointer at this
|
|
// point, so can be safely passed to `SpIBinder::from_raw`.
|
|
SpIBinder::from_raw(binder)
|
|
})
|
|
}
|
|
}
|
|
|
|
impl Drop for Parcel {
|
|
fn drop(&mut self) {
|
|
// Run the C++ Parcel complete object destructor
|
|
unsafe {
|
|
// Safety: `Parcel` always contains a valid pointer to an
|
|
// `AParcel`. Since we own the parcel, we can safely delete it
|
|
// here.
|
|
sys::AParcel_delete(self.ptr.as_ptr())
|
|
}
|
|
}
|
|
}
|
|
|
|
impl fmt::Debug for Parcel {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
f.debug_struct("Parcel").finish()
|
|
}
|
|
}
|
|
|
|
impl<'a> fmt::Debug for BorrowedParcel<'a> {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
f.debug_struct("BorrowedParcel").finish()
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_read_write() {
|
|
let mut parcel = Parcel::new();
|
|
let start = parcel.get_data_position();
|
|
|
|
assert_eq!(parcel.read::<bool>(), Err(StatusCode::NOT_ENOUGH_DATA));
|
|
assert_eq!(parcel.read::<i8>(), Err(StatusCode::NOT_ENOUGH_DATA));
|
|
assert_eq!(parcel.read::<u16>(), Err(StatusCode::NOT_ENOUGH_DATA));
|
|
assert_eq!(parcel.read::<i32>(), Err(StatusCode::NOT_ENOUGH_DATA));
|
|
assert_eq!(parcel.read::<u32>(), Err(StatusCode::NOT_ENOUGH_DATA));
|
|
assert_eq!(parcel.read::<i64>(), Err(StatusCode::NOT_ENOUGH_DATA));
|
|
assert_eq!(parcel.read::<u64>(), Err(StatusCode::NOT_ENOUGH_DATA));
|
|
assert_eq!(parcel.read::<f32>(), Err(StatusCode::NOT_ENOUGH_DATA));
|
|
assert_eq!(parcel.read::<f64>(), Err(StatusCode::NOT_ENOUGH_DATA));
|
|
assert_eq!(parcel.read::<Option<String>>(), Ok(None));
|
|
assert_eq!(parcel.read::<String>(), Err(StatusCode::UNEXPECTED_NULL));
|
|
|
|
assert_eq!(parcel.borrowed_ref().read_binder().err(), Some(StatusCode::BAD_TYPE));
|
|
|
|
parcel.write(&1i32).unwrap();
|
|
|
|
unsafe {
|
|
parcel.set_data_position(start).unwrap();
|
|
}
|
|
|
|
let i: i32 = parcel.read().unwrap();
|
|
assert_eq!(i, 1i32);
|
|
}
|
|
|
|
#[test]
|
|
#[allow(clippy::float_cmp)]
|
|
fn test_read_data() {
|
|
let mut parcel = Parcel::new();
|
|
let str_start = parcel.get_data_position();
|
|
|
|
parcel.write(&b"Hello, Binder!\0"[..]).unwrap();
|
|
// Skip over string length
|
|
unsafe {
|
|
assert!(parcel.set_data_position(str_start).is_ok());
|
|
}
|
|
assert_eq!(parcel.read::<i32>().unwrap(), 15);
|
|
let start = parcel.get_data_position();
|
|
|
|
assert!(parcel.read::<bool>().unwrap());
|
|
|
|
unsafe {
|
|
assert!(parcel.set_data_position(start).is_ok());
|
|
}
|
|
|
|
assert_eq!(parcel.read::<i8>().unwrap(), 72i8);
|
|
|
|
unsafe {
|
|
assert!(parcel.set_data_position(start).is_ok());
|
|
}
|
|
|
|
assert_eq!(parcel.read::<u16>().unwrap(), 25928);
|
|
|
|
unsafe {
|
|
assert!(parcel.set_data_position(start).is_ok());
|
|
}
|
|
|
|
assert_eq!(parcel.read::<i32>().unwrap(), 1819043144);
|
|
|
|
unsafe {
|
|
assert!(parcel.set_data_position(start).is_ok());
|
|
}
|
|
|
|
assert_eq!(parcel.read::<u32>().unwrap(), 1819043144);
|
|
|
|
unsafe {
|
|
assert!(parcel.set_data_position(start).is_ok());
|
|
}
|
|
|
|
assert_eq!(parcel.read::<i64>().unwrap(), 4764857262830019912);
|
|
|
|
unsafe {
|
|
assert!(parcel.set_data_position(start).is_ok());
|
|
}
|
|
|
|
assert_eq!(parcel.read::<u64>().unwrap(), 4764857262830019912);
|
|
|
|
unsafe {
|
|
assert!(parcel.set_data_position(start).is_ok());
|
|
}
|
|
|
|
assert_eq!(parcel.read::<f32>().unwrap(), 1143139100000000000000000000.0);
|
|
assert_eq!(parcel.read::<f32>().unwrap(), 40.043392);
|
|
|
|
unsafe {
|
|
assert!(parcel.set_data_position(start).is_ok());
|
|
}
|
|
|
|
assert_eq!(parcel.read::<f64>().unwrap(), 34732488246.197815);
|
|
|
|
// Skip back to before the string length
|
|
unsafe {
|
|
assert!(parcel.set_data_position(str_start).is_ok());
|
|
}
|
|
|
|
assert_eq!(parcel.read::<Vec<u8>>().unwrap(), b"Hello, Binder!\0");
|
|
}
|
|
|
|
#[test]
|
|
fn test_utf8_utf16_conversions() {
|
|
let mut parcel = Parcel::new();
|
|
let start = parcel.get_data_position();
|
|
|
|
assert!(parcel.write("Hello, Binder!").is_ok());
|
|
unsafe {
|
|
assert!(parcel.set_data_position(start).is_ok());
|
|
}
|
|
assert_eq!(parcel.read::<Option<String>>().unwrap().unwrap(), "Hello, Binder!",);
|
|
unsafe {
|
|
assert!(parcel.set_data_position(start).is_ok());
|
|
}
|
|
|
|
assert!(parcel.write("Embedded null \0 inside a string").is_ok());
|
|
unsafe {
|
|
assert!(parcel.set_data_position(start).is_ok());
|
|
}
|
|
assert_eq!(
|
|
parcel.read::<Option<String>>().unwrap().unwrap(),
|
|
"Embedded null \0 inside a string",
|
|
);
|
|
unsafe {
|
|
assert!(parcel.set_data_position(start).is_ok());
|
|
}
|
|
|
|
assert!(parcel.write(&["str1", "str2", "str3"][..]).is_ok());
|
|
assert!(parcel
|
|
.write(&[String::from("str4"), String::from("str5"), String::from("str6"),][..])
|
|
.is_ok());
|
|
|
|
let s1 = "Hello, Binder!";
|
|
let s2 = "This is a utf8 string.";
|
|
let s3 = "Some more text here.";
|
|
|
|
assert!(parcel.write(&[s1, s2, s3][..]).is_ok());
|
|
unsafe {
|
|
assert!(parcel.set_data_position(start).is_ok());
|
|
}
|
|
|
|
assert_eq!(parcel.read::<Vec<String>>().unwrap(), ["str1", "str2", "str3"]);
|
|
assert_eq!(parcel.read::<Vec<String>>().unwrap(), ["str4", "str5", "str6"]);
|
|
assert_eq!(parcel.read::<Vec<String>>().unwrap(), [s1, s2, s3]);
|
|
}
|
|
|
|
#[test]
|
|
fn test_sized_write() {
|
|
let mut parcel = Parcel::new();
|
|
let start = parcel.get_data_position();
|
|
|
|
let arr = [1i32, 2i32, 3i32];
|
|
|
|
parcel
|
|
.sized_write(|subparcel| subparcel.write(&arr[..]))
|
|
.expect("Could not perform sized write");
|
|
|
|
// i32 sub-parcel length + i32 array length + 3 i32 elements
|
|
let expected_len = 20i32;
|
|
|
|
assert_eq!(parcel.get_data_position(), start + expected_len);
|
|
|
|
unsafe {
|
|
parcel.set_data_position(start).unwrap();
|
|
}
|
|
|
|
assert_eq!(expected_len, parcel.read().unwrap(),);
|
|
|
|
assert_eq!(parcel.read::<Vec<i32>>().unwrap(), &arr,);
|
|
}
|
|
|
|
#[test]
|
|
fn test_append_from() {
|
|
let mut parcel1 = Parcel::new();
|
|
parcel1.write(&42i32).expect("Could not perform write");
|
|
|
|
let mut parcel2 = Parcel::new();
|
|
assert_eq!(Ok(()), parcel2.append_all_from(&parcel1));
|
|
assert_eq!(4, parcel2.get_data_size());
|
|
assert_eq!(Ok(()), parcel2.append_all_from(&parcel1));
|
|
assert_eq!(8, parcel2.get_data_size());
|
|
unsafe {
|
|
parcel2.set_data_position(0).unwrap();
|
|
}
|
|
assert_eq!(Ok(42), parcel2.read::<i32>());
|
|
assert_eq!(Ok(42), parcel2.read::<i32>());
|
|
|
|
let mut parcel2 = Parcel::new();
|
|
assert_eq!(Ok(()), parcel2.append_from(&parcel1, 0, 2));
|
|
assert_eq!(Ok(()), parcel2.append_from(&parcel1, 2, 2));
|
|
assert_eq!(4, parcel2.get_data_size());
|
|
unsafe {
|
|
parcel2.set_data_position(0).unwrap();
|
|
}
|
|
assert_eq!(Ok(42), parcel2.read::<i32>());
|
|
|
|
let mut parcel2 = Parcel::new();
|
|
assert_eq!(Ok(()), parcel2.append_from(&parcel1, 0, 2));
|
|
assert_eq!(2, parcel2.get_data_size());
|
|
unsafe {
|
|
parcel2.set_data_position(0).unwrap();
|
|
}
|
|
assert_eq!(Err(StatusCode::NOT_ENOUGH_DATA), parcel2.read::<i32>());
|
|
|
|
let mut parcel2 = Parcel::new();
|
|
assert_eq!(Err(StatusCode::BAD_VALUE), parcel2.append_from(&parcel1, 4, 2));
|
|
assert_eq!(Err(StatusCode::BAD_VALUE), parcel2.append_from(&parcel1, 2, 4));
|
|
assert_eq!(Err(StatusCode::BAD_VALUE), parcel2.append_from(&parcel1, -1, 4));
|
|
assert_eq!(Err(StatusCode::BAD_VALUE), parcel2.append_from(&parcel1, 2, -1));
|
|
}
|