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

vfs/directory/mutable/
connection.rs
