1 mod attr;
2 mod dir;
3 mod remote_file;
4
5 pub use attr::Attr;
6 pub use dir::{InMemoryDir, RemoteDirEditor};
7 pub use remote_file::{RemoteFileEditor, RemoteFileReader, RemoteMerkleTreeReader};
8
9 use binder::unstable_api::{new_spibinder, AIBinder};
10 use binder::FromIBinder;
11 use std::convert::TryFrom;
12 use std::io;
13 use std::path::{Path, MAIN_SEPARATOR};
14
15 use crate::common::{divide_roundup, CHUNK_SIZE};
16 use authfs_aidl_interface::aidl::com::android::virt::fs::IVirtFdService::IVirtFdService;
17 use authfs_aidl_interface::binder::{Status, Strong};
18
19 pub type VirtFdService = Strong<dyn IVirtFdService>;
20 pub type VirtFdServiceStatus = Status;
21
22 pub type ChunkBuffer = [u8; CHUNK_SIZE as usize];
23
24 pub const RPC_SERVICE_PORT: u32 = 3264;
25
get_rpc_binder_service(cid: u32) -> io::Result<VirtFdService>26 pub fn get_rpc_binder_service(cid: u32) -> io::Result<VirtFdService> {
27 // SAFETY: AIBinder returned by RpcClient has correct reference count, and the ownership can be
28 // safely taken by new_spibinder.
29 let ibinder = unsafe {
30 new_spibinder(binder_rpc_unstable_bindgen::RpcClient(cid, RPC_SERVICE_PORT) as *mut AIBinder)
31 };
32 if let Some(ibinder) = ibinder {
33 Ok(<dyn IVirtFdService>::try_from(ibinder).map_err(|e| {
34 io::Error::new(
35 io::ErrorKind::AddrNotAvailable,
36 format!("Cannot connect to RPC service: {}", e),
37 )
38 })?)
39 } else {
40 Err(io::Error::new(io::ErrorKind::InvalidInput, "Invalid raw AIBinder"))
41 }
42 }
43
44 /// A trait for reading data by chunks. Chunks can be read by specifying the chunk index. Only the
45 /// last chunk may have incomplete chunk size.
46 pub trait ReadByChunk {
47 /// Reads the `chunk_index`-th chunk to a `ChunkBuffer`. Returns the size read, which has to be
48 /// `CHUNK_SIZE` except for the last incomplete chunk. Reading beyond the file size (including
49 /// empty file) should return 0.
read_chunk(&self, chunk_index: u64, buf: &mut ChunkBuffer) -> io::Result<usize>50 fn read_chunk(&self, chunk_index: u64, buf: &mut ChunkBuffer) -> io::Result<usize>;
51 }
52
53 /// A trait to write a buffer to the destination at a given offset. The implementation does not
54 /// necessarily own or maintain the destination state.
55 ///
56 /// NB: The trait is required in a member of `fusefs::AuthFs`, which is required to be Sync and
57 /// immutable (this the member).
58 pub trait RandomWrite {
59 /// Writes `buf` to the destination at `offset`. Returns the written size, which may not be the
60 /// full buffer.
write_at(&self, buf: &[u8], offset: u64) -> io::Result<usize>61 fn write_at(&self, buf: &[u8], offset: u64) -> io::Result<usize>;
62
63 /// Writes the full `buf` to the destination at `offset`.
write_all_at(&self, buf: &[u8], offset: u64) -> io::Result<()>64 fn write_all_at(&self, buf: &[u8], offset: u64) -> io::Result<()> {
65 let mut input_offset = 0;
66 let mut output_offset = offset;
67 while input_offset < buf.len() {
68 let size = self.write_at(&buf[input_offset..], output_offset)?;
69 input_offset += size;
70 output_offset += size as u64;
71 }
72 Ok(())
73 }
74
75 /// Resizes the file to the new size.
resize(&self, size: u64) -> io::Result<()>76 fn resize(&self, size: u64) -> io::Result<()>;
77 }
78
79 /// Checks whether the path is a simple file name without any directory separator.
validate_basename(path: &Path) -> io::Result<()>80 pub fn validate_basename(path: &Path) -> io::Result<()> {
81 if matches!(path.to_str(), Some(path_str) if !path_str.contains(MAIN_SEPARATOR)) {
82 Ok(())
83 } else {
84 Err(io::Error::from_raw_os_error(libc::EINVAL))
85 }
86 }
87
88 pub struct EagerChunkReader {
89 buffer: Vec<u8>,
90 }
91
92 impl EagerChunkReader {
new<F: ReadByChunk>(chunked_file: F, file_size: u64) -> io::Result<EagerChunkReader>93 pub fn new<F: ReadByChunk>(chunked_file: F, file_size: u64) -> io::Result<EagerChunkReader> {
94 let last_index = divide_roundup(file_size, CHUNK_SIZE);
95 let file_size = usize::try_from(file_size).unwrap();
96 let mut buffer = Vec::with_capacity(file_size);
97 let mut chunk_buffer = [0; CHUNK_SIZE as usize];
98 for index in 0..last_index {
99 let size = chunked_file.read_chunk(index, &mut chunk_buffer)?;
100 buffer.extend_from_slice(&chunk_buffer[..size]);
101 }
102 if buffer.len() < file_size {
103 Err(io::Error::new(
104 io::ErrorKind::InvalidData,
105 format!("Insufficient data size ({} < {})", buffer.len(), file_size),
106 ))
107 } else {
108 Ok(EagerChunkReader { buffer })
109 }
110 }
111 }
112
113 impl ReadByChunk for EagerChunkReader {
read_chunk(&self, chunk_index: u64, buf: &mut ChunkBuffer) -> io::Result<usize>114 fn read_chunk(&self, chunk_index: u64, buf: &mut ChunkBuffer) -> io::Result<usize> {
115 if let Some(chunk) = &self.buffer.chunks(CHUNK_SIZE as usize).nth(chunk_index as usize) {
116 buf[..chunk.len()].copy_from_slice(chunk);
117 Ok(chunk.len())
118 } else {
119 Ok(0) // Read beyond EOF is normal
120 }
121 }
122 }
123