fidl_fuchsia_posix_socket_ext/
lib.rs

1// Copyright 2023 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//! Extension crate for `fuchsia.posix.socket` and `fuchsia.posix.socket.packet`.
6#![deny(missing_docs)]
7
8use fidl_fuchsia_posix_socket as fposix_socket;
9use fidl_fuchsia_posix_socket_packet as fpacket;
10use zx::StatusExt;
11
12/// Creates a datagram socket using the given provider.
13pub async fn datagram_socket(
14    provider: &fposix_socket::ProviderProxy,
15    domain: fposix_socket::Domain,
16    protocol: fposix_socket::DatagramSocketProtocol,
17) -> Result<Result<socket2::Socket, std::io::Error>, fidl::Error> {
18    let result = provider.datagram_socket(domain, protocol).await?;
19    Ok(async move {
20        let response =
21            result.map_err(|errno| std::io::Error::from_raw_os_error(errno.into_primitive()))?;
22        let fd = match response {
23            fposix_socket::ProviderDatagramSocketResponse::DatagramSocket(client_end) => {
24                fdio::create_fd(client_end.into()).map_err(|status| status.into_io_error())
25            }
26            fposix_socket::ProviderDatagramSocketResponse::SynchronousDatagramSocket(
27                client_end,
28            ) => fdio::create_fd(client_end.into()).map_err(|status| status.into_io_error()),
29        }?;
30        Ok(fd.into())
31    }
32    .await)
33}
34
35/// Creates a datagram socket using the given provider and configured with the
36/// specified options.
37pub async fn datagram_socket_with_options(
38    provider: &fposix_socket::ProviderProxy,
39    domain: fposix_socket::Domain,
40    protocol: fposix_socket::DatagramSocketProtocol,
41    options: fposix_socket::SocketCreationOptions,
42) -> Result<Result<socket2::Socket, std::io::Error>, fidl::Error> {
43    let result = provider.datagram_socket_with_options(domain, protocol, options).await?;
44    Ok(async move {
45        let response =
46            result.map_err(|errno| std::io::Error::from_raw_os_error(errno.into_primitive()))?;
47        let fd = match response {
48            fposix_socket::ProviderDatagramSocketWithOptionsResponse::DatagramSocket(
49                client_end,
50            ) => fdio::create_fd(client_end.into()).map_err(|status| status.into_io_error()),
51            fposix_socket::ProviderDatagramSocketWithOptionsResponse::SynchronousDatagramSocket(
52                client_end,
53            ) => fdio::create_fd(client_end.into()).map_err(|status| status.into_io_error()),
54        }?;
55        Ok(fd.into())
56    }
57    .await)
58}
59
60/// Creates a packet socket using the given provider.
61pub async fn packet_socket(
62    provider: &fpacket::ProviderProxy,
63    kind: fpacket::Kind,
64) -> Result<Result<socket2::Socket, std::io::Error>, fidl::Error> {
65    let result = provider.socket(kind).await?;
66    Ok(async move {
67        let client_end =
68            result.map_err(|errno| std::io::Error::from_raw_os_error(errno.into_primitive()))?;
69        Ok(fdio::create_fd(client_end.into()).map_err(|status| status.into_io_error())?.into())
70    }
71    .await)
72}
73
74#[cfg(test)]
75mod test {
76    use super::*;
77    use fidl_fuchsia_net_ext as fnet_ext;
78    use fidl_fuchsia_netemul_network as fnetemul_network;
79    use fidl_fuchsia_posix_socket as fposix_socket;
80    use net_declare::std_socket_addr;
81    use netstack_testing_common::realms::{Netstack, TestSandboxExt as _};
82    use netstack_testing_macros::netstack_test;
83    use sockaddr::{IntoSockAddr as _, TryToSockaddrLl as _};
84
85    #[netstack_test]
86    #[variant(N, Netstack)]
87    async fn datagram_socket_send_receive<N: Netstack>(name: &str) {
88        let sandbox: netemul::TestSandbox = netemul::TestSandbox::new().unwrap();
89
90        let network =
91            sandbox.create_network(format!("{name}-test-network")).await.expect("create network");
92        let realm_a: netemul::TestRealm<'_> = sandbox
93            .create_netstack_realm::<N, _>(format!("{name}-test-realm-a"))
94            .expect("create realm");
95        let realm_b: netemul::TestRealm<'_> = sandbox
96            .create_netstack_realm::<N, _>(format!("{name}-test-realm-b"))
97            .expect("create realm");
98
99        const MAC_A: net_types::ethernet::Mac = net_declare::net_mac!("00:00:00:00:00:01");
100        const MAC_B: net_types::ethernet::Mac = net_declare::net_mac!("00:00:00:00:00:02");
101        const FIDL_SUBNET_A: fidl_fuchsia_net::Subnet = net_declare::fidl_subnet!("192.0.2.1/24");
102        const SOCKET_ADDR_A: std::net::SocketAddr = std_socket_addr!("192.0.2.1:1111");
103        const FIDL_SUBNET_B: fidl_fuchsia_net::Subnet = net_declare::fidl_subnet!("192.0.2.2/24");
104        const SOCKET_ADDR_B: std::net::SocketAddr = std_socket_addr!("192.0.2.2:2222");
105
106        let iface_a = realm_a
107            .join_network_with(
108                &network,
109                "iface_a",
110                fnetemul_network::EndpointConfig {
111                    mtu: netemul::DEFAULT_MTU,
112                    mac: Some(Box::new(fnet_ext::MacAddress { octets: MAC_A.bytes() }.into())),
113                    port_class: fidl_fuchsia_hardware_network::PortClass::Virtual,
114                },
115                netemul::InterfaceConfig { name: Some("iface_a".into()), ..Default::default() },
116            )
117            .await
118            .expect("join network with realm_a");
119        let iface_b = realm_b
120            .join_network_with(
121                &network,
122                "iface_b",
123                fnetemul_network::EndpointConfig {
124                    mtu: netemul::DEFAULT_MTU,
125                    mac: Some(Box::new(fnet_ext::MacAddress { octets: MAC_B.bytes() }.into())),
126                    port_class: fidl_fuchsia_hardware_network::PortClass::Virtual,
127                },
128                netemul::InterfaceConfig { name: Some("iface_b".into()), ..Default::default() },
129            )
130            .await
131            .expect("join network with realm_b");
132
133        iface_a
134            .add_address_and_subnet_route(FIDL_SUBNET_A)
135            .await
136            .expect("add address should succeed");
137        iface_b
138            .add_address_and_subnet_route(FIDL_SUBNET_B)
139            .await
140            .expect("add address should succeed");
141
142        let socket_a = datagram_socket(
143            &realm_a
144                .connect_to_protocol::<fposix_socket::ProviderMarker>()
145                .expect("connect should succeed"),
146            fposix_socket::Domain::Ipv4,
147            fposix_socket::DatagramSocketProtocol::Udp,
148        )
149        .await
150        .expect("should not have FIDL error")
151        .expect("should not have io Error");
152
153        socket_a.bind(&SOCKET_ADDR_A.into()).expect("should succeed");
154
155        let socket_b = datagram_socket(
156            &realm_b
157                .connect_to_protocol::<fposix_socket::ProviderMarker>()
158                .expect("connect should succeed"),
159            fposix_socket::Domain::Ipv4,
160            fposix_socket::DatagramSocketProtocol::Udp,
161        )
162        .await
163        .expect("should not have FIDL error")
164        .expect("should not have io Error");
165
166        socket_b.bind(&SOCKET_ADDR_B.into()).expect("should succeed");
167
168        let mut buf = [std::mem::MaybeUninit::new(0u8); netemul::DEFAULT_MTU as usize];
169
170        let payload = b"hello world!";
171
172        let n = socket_a
173            .send_to(payload.as_ref(), &SOCKET_ADDR_B.into())
174            .expect("send_to should succeed");
175        assert_eq!(n, payload.len());
176
177        let (n, address) = socket_b.recv_from(&mut buf[..]).expect("recv_from should succeed");
178        let buf = buf[..n].iter().map(|byte| unsafe { byte.assume_init() }).collect::<Vec<_>>();
179
180        assert_eq!(&buf[..], payload.as_ref());
181        assert_eq!(address.as_socket().expect("should be SocketAddr"), SOCKET_ADDR_A);
182    }
183
184    #[netstack_test]
185    #[variant(N, Netstack)]
186    async fn packet_socket_send_receive<N: Netstack>(name: &str) {
187        let sandbox: netemul::TestSandbox = netemul::TestSandbox::new().unwrap();
188
189        let network =
190            sandbox.create_network(format!("{name}-test-network")).await.expect("create network");
191        let realm_a: netemul::TestRealm<'_> = sandbox
192            .create_netstack_realm::<N, _>(format!("{name}-test-realm-a"))
193            .expect("create realm");
194        let realm_b: netemul::TestRealm<'_> = sandbox
195            .create_netstack_realm::<N, _>(format!("{name}-test-realm-b"))
196            .expect("create realm");
197
198        const MAC_A: net_types::ethernet::Mac = net_declare::net_mac!("00:00:00:00:00:01");
199        const MAC_B: net_types::ethernet::Mac = net_declare::net_mac!("00:00:00:00:00:02");
200
201        let iface_a = realm_a
202            .join_network_with(
203                &network,
204                "iface_a",
205                fnetemul_network::EndpointConfig {
206                    mtu: netemul::DEFAULT_MTU,
207                    mac: Some(Box::new(fnet_ext::MacAddress { octets: MAC_A.bytes() }.into())),
208                    port_class: fidl_fuchsia_hardware_network::PortClass::Virtual,
209                },
210                netemul::InterfaceConfig { name: Some("iface_a".into()), ..Default::default() },
211            )
212            .await
213            .expect("join network with realm_a");
214        let iface_b = realm_b
215            .join_network_with(
216                &network,
217                "iface_b",
218                fnetemul_network::EndpointConfig {
219                    mtu: netemul::DEFAULT_MTU,
220                    mac: Some(Box::new(fnet_ext::MacAddress { octets: MAC_B.bytes() }.into())),
221                    port_class: fidl_fuchsia_hardware_network::PortClass::Virtual,
222                },
223                netemul::InterfaceConfig { name: Some("iface_b".into()), ..Default::default() },
224            )
225            .await
226            .expect("join network with realm_b");
227
228        let socket_a = packet_socket(
229            &realm_a
230                .connect_to_protocol::<fpacket::ProviderMarker>()
231                .expect("connect should succeed"),
232            fpacket::Kind::Network,
233        )
234        .await
235        .expect("should not have FIDL error")
236        .expect("should not have io Error");
237
238        let socket_b = packet_socket(
239            &realm_b
240                .connect_to_protocol::<fpacket::ProviderMarker>()
241                .expect("connect should succeed"),
242            fpacket::Kind::Network,
243        )
244        .await
245        .expect("should not have FIDL error")
246        .expect("should not have io Error");
247
248        let sockaddr_a = libc::sockaddr_ll::from(sockaddr::EthernetSockaddr {
249            interface_id: Some(iface_a.id().try_into().expect("nonzero")),
250            addr: MAC_A,
251            protocol: packet_formats::ethernet::EtherType::Ipv4,
252        });
253
254        let sockaddr_b = libc::sockaddr_ll::from(sockaddr::EthernetSockaddr {
255            interface_id: Some(iface_b.id().try_into().expect("nonzero")),
256            addr: MAC_B,
257            protocol: packet_formats::ethernet::EtherType::Ipv4,
258        });
259
260        socket_a.bind(&sockaddr_a.into_sockaddr()).expect("should succeed");
261        socket_b.bind(&sockaddr_b.into_sockaddr()).expect("should succeed");
262
263        let mut buf = [std::mem::MaybeUninit::new(0u8); netemul::DEFAULT_MTU as usize];
264
265        let payload = b"hello world!";
266
267        let n = socket_a
268            .send_to(
269                payload.as_ref(),
270                &libc::sockaddr_ll::from(sockaddr::EthernetSockaddr {
271                    interface_id: Some(iface_a.id().try_into().expect("nonzero")),
272                    addr: MAC_B,
273                    protocol: packet_formats::ethernet::EtherType::Ipv4,
274                })
275                .into_sockaddr(),
276            )
277            .expect("send_to should succeed");
278        assert_eq!(n, payload.len());
279
280        // We make multiple attempts because there's no guarantee that we're the
281        // exclusive traffic over this interface. In particular, this is being
282        // introduced because we're seeing IGMP reports over the interface
283        // (https://g-issues.fuchsia.dev/issues/324591565#comment13), but even
284        // without that this is a source of flakiness.
285        const NUM_ATTEMPTS: i32 = 5;
286
287        for attempt in 1..=NUM_ATTEMPTS {
288            let (n, address) = socket_b.recv_from(&mut buf[..]).expect("recv_from should succeed");
289            let buf = buf[..n].iter().map(|byte| unsafe { byte.assume_init() }).collect::<Vec<_>>();
290
291            if &buf[..] != payload.as_ref() {
292                println!("got buf={buf:?} didn't match wanted={payload:?} in attempt {attempt}");
293                continue;
294            }
295
296            let got_address = match address.try_to_sockaddr_ll() {
297                Some(addr) => addr,
298                None => {
299                    println!("could not convert {address:?} to sockaddr_ll in attempt {attempt}");
300                    continue;
301                }
302            };
303
304            let want_address = {
305                let mut addr = libc::sockaddr_ll::from(sockaddr::EthernetSockaddr {
306                    interface_id: Some(iface_b.id().try_into().expect("nonzero")),
307                    addr: MAC_A,
308                    protocol: packet_formats::ethernet::EtherType::Ipv4,
309                });
310                const ARPHRD_ETHER: libc::c_ushort = 1;
311                addr.sll_hatype = ARPHRD_ETHER;
312                addr
313            };
314
315            if got_address != want_address {
316                println!(
317                    "got_address {got_address:?} didn't match \
318                want_address {want_address:?} in attempt {attempt}"
319                );
320                continue;
321            }
322
323            println!("succeeded on attempt {attempt}");
324            return;
325        }
326
327        panic!("failed to receive expected frame in all {NUM_ATTEMPTS} attempts");
328    }
329}
fidl_fuchsia_posix_socket_ext/lib.rs

fidl_fuchsia_posix_socket_ext/
lib.rs
