blob: 9a60bf7a7b2dad83d858f28e75ec0f4496d48efe [file] [log] [blame]
Victor Hsiehb0f5fc82021-10-15 17:24:19 -07001/*
2 * Copyright (C) 2021 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
17use anyhow::Result;
18use log::error;
Victor Hsieh45636232021-10-15 17:52:51 -070019use nix::{
Victor Hsiehbf944d72022-03-07 23:46:43 +000020 errno::Errno, fcntl::openat, fcntl::OFlag, sys::stat::fchmod, sys::stat::mkdirat,
Victor Hsiehf393a722021-12-08 13:04:27 -080021 sys::stat::mode_t, sys::stat::Mode, sys::statvfs::statvfs, sys::statvfs::Statvfs,
22 unistd::unlinkat, unistd::UnlinkatFlags,
Victor Hsieh45636232021-10-15 17:52:51 -070023};
Victor Hsiehb0f5fc82021-10-15 17:24:19 -070024use std::cmp::min;
Victor Hsieh45636232021-10-15 17:52:51 -070025use std::collections::{btree_map, BTreeMap};
Victor Hsiehb0f5fc82021-10-15 17:24:19 -070026use std::convert::TryInto;
27use std::fs::File;
28use std::io;
29use std::os::unix::fs::FileExt;
Victor Hsieh559b9272021-11-08 15:15:14 -080030use std::os::unix::io::{AsRawFd, FromRawFd, RawFd};
31use std::path::{Component, Path, PathBuf, MAIN_SEPARATOR};
Victor Hsiehbf944d72022-03-07 23:46:43 +000032use std::sync::{Arc, RwLock};
Victor Hsiehb0f5fc82021-10-15 17:24:19 -070033
Victor Hsiehbf944d72022-03-07 23:46:43 +000034use crate::common::OwnedFd;
Victor Hsiehb0f5fc82021-10-15 17:24:19 -070035use crate::fsverity;
36use authfs_aidl_interface::aidl::com::android::virt::fs::IVirtFdService::{
Victor Hsiehf7fc3d32021-11-22 10:20:33 -080037 BnVirtFdService, FsStat::FsStat, IVirtFdService, MAX_REQUESTING_DATA,
Victor Hsiehb0f5fc82021-10-15 17:24:19 -070038};
Inseob Kimc0886c22021-12-13 17:41:24 +090039use authfs_fsverity_metadata::{
40 get_fsverity_metadata_path, parse_fsverity_metadata, FSVerityMetadata,
41};
Alan Stokes0e82b502022-08-08 14:44:48 +010042use binder::{
43 BinderFeatures, ExceptionCode, Interface, Result as BinderResult, Status, StatusCode, Strong,
44};
Victor Hsiehb0f5fc82021-10-15 17:24:19 -070045
Victor Hsiehf393a722021-12-08 13:04:27 -080046/// Bitflags of forbidden file mode, e.g. setuid, setgid and sticky bit.
47const FORBIDDEN_MODES: Mode = Mode::from_bits_truncate(!0o777);
Victor Hsiehb0f5fc82021-10-15 17:24:19 -070048
49/// Configuration of a file descriptor to be served/exposed/shared.
50pub enum FdConfig {
51 /// A read-only file to serve by this server. The file is supposed to be verifiable with the
52 /// associated fs-verity metadata.
53 Readonly {
54 /// The file to read from. fs-verity metadata can be retrieved from this file's FD.
55 file: File,
56
Inseob Kimc0886c22021-12-13 17:41:24 +090057 // Alternative metadata storing merkle tree and signature.
58 alt_metadata: Option<Box<FSVerityMetadata>>,
Victor Hsiehb0f5fc82021-10-15 17:24:19 -070059 },
60
61 /// A readable/writable file to serve by this server. This backing file should just be a
62 /// regular file and does not have any specific property.
63 ReadWrite(File),
Victor Hsieh45636232021-10-15 17:52:51 -070064
Victor Hsieh559b9272021-11-08 15:15:14 -080065 /// A read-only directory to serve by this server.
Victor Hsiehbf944d72022-03-07 23:46:43 +000066 InputDir(OwnedFd),
Victor Hsieh559b9272021-11-08 15:15:14 -080067
Victor Hsieh45636232021-10-15 17:52:51 -070068 /// A writable directory to serve by this server.
Victor Hsiehbf944d72022-03-07 23:46:43 +000069 OutputDir(OwnedFd),
Victor Hsiehb0f5fc82021-10-15 17:24:19 -070070}
71
72pub struct FdService {
Victor Hsieh45636232021-10-15 17:52:51 -070073 /// A pool of opened files and directories, which can be looked up by the FD number.
Victor Hsiehbf944d72022-03-07 23:46:43 +000074 fd_pool: Arc<RwLock<BTreeMap<i32, FdConfig>>>,
Victor Hsiehb0f5fc82021-10-15 17:24:19 -070075}
76
77impl FdService {
78 pub fn new_binder(fd_pool: BTreeMap<i32, FdConfig>) -> Strong<dyn IVirtFdService> {
Victor Hsieh45636232021-10-15 17:52:51 -070079 BnVirtFdService::new_binder(
Victor Hsiehbf944d72022-03-07 23:46:43 +000080 FdService { fd_pool: Arc::new(RwLock::new(fd_pool)) },
Victor Hsieh45636232021-10-15 17:52:51 -070081 BinderFeatures::default(),
82 )
Victor Hsiehb0f5fc82021-10-15 17:24:19 -070083 }
84
Victor Hsieh45636232021-10-15 17:52:51 -070085 /// Handles the requesting file `id` with `handle_fn` if it is in the FD pool. This function
86 /// returns whatever `handle_fn` returns.
87 fn handle_fd<F, R>(&self, id: i32, handle_fn: F) -> BinderResult<R>
Victor Hsiehc85e4ef2021-10-18 15:28:53 -070088 where
89 F: FnOnce(&FdConfig) -> BinderResult<R>,
90 {
Victor Hsiehbf944d72022-03-07 23:46:43 +000091 let fd_pool = self.fd_pool.read().unwrap();
Victor Hsieh45636232021-10-15 17:52:51 -070092 let fd_config = fd_pool.get(&id).ok_or_else(|| new_errno_error(Errno::EBADF))?;
93 handle_fn(fd_config)
94 }
95
96 /// Inserts a new FD and corresponding `FdConfig` created by `create_fn` to the FD pool, then
97 /// returns the new FD number.
98 fn insert_new_fd<F>(&self, fd: i32, create_fn: F) -> BinderResult<i32>
99 where
100 F: FnOnce(&mut FdConfig) -> BinderResult<(i32, FdConfig)>,
101 {
Victor Hsiehbf944d72022-03-07 23:46:43 +0000102 let mut fd_pool = self.fd_pool.write().unwrap();
Chris Wailes641fc4a2021-12-01 15:03:21 -0800103 let fd_config = fd_pool.get_mut(&fd).ok_or_else(|| new_errno_error(Errno::EBADF))?;
104 let (new_fd, new_fd_config) = create_fn(fd_config)?;
Victor Hsieh45636232021-10-15 17:52:51 -0700105 if let btree_map::Entry::Vacant(entry) = fd_pool.entry(new_fd) {
106 entry.insert(new_fd_config);
107 Ok(new_fd)
108 } else {
Andrew Walbrandcf9d582022-08-03 11:25:24 +0000109 Err(Status::new_exception_str(
Victor Hsieh45636232021-10-15 17:52:51 -0700110 ExceptionCode::ILLEGAL_STATE,
Andrew Walbrandcf9d582022-08-03 11:25:24 +0000111 Some(format!(
112 "The newly created FD {} is already in the pool unexpectedly",
113 new_fd
114 )),
Victor Hsieh45636232021-10-15 17:52:51 -0700115 ))
116 }
Victor Hsiehb0f5fc82021-10-15 17:24:19 -0700117 }
118}
119
120impl Interface for FdService {}
121
122impl IVirtFdService for FdService {
123 fn readFile(&self, id: i32, offset: i64, size: i32) -> BinderResult<Vec<u8>> {
124 let size: usize = validate_and_cast_size(size)?;
125 let offset: u64 = validate_and_cast_offset(offset)?;
126
Victor Hsiehc85e4ef2021-10-18 15:28:53 -0700127 self.handle_fd(id, |config| match config {
Victor Hsiehb0f5fc82021-10-15 17:24:19 -0700128 FdConfig::Readonly { file, .. } | FdConfig::ReadWrite(file) => {
129 read_into_buf(file, size, offset).map_err(|e| {
130 error!("readFile: read error: {}", e);
Victor Hsiehbe8b08d2021-10-29 16:31:24 -0700131 new_errno_error(Errno::EIO)
Victor Hsiehb0f5fc82021-10-15 17:24:19 -0700132 })
133 }
Victor Hsieh559b9272021-11-08 15:15:14 -0800134 FdConfig::InputDir(_) | FdConfig::OutputDir(_) => Err(new_errno_error(Errno::EISDIR)),
Victor Hsiehc85e4ef2021-10-18 15:28:53 -0700135 })
Victor Hsiehb0f5fc82021-10-15 17:24:19 -0700136 }
137
138 fn readFsverityMerkleTree(&self, id: i32, offset: i64, size: i32) -> BinderResult<Vec<u8>> {
139 let size: usize = validate_and_cast_size(size)?;
140 let offset: u64 = validate_and_cast_offset(offset)?;
141
Victor Hsiehc85e4ef2021-10-18 15:28:53 -0700142 self.handle_fd(id, |config| match config {
Inseob Kimc0886c22021-12-13 17:41:24 +0900143 FdConfig::Readonly { file, alt_metadata, .. } => {
144 let mut buf = vec![0; size];
145
146 let s = if let Some(metadata) = &alt_metadata {
147 metadata.read_merkle_tree(offset, &mut buf).map_err(|e| {
Victor Hsiehb0f5fc82021-10-15 17:24:19 -0700148 error!("readFsverityMerkleTree: read error: {}", e);
Victor Hsiehbe8b08d2021-10-29 16:31:24 -0700149 new_errno_error(Errno::EIO)
Inseob Kimc0886c22021-12-13 17:41:24 +0900150 })?
Victor Hsiehb0f5fc82021-10-15 17:24:19 -0700151 } else {
Inseob Kimc0886c22021-12-13 17:41:24 +0900152 fsverity::read_merkle_tree(file.as_raw_fd(), offset, &mut buf).map_err(|e| {
153 error!("readFsverityMerkleTree: failed to retrieve merkle tree: {}", e);
154 new_errno_error(Errno::EIO)
155 })?
156 };
157 debug_assert!(s <= buf.len(), "Shouldn't return more bytes than asked");
158 buf.truncate(s);
159 Ok(buf)
Victor Hsiehb0f5fc82021-10-15 17:24:19 -0700160 }
161 FdConfig::ReadWrite(_file) => {
162 // For a writable file, Merkle tree is not expected to be served since Auth FS
163 // doesn't trust it anyway. Auth FS may keep the Merkle tree privately for its own
164 // use.
Victor Hsiehbe8b08d2021-10-29 16:31:24 -0700165 Err(new_errno_error(Errno::ENOSYS))
Victor Hsiehb0f5fc82021-10-15 17:24:19 -0700166 }
Victor Hsieh559b9272021-11-08 15:15:14 -0800167 FdConfig::InputDir(_) | FdConfig::OutputDir(_) => Err(new_errno_error(Errno::EISDIR)),
Victor Hsiehc85e4ef2021-10-18 15:28:53 -0700168 })
Victor Hsiehb0f5fc82021-10-15 17:24:19 -0700169 }
170
171 fn readFsveritySignature(&self, id: i32) -> BinderResult<Vec<u8>> {
Victor Hsiehc85e4ef2021-10-18 15:28:53 -0700172 self.handle_fd(id, |config| match config {
Inseob Kimc0886c22021-12-13 17:41:24 +0900173 FdConfig::Readonly { file, alt_metadata, .. } => {
174 if let Some(metadata) = &alt_metadata {
175 if let Some(signature) = &metadata.signature {
176 Ok(signature.clone())
177 } else {
Andrew Walbrandcf9d582022-08-03 11:25:24 +0000178 Err(Status::new_service_specific_error_str(
179 -1,
180 Some("metadata doesn't contain a signature"),
Inseob Kimc0886c22021-12-13 17:41:24 +0900181 ))
182 }
Victor Hsiehb0f5fc82021-10-15 17:24:19 -0700183 } else {
184 let mut buf = vec![0; MAX_REQUESTING_DATA as usize];
185 let s = fsverity::read_signature(file.as_raw_fd(), &mut buf).map_err(|e| {
186 error!("readFsverityMerkleTree: failed to retrieve merkle tree: {}", e);
Victor Hsiehbe8b08d2021-10-29 16:31:24 -0700187 new_errno_error(Errno::EIO)
Victor Hsiehb0f5fc82021-10-15 17:24:19 -0700188 })?;
189 debug_assert!(s <= buf.len(), "Shouldn't return more bytes than asked");
190 buf.truncate(s);
191 Ok(buf)
192 }
193 }
194 FdConfig::ReadWrite(_file) => {
195 // There is no signature for a writable file.
Victor Hsiehbe8b08d2021-10-29 16:31:24 -0700196 Err(new_errno_error(Errno::ENOSYS))
Victor Hsiehb0f5fc82021-10-15 17:24:19 -0700197 }
Victor Hsieh559b9272021-11-08 15:15:14 -0800198 FdConfig::InputDir(_) | FdConfig::OutputDir(_) => Err(new_errno_error(Errno::EISDIR)),
Victor Hsiehc85e4ef2021-10-18 15:28:53 -0700199 })
Victor Hsiehb0f5fc82021-10-15 17:24:19 -0700200 }
201
202 fn writeFile(&self, id: i32, buf: &[u8], offset: i64) -> BinderResult<i32> {
Victor Hsiehc85e4ef2021-10-18 15:28:53 -0700203 self.handle_fd(id, |config| match config {
Victor Hsiehb0f5fc82021-10-15 17:24:19 -0700204 FdConfig::Readonly { .. } => Err(StatusCode::INVALID_OPERATION.into()),
205 FdConfig::ReadWrite(file) => {
Victor Hsiehbe8b08d2021-10-29 16:31:24 -0700206 let offset: u64 = offset.try_into().map_err(|_| new_errno_error(Errno::EINVAL))?;
Victor Hsiehb0f5fc82021-10-15 17:24:19 -0700207 // Check buffer size just to make `as i32` safe below.
208 if buf.len() > i32::MAX as usize {
Victor Hsiehbe8b08d2021-10-29 16:31:24 -0700209 return Err(new_errno_error(Errno::EOVERFLOW));
Victor Hsiehb0f5fc82021-10-15 17:24:19 -0700210 }
211 Ok(file.write_at(buf, offset).map_err(|e| {
212 error!("writeFile: write error: {}", e);
Victor Hsiehbe8b08d2021-10-29 16:31:24 -0700213 new_errno_error(Errno::EIO)
Victor Hsiehb0f5fc82021-10-15 17:24:19 -0700214 })? as i32)
215 }
Victor Hsieh559b9272021-11-08 15:15:14 -0800216 FdConfig::InputDir(_) | FdConfig::OutputDir(_) => Err(new_errno_error(Errno::EISDIR)),
Victor Hsiehc85e4ef2021-10-18 15:28:53 -0700217 })
Victor Hsiehb0f5fc82021-10-15 17:24:19 -0700218 }
219
220 fn resize(&self, id: i32, size: i64) -> BinderResult<()> {
Victor Hsiehc85e4ef2021-10-18 15:28:53 -0700221 self.handle_fd(id, |config| match config {
Victor Hsiehb0f5fc82021-10-15 17:24:19 -0700222 FdConfig::Readonly { .. } => Err(StatusCode::INVALID_OPERATION.into()),
223 FdConfig::ReadWrite(file) => {
224 if size < 0 {
Victor Hsiehbe8b08d2021-10-29 16:31:24 -0700225 return Err(new_errno_error(Errno::EINVAL));
Victor Hsiehb0f5fc82021-10-15 17:24:19 -0700226 }
227 file.set_len(size as u64).map_err(|e| {
228 error!("resize: set_len error: {}", e);
Victor Hsiehbe8b08d2021-10-29 16:31:24 -0700229 new_errno_error(Errno::EIO)
Victor Hsiehb0f5fc82021-10-15 17:24:19 -0700230 })
231 }
Victor Hsieh559b9272021-11-08 15:15:14 -0800232 FdConfig::InputDir(_) | FdConfig::OutputDir(_) => Err(new_errno_error(Errno::EISDIR)),
Victor Hsiehc85e4ef2021-10-18 15:28:53 -0700233 })
Victor Hsiehb0f5fc82021-10-15 17:24:19 -0700234 }
235
236 fn getFileSize(&self, id: i32) -> BinderResult<i64> {
Victor Hsiehc85e4ef2021-10-18 15:28:53 -0700237 self.handle_fd(id, |config| match config {
Victor Hsiehb0f5fc82021-10-15 17:24:19 -0700238 FdConfig::Readonly { file, .. } => {
239 let size = file
240 .metadata()
241 .map_err(|e| {
242 error!("getFileSize error: {}", e);
Victor Hsiehbe8b08d2021-10-29 16:31:24 -0700243 new_errno_error(Errno::EIO)
Victor Hsiehb0f5fc82021-10-15 17:24:19 -0700244 })?
245 .len();
246 Ok(size.try_into().map_err(|e| {
247 error!("getFileSize: File too large: {}", e);
Victor Hsiehbe8b08d2021-10-29 16:31:24 -0700248 new_errno_error(Errno::EFBIG)
Victor Hsiehb0f5fc82021-10-15 17:24:19 -0700249 })?)
250 }
251 FdConfig::ReadWrite(_file) => {
252 // Content and metadata of a writable file needs to be tracked by authfs, since
253 // fd_server isn't considered trusted. So there is no point to support getFileSize
254 // for a writable file.
Victor Hsiehbe8b08d2021-10-29 16:31:24 -0700255 Err(new_errno_error(Errno::ENOSYS))
Victor Hsiehb0f5fc82021-10-15 17:24:19 -0700256 }
Victor Hsieh559b9272021-11-08 15:15:14 -0800257 FdConfig::InputDir(_) | FdConfig::OutputDir(_) => Err(new_errno_error(Errno::EISDIR)),
258 })
259 }
260
Victor Hsiehdd99b462021-12-02 17:36:15 -0800261 fn openFileInDirectory(&self, dir_fd: i32, file_path: &str) -> BinderResult<i32> {
Victor Hsieh559b9272021-11-08 15:15:14 -0800262 let path_buf = PathBuf::from(file_path);
263 // Checks if the path is a simple, related path.
264 if path_buf.components().any(|c| !matches!(c, Component::Normal(_))) {
265 return Err(new_errno_error(Errno::EINVAL));
266 }
267
Victor Hsiehdd99b462021-12-02 17:36:15 -0800268 self.insert_new_fd(dir_fd, |config| match config {
Victor Hsieh559b9272021-11-08 15:15:14 -0800269 FdConfig::InputDir(dir) => {
270 let file = open_readonly_at(dir.as_raw_fd(), &path_buf).map_err(new_errno_error)?;
271
Inseob Kimc0886c22021-12-13 17:41:24 +0900272 let metadata_path_buf = get_fsverity_metadata_path(&path_buf);
273 let metadata = open_readonly_at(dir.as_raw_fd(), &metadata_path_buf)
274 .ok()
275 .and_then(|f| parse_fsverity_metadata(f).ok());
276
277 Ok((file.as_raw_fd(), FdConfig::Readonly { file, alt_metadata: metadata }))
Victor Hsieh559b9272021-11-08 15:15:14 -0800278 }
279 FdConfig::OutputDir(_) => {
280 Err(new_errno_error(Errno::ENOSYS)) // TODO: Implement when needed
281 }
282 _ => Err(new_errno_error(Errno::ENOTDIR)),
Victor Hsieh45636232021-10-15 17:52:51 -0700283 })
284 }
285
Victor Hsiehf393a722021-12-08 13:04:27 -0800286 fn createFileInDirectory(&self, dir_fd: i32, basename: &str, mode: i32) -> BinderResult<i32> {
Victor Hsiehdd99b462021-12-02 17:36:15 -0800287 validate_basename(basename)?;
288
289 self.insert_new_fd(dir_fd, |config| match config {
Victor Hsieh559b9272021-11-08 15:15:14 -0800290 FdConfig::InputDir(_) => Err(new_errno_error(Errno::EACCES)),
Victor Hsieh45636232021-10-15 17:52:51 -0700291 FdConfig::OutputDir(dir) => {
Victor Hsiehf393a722021-12-08 13:04:27 -0800292 let mode = validate_file_mode(mode)?;
Victor Hsieh45636232021-10-15 17:52:51 -0700293 let new_fd = openat(
294 dir.as_raw_fd(),
295 basename,
Victor Hsieh928d5032022-02-15 00:06:20 +0000296 // This function is supposed to be only called when FUSE/authfs thinks the file
297 // does not exist. However, if the file does exist from the view of fd_server
298 // (where the execution context is considered untrusted), we prefer to honor
299 // authfs and still allow the create to success. Therefore, always use O_TRUNC.
Victor Hsieh45636232021-10-15 17:52:51 -0700300 OFlag::O_CREAT | OFlag::O_RDWR | OFlag::O_TRUNC,
Victor Hsiehf393a722021-12-08 13:04:27 -0800301 mode,
Victor Hsieh45636232021-10-15 17:52:51 -0700302 )
303 .map_err(new_errno_error)?;
304 // SAFETY: new_fd is just created and not an error.
305 let new_file = unsafe { File::from_raw_fd(new_fd) };
306 Ok((new_fd, FdConfig::ReadWrite(new_file)))
307 }
308 _ => Err(new_errno_error(Errno::ENOTDIR)),
309 })
310 }
311
Victor Hsiehf393a722021-12-08 13:04:27 -0800312 fn createDirectoryInDirectory(
313 &self,
314 dir_fd: i32,
315 basename: &str,
316 mode: i32,
317 ) -> BinderResult<i32> {
Victor Hsiehdd99b462021-12-02 17:36:15 -0800318 validate_basename(basename)?;
319
Victor Hsieh45636232021-10-15 17:52:51 -0700320 self.insert_new_fd(dir_fd, |config| match config {
Victor Hsieh559b9272021-11-08 15:15:14 -0800321 FdConfig::InputDir(_) => Err(new_errno_error(Errno::EACCES)),
Victor Hsieh45636232021-10-15 17:52:51 -0700322 FdConfig::OutputDir(_) => {
Victor Hsiehf393a722021-12-08 13:04:27 -0800323 let mode = validate_file_mode(mode)?;
324 mkdirat(dir_fd, basename, mode).map_err(new_errno_error)?;
Victor Hsiehbf944d72022-03-07 23:46:43 +0000325 let new_dir_fd =
326 openat(dir_fd, basename, OFlag::O_DIRECTORY | OFlag::O_RDONLY, Mode::empty())
327 .map_err(new_errno_error)?;
328 // SAFETY: new_dir_fd is just created and not an error.
329 let fd_owner = unsafe { OwnedFd::from_raw_fd(new_dir_fd) };
330 Ok((new_dir_fd, FdConfig::OutputDir(fd_owner)))
Victor Hsieh45636232021-10-15 17:52:51 -0700331 }
332 _ => Err(new_errno_error(Errno::ENOTDIR)),
Victor Hsiehc85e4ef2021-10-18 15:28:53 -0700333 })
Victor Hsiehb0f5fc82021-10-15 17:24:19 -0700334 }
Victor Hsiehf7fc3d32021-11-22 10:20:33 -0800335
Victor Hsiehdd99b462021-12-02 17:36:15 -0800336 fn deleteFile(&self, dir_fd: i32, basename: &str) -> BinderResult<()> {
337 validate_basename(basename)?;
338
339 self.handle_fd(dir_fd, |config| match config {
Victor Hsiehbf944d72022-03-07 23:46:43 +0000340 FdConfig::OutputDir(_) => {
Victor Hsiehdd99b462021-12-02 17:36:15 -0800341 unlinkat(Some(dir_fd), basename, UnlinkatFlags::NoRemoveDir)
342 .map_err(new_errno_error)?;
343 Ok(())
344 }
345 FdConfig::InputDir(_) => Err(new_errno_error(Errno::EACCES)),
346 _ => Err(new_errno_error(Errno::ENOTDIR)),
347 })
348 }
349
350 fn deleteDirectory(&self, dir_fd: i32, basename: &str) -> BinderResult<()> {
351 validate_basename(basename)?;
352
353 self.handle_fd(dir_fd, |config| match config {
Victor Hsiehbf944d72022-03-07 23:46:43 +0000354 FdConfig::OutputDir(_) => {
Victor Hsiehdd99b462021-12-02 17:36:15 -0800355 unlinkat(Some(dir_fd), basename, UnlinkatFlags::RemoveDir)
356 .map_err(new_errno_error)?;
357 Ok(())
358 }
359 FdConfig::InputDir(_) => Err(new_errno_error(Errno::EACCES)),
360 _ => Err(new_errno_error(Errno::ENOTDIR)),
361 })
362 }
363
Victor Hsiehf393a722021-12-08 13:04:27 -0800364 fn chmod(&self, fd: i32, mode: i32) -> BinderResult<()> {
365 self.handle_fd(fd, |config| match config {
366 FdConfig::ReadWrite(_) | FdConfig::OutputDir(_) => {
367 let mode = validate_file_mode(mode)?;
368 fchmod(fd, mode).map_err(new_errno_error)
369 }
370 _ => Err(new_errno_error(Errno::EACCES)),
371 })
372 }
373
Victor Hsiehf7fc3d32021-11-22 10:20:33 -0800374 fn statfs(&self) -> BinderResult<FsStat> {
375 let st = statvfs("/data").map_err(new_errno_error)?;
376 try_into_fs_stat(st).map_err(|_e| new_errno_error(Errno::EINVAL))
377 }
378}
379
380fn try_into_fs_stat(st: Statvfs) -> Result<FsStat, std::num::TryFromIntError> {
381 Ok(FsStat {
382 blockSize: st.block_size().try_into()?,
383 fragmentSize: st.fragment_size().try_into()?,
384 blockNumbers: st.blocks().try_into()?,
385 blockAvailable: st.blocks_available().try_into()?,
386 inodesAvailable: st.files_available().try_into()?,
387 maxFilename: st.name_max().try_into()?,
388 })
Victor Hsiehb0f5fc82021-10-15 17:24:19 -0700389}
390
391fn read_into_buf(file: &File, max_size: usize, offset: u64) -> io::Result<Vec<u8>> {
392 let remaining = file.metadata()?.len().saturating_sub(offset);
393 let buf_size = min(remaining, max_size as u64) as usize;
394 let mut buf = vec![0; buf_size];
395 file.read_exact_at(&mut buf, offset)?;
396 Ok(buf)
397}
Victor Hsiehbe8b08d2021-10-29 16:31:24 -0700398
399fn new_errno_error(errno: Errno) -> Status {
Andrew Walbrandcf9d582022-08-03 11:25:24 +0000400 Status::new_service_specific_error_str(errno as i32, Some(errno.desc()))
Victor Hsiehbe8b08d2021-10-29 16:31:24 -0700401}
Victor Hsieh559b9272021-11-08 15:15:14 -0800402
403fn open_readonly_at(dir_fd: RawFd, path: &Path) -> nix::Result<File> {
404 let new_fd = openat(dir_fd, path, OFlag::O_RDONLY, Mode::empty())?;
405 // SAFETY: new_fd is just created successfully and not owned.
406 let new_file = unsafe { File::from_raw_fd(new_fd) };
407 Ok(new_file)
408}
Victor Hsiehdd99b462021-12-02 17:36:15 -0800409
Victor Hsiehf393a722021-12-08 13:04:27 -0800410fn validate_and_cast_offset(offset: i64) -> Result<u64, Status> {
411 offset.try_into().map_err(|_| new_errno_error(Errno::EINVAL))
412}
413
414fn validate_and_cast_size(size: i32) -> Result<usize, Status> {
415 if size > MAX_REQUESTING_DATA {
416 Err(new_errno_error(Errno::EFBIG))
417 } else {
418 size.try_into().map_err(|_| new_errno_error(Errno::EINVAL))
419 }
420}
421
Victor Hsiehdd99b462021-12-02 17:36:15 -0800422fn validate_basename(name: &str) -> BinderResult<()> {
423 if name.contains(MAIN_SEPARATOR) {
424 Err(new_errno_error(Errno::EINVAL))
425 } else {
426 Ok(())
427 }
428}
Victor Hsiehf393a722021-12-08 13:04:27 -0800429
430fn validate_file_mode(mode: i32) -> BinderResult<Mode> {
431 let mode = Mode::from_bits(mode as mode_t).ok_or_else(|| new_errno_error(Errno::EINVAL))?;
432 if mode.intersects(FORBIDDEN_MODES) {
433 Err(new_errno_error(Errno::EPERM))
434 } else {
435 Ok(mode)
436 }
437}