netcfg/
devices.rs

1// Copyright 2020 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 std::fmt::Display;
6
7use {fidl_fuchsia_device as fdev, fidl_fuchsia_hardware_network as fhwnet};
8
9use anyhow::Context as _;
10
11use crate::errors::{self, ContextExt as _};
12use crate::exit_with_fidl_error;
13
14/// An error when adding a device.
15pub(super) enum AddDeviceError {
16    AlreadyExists(String),
17    Other(errors::Error),
18}
19
20impl From<errors::Error> for AddDeviceError {
21    fn from(e: errors::Error) -> AddDeviceError {
22        AddDeviceError::Other(e)
23    }
24}
25
26impl errors::ContextExt for AddDeviceError {
27    fn context<C>(self, context: C) -> AddDeviceError
28    where
29        C: Display + Send + Sync + 'static,
30    {
31        match self {
32            AddDeviceError::AlreadyExists(name) => AddDeviceError::AlreadyExists(name),
33            AddDeviceError::Other(e) => AddDeviceError::Other(e.context(context)),
34        }
35    }
36
37    fn with_context<C, F>(self, f: F) -> AddDeviceError
38    where
39        C: Display + Send + Sync + 'static,
40        F: FnOnce() -> C,
41    {
42        match self {
43            AddDeviceError::AlreadyExists(name) => AddDeviceError::AlreadyExists(name),
44            AddDeviceError::Other(e) => AddDeviceError::Other(e.with_context(f)),
45        }
46    }
47}
48
49// Cannot be completely replaced by `DeviceInfoRef` due to `get_device_info`
50// not being able to return a struct of references.
51#[derive(Debug, Clone)]
52pub(super) struct DeviceInfo {
53    pub(super) port_class: fhwnet::PortClass,
54    pub(super) mac: Option<fidl_fuchsia_net_ext::MacAddress>,
55    pub(super) topological_path: String,
56}
57
58/// An instance of a network device.
59pub(super) struct NetworkDeviceInstance {
60    port: fhwnet::PortProxy,
61    port_id: fhwnet::PortId,
62    device_control: fidl_fuchsia_net_interfaces_admin::DeviceControlProxy,
63    topological_path: String,
64}
65
66impl std::fmt::Debug for NetworkDeviceInstance {
67    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
68        let NetworkDeviceInstance { port: _, port_id, device_control: _, topological_path } = self;
69        write!(
70            f,
71            "NetworkDeviceInstance{{topological_path={}, port={:?}}}",
72            topological_path, port_id
73        )
74    }
75}
76
77impl NetworkDeviceInstance {
78    pub const PATH: &'static str = "/dev/class/network";
79
80    pub async fn get_instance_stream(
81        installer: &fidl_fuchsia_net_interfaces_admin::InstallerProxy,
82        path: &std::path::PathBuf,
83    ) -> Result<impl futures::Stream<Item = Result<Self, errors::Error>>, errors::Error> {
84        let (topological_path, _file_path, device_instance) =
85            get_topo_path_and_device::<fhwnet::DeviceInstanceMarker>(path)
86                .await
87                .with_context(|| format!("open netdevice at {:?}", path))?;
88
89        let get_device = || {
90            let (device, device_server_end) =
91                fidl::endpoints::create_endpoints::<fhwnet::DeviceMarker>();
92            device_instance
93                .get_device(device_server_end)
94                .context("calling DeviceInstance get_device")
95                .map_err(errors::Error::NonFatal)?;
96            Ok(device)
97        };
98
99        let device = get_device()?.into_proxy();
100
101        let (port_watcher, port_watcher_server_end) =
102            fidl::endpoints::create_proxy::<fhwnet::PortWatcherMarker>();
103        device
104            .get_port_watcher(port_watcher_server_end)
105            .context("calling Device get_port_watcher")
106            .map_err(errors::Error::NonFatal)?;
107
108        let (device_control, device_control_server_end) = fidl::endpoints::create_proxy::<
109            fidl_fuchsia_net_interfaces_admin::DeviceControlMarker,
110        >();
111
112        let device_for_netstack = get_device()?;
113        installer
114            .install_device(device_for_netstack, device_control_server_end)
115            // NB: Failing to communicate with installer is a fatal error, that
116            // means the Netstack is gone, which we don't tolerate.
117            .unwrap_or_else(|err| exit_with_fidl_error(err));
118
119        Ok(futures::stream::try_unfold(
120            (port_watcher, device_control, device, topological_path),
121            |(port_watcher, device_control, device, topological_path)| async move {
122                loop {
123                    let port_event = match port_watcher.watch().await {
124                        Ok(port_event) => port_event,
125                        Err(err) => {
126                            break if err.is_closed() {
127                                Ok(None)
128                            } else {
129                                Err(errors::Error::Fatal(err.into()))
130                                    .context("calling PortWatcher watch")
131                            };
132                        }
133                    };
134                    match port_event {
135                        fhwnet::DevicePortEvent::Idle(fhwnet::Empty {}) => {}
136                        fhwnet::DevicePortEvent::Removed(port_id) => {
137                            let _: fhwnet::PortId = port_id;
138                        }
139                        fhwnet::DevicePortEvent::Added(port_id)
140                        | fhwnet::DevicePortEvent::Existing(port_id) => {
141                            let (port, port_server_end) =
142                                fidl::endpoints::create_proxy::<fhwnet::PortMarker>();
143                            device
144                                .get_port(&port_id, port_server_end)
145                                .context("calling Device get_port")
146                                .map_err(errors::Error::NonFatal)?;
147                            break Ok(Some((
148                                NetworkDeviceInstance {
149                                    port,
150                                    port_id,
151                                    device_control: device_control.clone(),
152                                    topological_path: topological_path.clone(),
153                                },
154                                (port_watcher, device_control, device, topological_path),
155                            )));
156                        }
157                    }
158                }
159            },
160        ))
161    }
162
163    pub async fn get_device_info(&self) -> Result<DeviceInfo, errors::Error> {
164        let NetworkDeviceInstance { port, port_id: _, device_control: _, topological_path } = self;
165        let fhwnet::PortInfo { id: _, base_info, .. } = port
166            .get_info()
167            .await
168            .context("error getting port info")
169            .map_err(errors::Error::NonFatal)?;
170        let port_class = base_info
171            .ok_or_else(|| errors::Error::Fatal(anyhow::anyhow!("missing base info in port info")))?
172            .port_class
173            .ok_or_else(|| {
174                errors::Error::Fatal(anyhow::anyhow!("missing port class in port base info"))
175            })?;
176
177        let (mac_addressing, mac_addressing_server_end) =
178            fidl::endpoints::create_proxy::<fhwnet::MacAddressingMarker>();
179        port.get_mac(mac_addressing_server_end)
180            .context("calling Port get_mac")
181            .map_err(errors::Error::NonFatal)?;
182
183        let mac = mac_addressing
184            .get_unicast_address()
185            .await
186            .map(Some)
187            .or_else(|fidl_err| {
188                if fidl_err.is_closed() {
189                    Ok(None)
190                } else {
191                    Err(anyhow::Error::from(fidl_err))
192                }
193            })
194            .map_err(errors::Error::NonFatal)?;
195        Ok(DeviceInfo {
196            port_class,
197            mac: mac.map(Into::into),
198            topological_path: topological_path.clone(),
199        })
200    }
201
202    pub async fn add_to_stack(
203        &self,
204        _netcfg: &super::NetCfg<'_>,
205        config: crate::InterfaceConfig,
206    ) -> Result<(u64, fidl_fuchsia_net_interfaces_ext::admin::Control), AddDeviceError> {
207        let NetworkDeviceInstance { port: _, port_id, device_control, topological_path: _ } = self;
208        let crate::InterfaceConfig { name, metric } = config;
209
210        let (control, control_server_end) =
211            fidl_fuchsia_net_interfaces_ext::admin::Control::create_endpoints()
212                .context("create Control proxy")
213                .map_err(errors::Error::NonFatal)?;
214
215        device_control
216            .create_interface(
217                &port_id,
218                control_server_end,
219                &fidl_fuchsia_net_interfaces_admin::Options {
220                    name: Some(name.clone()),
221                    metric: Some(metric),
222                    ..Default::default()
223                },
224            )
225            .context("calling DeviceControl create_interface")
226            .map_err(errors::Error::NonFatal)?;
227
228        let interface_id = control.get_id().await.map_err(|err| {
229            let other = match err {
230                fidl_fuchsia_net_interfaces_ext::admin::TerminalError::Fidl(err) => err.into(),
231                fidl_fuchsia_net_interfaces_ext::admin::TerminalError::Terminal(terminal_error) => {
232                    match terminal_error {
233                        fidl_fuchsia_net_interfaces_admin::InterfaceRemovedReason::DuplicateName => {
234                            return AddDeviceError::AlreadyExists(name);
235                        }
236                        reason => {
237                            anyhow::anyhow!("received terminal event {:?}", reason)
238                        }
239                    }
240                }
241            };
242            AddDeviceError::Other(
243                errors::Error::NonFatal(other).context("calling Control get_id"),
244            )
245        })?;
246        Ok((interface_id, control))
247    }
248}
249
250/// Returns the topological path for a device located at `filepath`, `filepath`
251/// converted to `String`, and a proxy to `S`.
252///
253/// It is expected that the node at `filepath` implements `S`,
254/// and that the node at `filepath` + `/device_controller` implements `fuchsia.device/Controller`.
255async fn get_topo_path_and_device<S: fidl::endpoints::ProtocolMarker>(
256    filepath: &std::path::PathBuf,
257) -> Result<(String, String, S::Proxy), errors::Error> {
258    let filepath = filepath
259        .to_str()
260        .ok_or_else(|| anyhow::anyhow!("failed to convert {:?} to str", filepath))
261        .map_err(errors::Error::NonFatal)?;
262
263    // Get the topological path using `fuchsia.device/Controller`.
264    let (controller, req) = fidl::endpoints::create_proxy::<fdev::ControllerMarker>();
265    let controller_path = format!("{filepath}/device_controller");
266    fdio::service_connect(&controller_path, req.into_channel().into())
267        .with_context(|| format!("error calling fdio::service_connect({})", controller_path))
268        .map_err(errors::Error::NonFatal)?;
269    let topological_path = controller
270        .get_topological_path()
271        .await
272        .context("error sending get topological path request")
273        .map_err(errors::Error::NonFatal)?
274        .map_err(zx::Status::from_raw)
275        .context("error getting topological path")
276        .map_err(errors::Error::NonFatal)?;
277
278    // Now connect to the device channel.
279    let (device, req) = fidl::endpoints::create_proxy::<S>();
280    fdio::service_connect(filepath, req.into_channel().into())
281        .with_context(|| format!("error calling fdio::service_connect({})", filepath))
282        .map_err(errors::Error::NonFatal)?;
283
284    Ok((topological_path, filepath.to_string(), device))
285}
netcfg/devices.rs

netcfg/
devices.rs
