package_directory/
non_meta_subdir.rs

1// Copyright 2021 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5use crate::root_dir::RootDir;
6use anyhow::anyhow;
7use fidl::endpoints::ServerEnd;
8use fidl_fuchsia_io as fio;
9use log::error;
10use std::sync::Arc;
11use vfs::common::send_on_open_with_error;
12use vfs::directory::entry::EntryInfo;
13use vfs::directory::immutable::connection::ImmutableConnection;
14use vfs::directory::traversal_position::TraversalPosition;
15use vfs::execution_scope::ExecutionScope;
16use vfs::{immutable_attributes, ObjectRequestRef, ToObjectRequest as _};
17
18pub(crate) struct NonMetaSubdir<S: crate::NonMetaStorage> {
19    root_dir: Arc<RootDir<S>>,
20    // The object relative path expression of the subdir relative to the package root with a
21    // trailing slash appended.
22    path: String,
23}
24
25impl<S: crate::NonMetaStorage> NonMetaSubdir<S> {
26    pub(crate) fn new(root_dir: Arc<RootDir<S>>, path: String) -> Arc<Self> {
27        Arc::new(NonMetaSubdir { root_dir, path })
28    }
29}
30
31impl<S: crate::NonMetaStorage> vfs::directory::entry::GetEntryInfo for NonMetaSubdir<S> {
32    fn entry_info(&self) -> EntryInfo {
33        EntryInfo::new(fio::INO_UNKNOWN, fio::DirentType::Directory)
34    }
35}
36
37impl<S: crate::NonMetaStorage> vfs::node::Node for NonMetaSubdir<S> {
38    async fn get_attributes(
39        &self,
40        requested_attributes: fio::NodeAttributesQuery,
41    ) -> Result<fio::NodeAttributes2, zx::Status> {
42        Ok(immutable_attributes!(
43            requested_attributes,
44            Immutable {
45                protocols: fio::NodeProtocolKinds::DIRECTORY,
46                abilities: crate::DIRECTORY_ABILITIES,
47                id: 1,
48            }
49        ))
50    }
51}
52
53impl<S: crate::NonMetaStorage> vfs::directory::entry_container::Directory for NonMetaSubdir<S> {
54    fn open(
55        self: Arc<Self>,
56        scope: ExecutionScope,
57        flags: fio::OpenFlags,
58        path: vfs::Path,
59        server_end: ServerEnd<fio::NodeMarker>,
60    ) {
61        let flags = flags & !fio::OpenFlags::POSIX_WRITABLE;
62        let describe = flags.contains(fio::OpenFlags::DESCRIBE);
63        // Disallow creating a writable connection to this node or any children. We also disallow
64        // file flags which do not apply. Note that the latter is not required for Open3, as we
65        // require writable rights for the latter flags already.
66        if flags.intersects(fio::OpenFlags::RIGHT_WRITABLE | fio::OpenFlags::TRUNCATE) {
67            let () = send_on_open_with_error(describe, server_end, zx::Status::NOT_SUPPORTED);
68            return;
69        }
70        // The VFS should disallow file creation since we cannot serve a mutable connection.
71        assert!(!flags.intersects(fio::OpenFlags::CREATE | fio::OpenFlags::CREATE_IF_ABSENT));
72
73        // Handle case where the request is for this directory itself (e.g. ".").
74        if path.is_empty() {
75            flags.to_object_request(server_end).handle(|object_request| {
76                // NOTE: Some older CTF tests still rely on being able to use the APPEND flag in
77                // some cases, so we cannot check this flag above. Appending is still not possible.
78                // As we plan to remove this method entirely, we can just leave this for now.
79                if flags.intersects(fio::OpenFlags::APPEND) {
80                    return Err(zx::Status::NOT_SUPPORTED);
81                }
82
83                object_request
84                    .take()
85                    .create_connection_sync::<ImmutableConnection<_>, _>(scope, self, flags);
86                Ok(())
87            });
88            return;
89        }
90
91        // `path` is relative, and may include a trailing slash.
92        let file_path = format!(
93            "{}{}",
94            self.path,
95            path.as_ref().strip_suffix('/').unwrap_or_else(|| path.as_ref())
96        );
97
98        if let Some(blob) = self.root_dir.non_meta_files.get(&file_path) {
99            let () =
100                self.root_dir.non_meta_storage.open(blob, flags, scope, server_end).unwrap_or_else(
101                    |e| error!("Error forwarding content blob open to blobfs: {:#}", anyhow!(e)),
102                );
103            return;
104        }
105
106        if let Some(subdir) = self.root_dir.get_non_meta_subdir(file_path + "/") {
107            let () = subdir.open(scope, flags, vfs::Path::dot(), server_end);
108            return;
109        }
110
111        let () = send_on_open_with_error(describe, server_end, zx::Status::NOT_FOUND);
112    }
113
114    fn open3(
115        self: Arc<Self>,
116        scope: ExecutionScope,
117        path: vfs::Path,
118        flags: fio::Flags,
119        object_request: ObjectRequestRef<'_>,
120    ) -> Result<(), zx::Status> {
121        if !flags.difference(crate::ALLOWED_FLAGS).is_empty() {
122            return Err(zx::Status::NOT_SUPPORTED);
123        }
124
125        // Handle case where the request is for this directory itself (e.g. ".").
126        if path.is_empty() {
127            // `ImmutableConnection` checks that only directory flags are specified.
128            object_request
129                .take()
130                .create_connection_sync::<ImmutableConnection<_>, _>(scope, self, flags);
131            return Ok(());
132        }
133
134        // `path` is relative, and may include a trailing slash.
135        let file_path = format!(
136            "{}{}",
137            self.path,
138            path.as_ref().strip_suffix('/').unwrap_or_else(|| path.as_ref())
139        );
140
141        if let Some(blob) = self.root_dir.non_meta_files.get(&file_path) {
142            if path.is_dir() {
143                return Err(zx::Status::NOT_DIR);
144            }
145            return self.root_dir.non_meta_storage.open3(blob, flags, scope, object_request);
146        }
147
148        if let Some(subdir) = self.root_dir.get_non_meta_subdir(file_path + "/") {
149            return subdir.open3(scope, vfs::Path::dot(), flags, object_request);
150        }
151
152        Err(zx::Status::NOT_FOUND)
153    }
154
155    async fn read_dirents<'a>(
156        &'a self,
157        pos: &'a TraversalPosition,
158        sink: Box<(dyn vfs::directory::dirents_sink::Sink + 'static)>,
159    ) -> Result<
160        (TraversalPosition, Box<(dyn vfs::directory::dirents_sink::Sealed + 'static)>),
161        zx::Status,
162    > {
163        vfs::directory::read_dirents::read_dirents(
164            &crate::get_dir_children(
165                self.root_dir.non_meta_files.keys().map(|s| s.as_str()),
166                &self.path,
167            ),
168            pos,
169            sink,
170        )
171        .await
172    }
173
174    fn register_watcher(
175        self: Arc<Self>,
176        _: ExecutionScope,
177        _: fio::WatchMask,
178        _: vfs::directory::entry_container::DirectoryWatcher,
179    ) -> Result<(), zx::Status> {
180        Err(zx::Status::NOT_SUPPORTED)
181    }
182
183    // `register_watcher` is unsupported so no need to do anything here.
184    fn unregister_watcher(self: Arc<Self>, _: usize) {}
185}
186
187#[cfg(test)]
188mod tests {
189    use super::*;
190    use assert_matches::assert_matches;
191    use fuchsia_fs::directory::{DirEntry, DirentKind};
192    use fuchsia_pkg_testing::blobfs::Fake as FakeBlobfs;
193    use fuchsia_pkg_testing::PackageBuilder;
194    use futures::prelude::*;
195    use vfs::directory::entry_container::Directory as _;
196
197    struct TestEnv {
198        _blobfs_fake: FakeBlobfs,
199    }
200
201    impl TestEnv {
202        async fn new() -> (Self, fio::DirectoryProxy) {
203            let pkg = PackageBuilder::new("pkg")
204                .add_resource_at("dir0/dir1/file", "bloblob".as_bytes())
205                .build()
206                .await
207                .unwrap();
208            let (metafar_blob, content_blobs) = pkg.contents();
209            let (blobfs_fake, blobfs_client) = FakeBlobfs::new();
210            blobfs_fake.add_blob(metafar_blob.merkle, metafar_blob.contents);
211            for (hash, bytes) in content_blobs {
212                blobfs_fake.add_blob(hash, bytes);
213            }
214            let root_dir = RootDir::new(blobfs_client, metafar_blob.merkle).await.unwrap();
215            let sub_dir = NonMetaSubdir::new(root_dir, "dir0/".to_string());
216            (Self { _blobfs_fake: blobfs_fake }, vfs::directory::serve_read_only(sub_dir))
217        }
218    }
219
220    /// Ensure connections to a [`NonMetaSubdir`] cannot be created as mutable (i.e. with
221    /// [`fio::PERM_WRITABLE`]) This ensures that the VFS will disallow any attempts to create a new
222    /// file/directory, modify the attributes of any nodes, or open any files as writable.
223    #[fuchsia_async::run_singlethreaded(test)]
224    async fn non_meta_subdir_cannot_be_served_as_mutable() {
225        let pkg = PackageBuilder::new("pkg")
226            .add_resource_at("dir0/dir1/file", "bloblob".as_bytes())
227            .build()
228            .await
229            .unwrap();
230        let (metafar_blob, content_blobs) = pkg.contents();
231        let (blobfs_fake, blobfs_client) = FakeBlobfs::new();
232        blobfs_fake.add_blob(metafar_blob.merkle, metafar_blob.contents);
233        for (hash, bytes) in content_blobs {
234            blobfs_fake.add_blob(hash, bytes);
235        }
236        let root_dir = RootDir::new(blobfs_client, metafar_blob.merkle).await.unwrap();
237        let sub_dir = NonMetaSubdir::new(root_dir, "dir0/".to_string());
238        let (proxy, server) = fidl::endpoints::create_proxy::<fio::DirectoryMarker>();
239        let request = fio::PERM_WRITABLE.to_object_request(server);
240        request.handle(|request: &mut vfs::ObjectRequest| {
241            sub_dir.open3(ExecutionScope::new(), vfs::Path::dot(), fio::PERM_WRITABLE, request)
242        });
243        assert_matches!(
244            proxy.take_event_stream().try_next().await,
245            Err(fidl::Error::ClientChannelClosed { status: zx::Status::NOT_SUPPORTED, .. })
246        );
247    }
248
249    #[fuchsia_async::run_singlethreaded(test)]
250    async fn non_meta_subdir_readdir() {
251        let (_env, sub_dir) = TestEnv::new().await;
252        assert_eq!(
253            fuchsia_fs::directory::readdir_inclusive(&sub_dir).await.unwrap(),
254            vec![
255                DirEntry { name: ".".to_string(), kind: DirentKind::Directory },
256                DirEntry { name: "dir1".to_string(), kind: DirentKind::Directory }
257            ]
258        );
259    }
260
261    #[fuchsia_async::run_singlethreaded(test)]
262    async fn non_meta_subdir_get_attributes() {
263        let (_env, sub_dir) = TestEnv::new().await;
264        let (mutable_attributes, immutable_attributes) =
265            sub_dir.get_attributes(fio::NodeAttributesQuery::all()).await.unwrap().unwrap();
266        assert_eq!(
267            fio::NodeAttributes2 { mutable_attributes, immutable_attributes },
268            immutable_attributes!(
269                fio::NodeAttributesQuery::all(),
270                Immutable {
271                    protocols: fio::NodeProtocolKinds::DIRECTORY,
272                    abilities: crate::DIRECTORY_ABILITIES,
273                    id: 1,
274                }
275            )
276        );
277    }
278
279    #[fuchsia_async::run_singlethreaded(test)]
280    async fn non_meta_subdir_watch_not_supported() {
281        let (_env, sub_dir) = TestEnv::new().await;
282        let (_client, server) = fidl::endpoints::create_endpoints();
283        let status =
284            zx::Status::from_raw(sub_dir.watch(fio::WatchMask::empty(), 0, server).await.unwrap());
285        assert_eq!(status, zx::Status::NOT_SUPPORTED);
286    }
287
288    #[fuchsia_async::run_singlethreaded(test)]
289    async fn non_meta_subdir_open_directory() {
290        let (_env, sub_dir) = TestEnv::new().await;
291        for path in ["dir1", "dir1/"] {
292            let proxy = fuchsia_fs::directory::open_directory(&sub_dir, path, fio::PERM_READABLE)
293                .await
294                .unwrap();
295            assert_eq!(
296                fuchsia_fs::directory::readdir(&proxy).await.unwrap(),
297                vec![DirEntry { name: "file".to_string(), kind: DirentKind::File }]
298            );
299        }
300    }
301
302    #[fuchsia_async::run_singlethreaded(test)]
303    async fn non_meta_subdir_open_file() {
304        let (_env, sub_dir) = TestEnv::new().await;
305        let proxy = fuchsia_fs::directory::open_file(&sub_dir, "dir1/file", fio::PERM_READABLE)
306            .await
307            .unwrap();
308        assert_eq!(fuchsia_fs::file::read(&proxy).await.unwrap(), b"bloblob".to_vec())
309    }
310
311    #[fuchsia_async::run_singlethreaded(test)]
312    async fn non_meta_subdir_deprecated_open_directory() {
313        let (_env, sub_dir) = TestEnv::new().await;
314        for path in ["dir1", "dir1/"] {
315            let (proxy, server_end) = fidl::endpoints::create_proxy::<fio::DirectoryMarker>();
316            sub_dir
317                .deprecated_open(
318                    fio::OpenFlags::RIGHT_READABLE,
319                    Default::default(),
320                    path,
321                    server_end.into_channel().into(),
322                )
323                .unwrap();
324            assert_eq!(
325                fuchsia_fs::directory::readdir(&proxy).await.unwrap(),
326                vec![DirEntry { name: "file".to_string(), kind: DirentKind::File }]
327            );
328        }
329    }
330
331    #[fuchsia_async::run_singlethreaded(test)]
332    async fn non_meta_subdir_deprecated_open_file() {
333        let (_env, sub_dir) = TestEnv::new().await;
334        let (proxy, server_end) = fidl::endpoints::create_proxy::<fio::FileMarker>();
335        sub_dir
336            .deprecated_open(
337                fio::OpenFlags::RIGHT_READABLE,
338                Default::default(),
339                "dir1/file",
340                server_end.into_channel().into(),
341            )
342            .unwrap();
343        assert_eq!(fuchsia_fs::file::read(&proxy).await.unwrap(), b"bloblob".to_vec());
344    }
345}
package_directory/non_meta_subdir.rs

package_directory/
non_meta_subdir.rs
