Struct Parcel

pub struct Parcel { /* private fields */ }

Represents a binder serializable parcel

Implementations

impl Parcel

pub fn empty() -> Self

Create a new empty parcel.

Examples found in repository

examples/simple.rs (line 9)

fn main() {
    let mut service_manager = &mut ServiceManager::new();

    let mut package_manager = service_manager.get_service("myservice", "com.example.IMyService");

    let mut parcel = Parcel::empty();
    parcel.write_str16("Hello World");
    let mut res = package_manager.call(1, &mut parcel);
    println!("response: {:?}", res.read_str16());

    let mut parcel = Parcel::empty();
    parcel.write_str16("/data/local/tmp/testfile");
    let mut res = package_manager.call(2, &mut parcel);
    let fd = res.read_file_descriptor();
    unsafe {
        nix::libc::write(fd, "Hello world".as_ptr() as *const std::ffi::c_void, 11);
    }
}

examples/myservice.rs (line 30)

    fn process_request(&self, code: u32, data: &mut Parcel) -> Parcel {
        println!("Got command: {} -> {:?}", code, MyServiceCommands::from_u32(code));
        match MyServiceCommands::from_u32(code).unwrap() {
            MyServiceCommands::GetFile => {
                let filename = &std::ffi::CString::new(data.read_str16()).unwrap();
                let fd = unsafe { open(filename.as_ptr(), O_RDWR | O_CREAT) };
                println!("filename: {:?}, fd: {}", filename, fd);
                let mut parcel = Parcel::empty();
                parcel.write_u32(0);
                parcel.write_file_descriptor(fd, false);
                parcel
            },
            MyServiceCommands::Echo => {
                let mut parcel = Parcel::empty();
                parcel.write_u32(0); //status
                parcel.write_str16(&data.read_str16());
                parcel
            }
        }
    }

pub fn from_slice(data: &[u8]) -> Self

Create a new empty parcel, with a reserved size

pub fn from_data_and_offsets( data: *mut u8, data_size: usize, offsets: *mut usize, offsets_size: usize, ) -> Self

pub fn reset(&mut self)

pub fn position(&self) -> u64

pub fn set_position(&mut self, pos: u64)

pub fn append_parcel(&mut self, other: &mut Parcel)

Append the contents of another parcel to this parcel

pub fn as_ptr(&self) -> *const u8

Retrieve the data of the parcel as a pointer

pub fn as_mut_ptr(&mut self) -> *mut u8

Retrieve the data of the parcel as a mutable pointer

pub fn to_slice(&self) -> &[u8]

Retrieve the data of the parce as a slice

pub fn len(&self) -> usize

Retrieve the size of the parcel’s data

pub fn offsets_len(&self) -> usize

Retrieve the number of object offsets

pub fn offsets(&mut self) -> &mut Vec<usize>

Retrieve the object offsets

pub fn has_unread_data(&self) -> bool

Check if the parcel has unread data

pub fn write_i32(&mut self, data: i32)

Write an i32 to the parcel

pub fn write_u32(&mut self, data: u32)

Write an u32 to the parcel

Examples found in repository

examples/myservice.rs (line 31)

    fn process_request(&self, code: u32, data: &mut Parcel) -> Parcel {
        println!("Got command: {} -> {:?}", code, MyServiceCommands::from_u32(code));
        match MyServiceCommands::from_u32(code).unwrap() {
            MyServiceCommands::GetFile => {
                let filename = &std::ffi::CString::new(data.read_str16()).unwrap();
                let fd = unsafe { open(filename.as_ptr(), O_RDWR | O_CREAT) };
                println!("filename: {:?}, fd: {}", filename, fd);
                let mut parcel = Parcel::empty();
                parcel.write_u32(0);
                parcel.write_file_descriptor(fd, false);
                parcel
            },
            MyServiceCommands::Echo => {
                let mut parcel = Parcel::empty();
                parcel.write_u32(0); //status
                parcel.write_str16(&data.read_str16());
                parcel
            }
        }
    }

pub fn write_u16(&mut self, data: u16)

Write an u16 to the parcel

pub fn write_bool(&mut self, data: bool)

Write a bool to the parcel

pub fn read_i32(&mut self) -> i32

Read an i32 from the parcel

pub fn write(&mut self, data: &[u8])

Write a slice of data to the parcel

pub fn write_transaction_data(&mut self, data: &BinderTransactionData)

Write a BinderTransactionData struct into the parcel

pub fn read_u32(&mut self) -> u32

Read an u32 from the parcel

pub fn read_u64(&mut self) -> u64

Read an u64 from the parcel

pub fn read_usize(&mut self) -> usize

Read an usize from the parcel

pub fn read_pointer(&mut self) -> *const c_void

Read a void pointer from the parcel

pub fn read(&mut self, size: usize) -> Vec<u8>

Read a slice of size bytes from the parcel

pub fn read_without_alignment(&mut self, size: usize) -> Vec<u8>

Read a slice of size bytes from the parcel

pub fn read_transaction_data(&mut self) -> BinderTransactionData

Read a BinderTransactionData from the parcel

pub fn read_object<T>(&mut self) -> T

Read an object of type T from the parcel

pub fn write_object<T>(&mut self, object: T)

pub fn write_str16(&mut self, string: &str)

Write a string to the parcel

Examples found in repository

examples/simple.rs (line 10)

