vfs/directory/mutable/
connection.rs

1// Copyright 2019 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
5//! Connection to a directory that can be modified by the client though a FIDL connection.
6
7use crate::common::io1_to_io2_attrs;
8use crate::directory::connection::{BaseConnection, ConnectionState};
9use crate::directory::entry_container::MutableDirectory;
10use crate::execution_scope::ExecutionScope;
11use crate::name::validate_name;
12use crate::node::OpenNode;
13use crate::object_request::ConnectionCreator;
14use crate::path::Path;
15use crate::request_handler::{RequestHandler, RequestListener};
16use crate::token_registry::{TokenInterface, TokenRegistry, Tokenizable};
17use crate::{ObjectRequestRef, ProtocolsExt};
18
19use anyhow::Error;
20use fidl::NullableHandle;
21use fidl_fuchsia_io as fio;
22use std::ops::ControlFlow;
23use std::pin::Pin;
24use std::sync::Arc;
25use storage_trace::{self as trace, TraceFutureExt};
26use zx_status::Status;
27
28pub struct MutableConnection<DirectoryType: MutableDirectory> {
29    base: BaseConnection<DirectoryType>,
30}
31
32impl<DirectoryType: MutableDirectory> MutableConnection<DirectoryType> {
33    /// Creates a new connection to serve the mutable directory. The directory will be served from a
34    /// new async `Task`, not from the current `Task`. Errors in constructing the connection are not
35    /// guaranteed to be returned, they may be sent directly to the client end of the connection.
36    /// This method should be called from within an `ObjectRequest` handler to ensure that errors
37    /// are sent to the client end of the connection.
38    pub async fn create(
39        scope: ExecutionScope,
40        directory: Arc<DirectoryType>,
41        protocols: impl ProtocolsExt,
42        object_request: ObjectRequestRef<'_>,
43    ) -> Result<(), Status> {
44        // Ensure we close the directory if we fail to prepare the connection.
45        let directory = OpenNode::new(directory);
46
47        let connection = MutableConnection {
48            base: BaseConnection::new(scope.clone(), directory, protocols.to_directory_options()?),
49        };
50
51        if let Ok(requests) = object_request.take().into_request_stream(&connection.base).await {
52            scope.spawn(RequestListener::new(requests, Tokenizable::new(connection)));
53        }
54        Ok(())
55    }
56
57    async fn handle_request(
58        this: Pin<&mut Tokenizable<Self>>,
59        request: fio::DirectoryRequest,
60    ) -> Result<ConnectionState, Error> {
61        match request {
62            fio::DirectoryRequest::Unlink { name, options, responder } => {
63                async move {
64                    let result = this.handle_unlink(name, options).await;
65                    responder.send(result.map_err(Status::into_raw))
66                }
67                .trace(trace::trace_future_args!("storage", "Directory::Unlink"))
68                .await?;
69            }
70            fio::DirectoryRequest::GetToken { responder } => {
71                trace::duration!("storage", "Directory::GetToken");
72                let (status, token) = match Self::handle_get_token(this.into_ref()) {
73                    Ok(token) => (Status::OK, Some(token)),
74                    Err(status) => (status, None),
75                };
76                responder.send(status.into_raw(), token)?;
77            }
78            fio::DirectoryRequest::Rename { src, dst_parent_token, dst, responder } => {
79                async move {
80                    let result =
81                        this.handle_rename(src, NullableHandle::from(dst_parent_token), dst).await;
82                    responder.send(result.map_err(Status::into_raw))
83                }
84                .trace(trace::trace_future_args!("storage", "Directory::Rename"))
85                .await?;
86            }
87            #[cfg(fuchsia_api_level_at_least = "28")]
88            fio::DirectoryRequest::DeprecatedSetAttr { flags, attributes, responder } => {
89                let status = match this
90                    .handle_update_attributes(io1_to_io2_attrs(flags, attributes))
91                    .await
92                {
93                    Ok(()) => Status::OK,
94                    Err(status) => status,
95                };
96                responder.send(status.into_raw())?;
97            }
98            #[cfg(not(fuchsia_api_level_at_least = "28"))]
99            fio::DirectoryRequest::SetAttr { flags, attributes, responder } => {
100                let status = match this
101                    .handle_update_attributes(io1_to_io2_attrs(flags, attributes))
102                    .await
103                {
104                    Ok(()) => Status::OK,
105                    Err(status) => status,
106                };
107                responder.send(status.into_raw())?;
108            }
109            fio::DirectoryRequest::Sync { responder } => {
110                async move {
111                    responder.send(this.base.directory.sync().await.map_err(Status::into_raw))
112                }
113                .trace(trace::trace_future_args!("storage", "Directory::Sync"))
114                .await?;
115            }
116            fio::DirectoryRequest::CreateSymlink {
117                responder, name, target, connection, ..
118            } => {
119                async move {
120                    if !this.base.options.rights.contains(fio::Operations::MODIFY_DIRECTORY) {
121                        responder.send(Err(Status::ACCESS_DENIED.into_raw()))
122                    } else if validate_name(&name).is_err() {
123                        responder.send(Err(Status::INVALID_ARGS.into_raw()))
124                    } else {
125                        responder.send(
126                            this.base
127                                .directory
128                                .create_symlink(name, target, connection)
129                                .await
130                                .map_err(Status::into_raw),
131                        )
132                    }
133                }
134                .trace(trace::trace_future_args!("storage", "Directory::CreateSymlink"))
135                .await?;
136            }
137            fio::DirectoryRequest::UpdateAttributes { payload, responder } => {
138                async move {
139                    responder.send(
140                        this.handle_update_attributes(payload).await.map_err(Status::into_raw),
141                    )
142                }
143                .trace(trace::trace_future_args!("storage", "Directory::UpdateAttributes"))
144                .await?;
145            }
146            request => {
147                return this.as_mut().base.handle_request(request).await;
148            }
149        }
150        Ok(ConnectionState::Alive)
151    }
152
153    async fn handle_update_attributes(
154        &self,
155        attributes: fio::MutableNodeAttributes,
156    ) -> Result<(), Status> {
157        if !self.base.options.rights.contains(fio::Operations::UPDATE_ATTRIBUTES) {
158            return Err(Status::BAD_HANDLE);
159        }
160        // TODO(jfsulliv): Consider always permitting attributes to be deferrable. The risk with
161        // this is that filesystems would require a background flush of dirty attributes to disk.
162        self.base.directory.update_attributes(attributes).await
163    }
164
165    async fn handle_unlink(&self, name: String, options: fio::UnlinkOptions) -> Result<(), Status> {
166        if !self.base.options.rights.contains(fio::Rights::MODIFY_DIRECTORY) {
167            return Err(Status::BAD_HANDLE);
168        }
169
170        if name.is_empty() || name.contains('/') || name == "." || name == ".." {
171            return Err(Status::INVALID_ARGS);
172        }
173
174        self.base
175            .directory
176            .clone()
177            .unlink(
178                &name,
179                options
180                    .flags
181                    .map(|f| f.contains(fio::UnlinkFlags::MUST_BE_DIRECTORY))
182                    .unwrap_or(false),
183            )
184            .await
185    }
186
187    fn handle_get_token(this: Pin<&Tokenizable<Self>>) -> Result<NullableHandle, Status> {
188        // GetToken exists to support linking, so we must make sure the connection has the
189        // permission to modify the directory.
190        if !this.base.options.rights.contains(fio::Rights::MODIFY_DIRECTORY) {
191            return Err(Status::BAD_HANDLE);
192        }
193        Ok(TokenRegistry::get_token(this)?)
194    }
195
196    async fn handle_rename(
197        &self,
198        src: String,
199        dst_parent_token: NullableHandle,
200        dst: String,
201    ) -> Result<(), Status> {
202        if !self.base.options.rights.contains(fio::Rights::MODIFY_DIRECTORY) {
203            return Err(Status::BAD_HANDLE);
204        }
205
206        let src = Path::validate_and_split(src)?;
207        let dst = Path::validate_and_split(dst)?;
208
209        if !src.is_single_component() || !dst.is_single_component() {
210            return Err(Status::INVALID_ARGS);
211        }
212
213        let dst_parent = match self.base.scope.token_registry().get_owner(dst_parent_token)? {
214            None => return Err(Status::NOT_FOUND),
215            Some(entry) => entry,
216        };
217
218        dst_parent.clone().rename(self.base.directory.clone(), src, dst).await
219    }
220}
221
222impl<DirectoryType: MutableDirectory> ConnectionCreator<DirectoryType>
223    for MutableConnection<DirectoryType>
224{
225    async fn create<'a>(
226        scope: ExecutionScope,
227        node: Arc<DirectoryType>,
228        protocols: impl ProtocolsExt,
229        object_request: ObjectRequestRef<'a>,
230    ) -> Result<(), Status> {
231        Self::create(scope, node, protocols, object_request).await
232    }
233}
234
235impl<DirectoryType: MutableDirectory> RequestHandler
236    for Tokenizable<MutableConnection<DirectoryType>>
237{
238    type Request = Result<fio::DirectoryRequest, fidl::Error>;
239
240    async fn handle_request(self: Pin<&mut Self>, request: Self::Request) -> ControlFlow<()> {
241        if let Some(_guard) = self.base.scope.try_active_guard() {
242            match request {
243                Ok(request) => {
244                    match MutableConnection::<DirectoryType>::handle_request(self, request).await {
245                        Ok(ConnectionState::Alive) => ControlFlow::Continue(()),
246                        Ok(ConnectionState::Closed) | Err(_) => ControlFlow::Break(()),
247                    }
248                }
249                Err(_) => ControlFlow::Break(()),
250            }
251        } else {
252            ControlFlow::Break(())
253        }
254    }
255}
256
257impl<DirectoryType: MutableDirectory> TokenInterface for MutableConnection<DirectoryType> {
258    fn get_node(&self) -> Arc<dyn MutableDirectory> {
259        self.base.directory.clone()
260    }
261
262    fn token_registry(&self) -> &TokenRegistry {
263        self.base.scope.token_registry()
264    }
265}
266
267#[cfg(test)]
268mod tests {
269    use super::*;
270    use crate::ToObjectRequest;
271    use crate::directory::dirents_sink;
272    use crate::directory::entry::{EntryInfo, GetEntryInfo};
273    use crate::directory::entry_container::{Directory, DirectoryWatcher};
274    use crate::directory::traversal_position::TraversalPosition;
275    use crate::node::Node;
276    use fuchsia_sync::Mutex;
277    use futures::future::BoxFuture;
278    use std::any::Any;
279    use std::future::ready;
280    use std::sync::Weak;
281
282    #[derive(Debug, PartialEq)]
283    enum MutableDirectoryAction {
284        Link { id: u32, path: String },
285        Unlink { id: u32, name: String },
286        Rename { id: u32, src_name: String, dst_dir: u32, dst_name: String },
287        UpdateAttributes { id: u32, attributes: fio::MutableNodeAttributes },
288        Sync,
289        Close,
290    }
291
292    #[derive(Debug)]
293    struct MockDirectory {
294        id: u32,
295        fs: Arc<MockFilesystem>,
296    }
297
298    impl MockDirectory {
299        pub fn new(id: u32, fs: Arc<MockFilesystem>) -> Arc<Self> {
300            Arc::new(MockDirectory { id, fs })
301        }
302    }
303
304    impl PartialEq for MockDirectory {
305        fn eq(&self, other: &Self) -> bool {
306            self.id == other.id
307        }
308    }
309
310    impl GetEntryInfo for MockDirectory {
311        fn entry_info(&self) -> EntryInfo {
312            EntryInfo::new(0, fio::DirentType::Directory)
313        }
314    }
315
316    impl Node for MockDirectory {
317        async fn get_attributes(
318            &self,
319            _query: fio::NodeAttributesQuery,
320        ) -> Result<fio::NodeAttributes2, Status> {
321            unimplemented!("Not implemented");
322        }
323
324        fn close(self: Arc<Self>) {
325            let _ = self.fs.handle_event(MutableDirectoryAction::Close);
326        }
327    }
328
329    impl Directory for MockDirectory {
330        fn open(
331            self: Arc<Self>,
332            _scope: ExecutionScope,
333            _path: Path,
334            _flags: fio::Flags,
335            _object_request: ObjectRequestRef<'_>,
336        ) -> Result<(), Status> {
337            unimplemented!("Not implemented!");
338        }
339
340        async fn read_dirents(
341            &self,
342            _pos: &TraversalPosition,
343            _sink: Box<dyn dirents_sink::Sink>,
344        ) -> Result<(TraversalPosition, Box<dyn dirents_sink::Sealed>), Status> {
345            unimplemented!("Not implemented");
346        }
347
348        fn register_watcher(
349            self: Arc<Self>,
350            _scope: ExecutionScope,
351            _mask: fio::WatchMask,
352            _watcher: DirectoryWatcher,
353        ) -> Result<(), Status> {
354            unimplemented!("Not implemented");
355        }
356
357        fn unregister_watcher(self: Arc<Self>, _key: usize) {
358            unimplemented!("Not implemented");
359        }
360    }
361
362    impl MutableDirectory for MockDirectory {
363        fn link<'a>(
364            self: Arc<Self>,
365            path: String,
366            _source_dir: Arc<dyn Any + Send + Sync>,
367            _source_name: &'a str,
368        ) -> BoxFuture<'a, Result<(), Status>> {
369            let result = self.fs.handle_event(MutableDirectoryAction::Link { id: self.id, path });
370            Box::pin(ready(result))
371        }
372
373        async fn unlink(
374            self: Arc<Self>,
375            name: &str,
376            _must_be_directory: bool,
377        ) -> Result<(), Status> {
378            self.fs.handle_event(MutableDirectoryAction::Unlink {
379                id: self.id,
380                name: name.to_string(),
381            })
382        }
383
384        async fn update_attributes(
385            &self,
386            attributes: fio::MutableNodeAttributes,
387        ) -> Result<(), Status> {
388            self.fs
389                .handle_event(MutableDirectoryAction::UpdateAttributes { id: self.id, attributes })
390        }
391
392        async fn sync(&self) -> Result<(), Status> {
393            self.fs.handle_event(MutableDirectoryAction::Sync)
394        }
395
396        fn rename(
397            self: Arc<Self>,
398            src_dir: Arc<dyn MutableDirectory>,
399            src_name: Path,
400            dst_name: Path,
401        ) -> BoxFuture<'static, Result<(), Status>> {
402            let src_dir = src_dir.into_any().downcast::<MockDirectory>().unwrap();
403            let result = self.fs.handle_event(MutableDirectoryAction::Rename {
404                id: src_dir.id,
405                src_name: src_name.into_string(),
406                dst_dir: self.id,
407                dst_name: dst_name.into_string(),
408            });
409            Box::pin(ready(result))
410        }
411    }
412
413    struct Events(Mutex<Vec<MutableDirectoryAction>>);
414
415    impl Events {
416        fn new() -> Arc<Self> {
417            Arc::new(Events(Mutex::new(vec![])))
418        }
419    }
420
421    struct MockFilesystem {
422        cur_id: Mutex<u32>,
423        scope: ExecutionScope,
424        events: Weak<Events>,
425    }
426
427    impl MockFilesystem {
428        pub fn new(events: &Arc<Events>) -> Self {
429            let scope = ExecutionScope::new();
430            MockFilesystem { cur_id: Mutex::new(0), scope, events: Arc::downgrade(events) }
431        }
432
433        pub fn handle_event(&self, event: MutableDirectoryAction) -> Result<(), Status> {
434            self.events.upgrade().map(|x| x.0.lock().push(event));
435            Ok(())
436        }
437
438        pub fn make_connection(
439            self: &Arc<Self>,
440            flags: fio::Flags,
441        ) -> (Arc<MockDirectory>, fio::DirectoryProxy) {
442            let mut cur_id = self.cur_id.lock();
443            let dir = MockDirectory::new(*cur_id, self.clone());
444            *cur_id += 1;
445            let (proxy, server_end) = fidl::endpoints::create_proxy::<fio::DirectoryMarker>();
446            flags.to_object_request(server_end).create_connection_sync::<MutableConnection<_>, _>(
447                self.scope.clone(),
448                dir.clone(),
449                flags,
450            );
451            (dir, proxy)
452        }
453    }
454
455    impl std::fmt::Debug for MockFilesystem {
456        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
457            f.debug_struct("MockFilesystem").field("cur_id", &self.cur_id).finish()
458        }
459    }
460
461    #[fuchsia::test]
462    async fn test_rename() {
463        use fidl::Event;
464
465        let events = Events::new();
466        let fs = Arc::new(MockFilesystem::new(&events));
467
468        let (_dir, proxy) = fs.clone().make_connection(fio::PERM_READABLE | fio::PERM_WRITABLE);
469        let (dir2, proxy2) = fs.clone().make_connection(fio::PERM_READABLE | fio::PERM_WRITABLE);
470
471        let (status, token) = proxy2.get_token().await.unwrap();
472        assert_eq!(Status::from_raw(status), Status::OK);
473
474        let status = proxy.rename("src", Event::from(token.unwrap()), "dest").await.unwrap();
475        assert!(status.is_ok());
476
477        let events = events.0.lock();
478        assert_eq!(
479            *events,
480            vec![MutableDirectoryAction::Rename {
481                id: 0,
482                src_name: "src".to_owned(),
483                dst_dir: dir2.id,
484                dst_name: "dest".to_owned(),
485            },]
486        );
487    }
488
489    #[fuchsia::test]
490    async fn test_update_attributes() {
491        let events = Events::new();
492        let fs = Arc::new(MockFilesystem::new(&events));
493        let (_dir, proxy) = fs.clone().make_connection(fio::PERM_READABLE | fio::PERM_WRITABLE);
494        let attributes = fio::MutableNodeAttributes {
495            creation_time: Some(30),
496            modification_time: Some(100),
497            mode: Some(200),
498            ..Default::default()
499        };
500        proxy
501            .update_attributes(&attributes)
502            .await
503            .expect("FIDL call failed")
504            .map_err(Status::from_raw)
505            .expect("update attributes failed");
506
507        let events = events.0.lock();
508        assert_eq!(*events, vec![MutableDirectoryAction::UpdateAttributes { id: 0, attributes }]);
509    }
510
511    #[fuchsia::test]
512    async fn test_link() {
513        let events = Events::new();
514        let fs = Arc::new(MockFilesystem::new(&events));
515        let (_dir, proxy) = fs.clone().make_connection(fio::PERM_READABLE | fio::PERM_WRITABLE);
516        let (_dir2, proxy2) = fs.clone().make_connection(fio::PERM_READABLE | fio::PERM_WRITABLE);
517
518        let (status, token) = proxy2.get_token().await.unwrap();
519        assert_eq!(Status::from_raw(status), Status::OK);
520
521        let status = proxy.link("src", token.unwrap(), "dest").await.unwrap();
522        assert_eq!(Status::from_raw(status), Status::OK);
523        let events = events.0.lock();
524        assert_eq!(*events, vec![MutableDirectoryAction::Link { id: 1, path: "dest".to_owned() },]);
525    }
526
527    #[fuchsia::test]
528    async fn test_unlink() {
529        let events = Events::new();
530        let fs = Arc::new(MockFilesystem::new(&events));
531        let (_dir, proxy) = fs.clone().make_connection(fio::PERM_READABLE | fio::PERM_WRITABLE);
532        proxy
533            .unlink("test", &fio::UnlinkOptions::default())
534            .await
535            .expect("fidl call failed")
536            .expect("unlink failed");
537        let events = events.0.lock();
538        assert_eq!(
539            *events,
540            vec![MutableDirectoryAction::Unlink { id: 0, name: "test".to_string() },]
541        );
542    }
543
544    #[fuchsia::test]
545    async fn test_sync() {
546        let events = Events::new();
547        let fs = Arc::new(MockFilesystem::new(&events));
548        let (_dir, proxy) = fs.clone().make_connection(fio::PERM_READABLE | fio::PERM_WRITABLE);
549        let () = proxy.sync().await.unwrap().map_err(Status::from_raw).unwrap();
550        let events = events.0.lock();
551        assert_eq!(*events, vec![MutableDirectoryAction::Sync]);
552    }
553
554    #[fuchsia::test]
555    async fn test_close() {
556        let events = Events::new();
557        let fs = Arc::new(MockFilesystem::new(&events));
558        let (_dir, proxy) = fs.clone().make_connection(fio::PERM_READABLE | fio::PERM_WRITABLE);
559        let () = proxy.close().await.unwrap().map_err(Status::from_raw).unwrap();
560        let events = events.0.lock();
561        assert_eq!(*events, vec![MutableDirectoryAction::Close]);
562    }
563
564    #[fuchsia::test]
565    async fn test_implicit_close() {
566        let events = Events::new();
567        let fs = Arc::new(MockFilesystem::new(&events));
568        let (_dir, _proxy) = fs.clone().make_connection(fio::PERM_READABLE | fio::PERM_WRITABLE);
569
570        fs.scope.shutdown();
571        fs.scope.wait().await;
572
573        let events = events.0.lock();
574        assert_eq!(*events, vec![MutableDirectoryAction::Close]);
575    }
576}
vfs/directory/mutable/connection.rs

vfs/directory/mutable/
connection.rs