fn main() {
    let mut service_manager = &mut ServiceManager::new();

    let mut package_manager = service_manager.get_service("myservice", "com.example.IMyService");

    let mut parcel = Parcel::empty();
    parcel.write_str16("Hello World");
    let mut res = package_manager.call(1, &mut parcel);
    println!("response: {:?}", res.read_str16());

    let mut parcel = Parcel::empty();
    parcel.write_str16("/data/local/tmp/testfile");
    let mut res = package_manager.call(2, &mut parcel);
    let fd = res.read_file_descriptor();
    unsafe {
        nix::libc::write(fd, "Hello world".as_ptr() as *const std::ffi::c_void, 11);
    }
}

examples/myservice.rs (line 38)

    fn process_request(&self, code: u32, data: &mut Parcel) -> Parcel {
        println!("Got command: {} -> {:?}", code, MyServiceCommands::from_u32(code));
        match MyServiceCommands::from_u32(code).unwrap() {
            MyServiceCommands::GetFile => {
                let filename = &std::ffi::CString::new(data.read_str16()).unwrap();
                let fd = unsafe { open(filename.as_ptr(), O_RDWR | O_CREAT) };
                println!("filename: {:?}, fd: {}", filename, fd);
                let mut parcel = Parcel::empty();
                parcel.write_u32(0);
                parcel.write_file_descriptor(fd, false);
                parcel
            },
            MyServiceCommands::Echo => {
                let mut parcel = Parcel::empty();
                parcel.write_u32(0); //status
                parcel.write_str16(&data.read_str16());
                parcel
            }
        }
    }

pub fn write_binder(&mut self, object: *const c_void)

Write a Binder object into the parcel

pub fn write_file_descriptor(&mut self, fd: RawFd, take_ownership: bool)

Write a file descriptor into the parcel

Examples found in repository

examples/myservice.rs (line 32)

    fn process_request(&self, code: u32, data: &mut Parcel) -> Parcel {
        println!("Got command: {} -> {:?}", code, MyServiceCommands::from_u32(code));
        match MyServiceCommands::from_u32(code).unwrap() {
            MyServiceCommands::GetFile => {
                let filename = &std::ffi::CString::new(data.read_str16()).unwrap();
                let fd = unsafe { open(filename.as_ptr(), O_RDWR | O_CREAT) };
                println!("filename: {:?}, fd: {}", filename, fd);
                let mut parcel = Parcel::empty();
                parcel.write_u32(0);
                parcel.write_file_descriptor(fd, false);
                parcel
            },
            MyServiceCommands::Echo => {
                let mut parcel = Parcel::empty();
                parcel.write_u32(0); //status
                parcel.write_str16(&data.read_str16());
                parcel
            }
        }
    }

pub fn read_file_descriptor(&mut self) -> RawFd

REad a file descriptor from the parcel

Examples found in repository

examples/simple.rs (line 17)

fn main() {
    let mut service_manager = &mut ServiceManager::new();

    let mut package_manager = service_manager.get_service("myservice", "com.example.IMyService");

    let mut parcel = Parcel::empty();
    parcel.write_str16("Hello World");
    let mut res = package_manager.call(1, &mut parcel);
    println!("response: {:?}", res.read_str16());

    let mut parcel = Parcel::empty();
    parcel.write_str16("/data/local/tmp/testfile");
    let mut res = package_manager.call(2, &mut parcel);
    let fd = res.read_file_descriptor();
    unsafe {
        nix::libc::write(fd, "Hello world".as_ptr() as *const std::ffi::c_void, 11);
    }
}

pub fn read_str16(&mut self) -> String

Read a string from the parcel

Examples found in repository

examples/simple.rs (line 12)

fn main() {
    let mut service_manager = &mut ServiceManager::new();

    let mut package_manager = service_manager.get_service("myservice", "com.example.IMyService");

    let mut parcel = Parcel::empty();
    parcel.write_str16("Hello World");
    let mut res = package_manager.call(1, &mut parcel);
    println!("response: {:?}", res.read_str16());

    let mut parcel = Parcel::empty();
    parcel.write_str16("/data/local/tmp/testfile");
    let mut res = package_manager.call(2, &mut parcel);
    let fd = res.read_file_descriptor();
    unsafe {
        nix::libc::write(fd, "Hello world".as_ptr() as *const std::ffi::c_void, 11);
    }
}

examples/myservice.rs (line 27)

    fn process_request(&self, code: u32, data: &mut Parcel) -> Parcel {
        println!("Got command: {} -> {:?}", code, MyServiceCommands::from_u32(code));
        match MyServiceCommands::from_u32(code).unwrap() {
            MyServiceCommands::GetFile => {
                let filename = &std::ffi::CString::new(data.read_str16()).unwrap();
                let fd = unsafe { open(filename.as_ptr(), O_RDWR | O_CREAT) };
                println!("filename: {:?}, fd: {}", filename, fd);
                let mut parcel = Parcel::empty();
                parcel.write_u32(0);
                parcel.write_file_descriptor(fd, false);
                parcel
            },
            MyServiceCommands::Echo => {
                let mut parcel = Parcel::empty();
                parcel.write_u32(0); //status
                parcel.write_str16(&data.read_str16());
                parcel
            }
        }
    }

pub fn read_str(&mut self) -> String

Read a string from the parcel

pub fn read_interface_token(&mut self) -> String

Read an interface token from the parcel

pub fn write_interface_token(&mut self, name: &str)

Write an interface token to the parcel

Trait Implementations

impl Debug for Parcel

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.