1use std::cell::{Cell, Ref, RefCell};
2use std::net::{Ipv4Addr, SocketAddrV4};
3use std::ops::{Deref, DerefMut};
4use std::sync::Arc;
5
6use atomic_refcell::AtomicRefCell;
7
8use crate::core::configuration::QDiscMode;
9use crate::core::worker::Worker;
10use crate::host::descriptor::socket::abstract_unix_ns::AbstractUnixNamespace;
11use crate::host::descriptor::socket::inet::InetSocket;
12use crate::host::network::interface::{NetworkInterface, PcapOptions};
13use crate::network::PacketDevice;
14use crate::network::packet::IanaProtocol;
15
16const MIN_RANDOM_PORT: u16 = 10000;
19
20pub struct NetworkNamespace {
27 pub unix: Arc<AtomicRefCell<AbstractUnixNamespace>>,
29
30 pub localhost: RefCell<NetworkInterface>,
31 pub internet: RefCell<NetworkInterface>,
32
33 pub default_ip: Ipv4Addr,
34
35 has_run_cleanup: Cell<bool>,
37}
38
39impl NetworkNamespace {
40 pub fn new(public_ip: Ipv4Addr, pcap: Option<PcapOptions>, qdisc: QDiscMode) -> Self {
41 let localhost = NetworkInterface::new("lo", Ipv4Addr::LOCALHOST, pcap.clone(), qdisc);
42
43 let internet = NetworkInterface::new("eth0", public_ip, pcap, qdisc);
44
45 Self {
46 unix: Arc::new(AtomicRefCell::new(AbstractUnixNamespace::new())),
47 localhost: RefCell::new(localhost),
48 internet: RefCell::new(internet),
49 default_ip: public_ip,
50 has_run_cleanup: Cell::new(false),
51 }
52 }
53
54 pub fn cleanup(&self) {
57 assert!(!self.has_run_cleanup.get());
58
59 self.localhost.borrow().remove_all_sockets();
62 self.internet.borrow().remove_all_sockets();
63
64 self.has_run_cleanup.set(true);
65 }
66
67 #[track_caller]
69 pub fn interface_borrow(
70 &self,
71 addr: Ipv4Addr,
72 ) -> Option<impl Deref<Target = NetworkInterface> + '_> {
73 if addr.is_loopback() {
81 Some(self.localhost.borrow())
82 } else if addr == self.default_ip || addr.is_unspecified() {
83 Some(self.internet.borrow())
84 } else {
85 None
86 }
87 }
88
89 #[track_caller]
91 pub fn interface_borrow_mut(
92 &self,
93 addr: Ipv4Addr,
94 ) -> Option<impl DerefMut<Target = NetworkInterface> + '_> {
95 if addr.is_loopback() {
97 Some(self.localhost.borrow_mut())
98 } else if addr == self.default_ip || addr.is_unspecified() {
99 Some(self.internet.borrow_mut())
100 } else {
101 None
102 }
103 }
104
105 #[track_caller]
107 pub fn interface_borrow_as_packet_device(
108 &self,
109 addr: Ipv4Addr,
110 ) -> Option<Ref<'_, dyn PacketDevice>> {
111 if addr.is_loopback() {
113 Some(self.localhost.borrow())
114 } else if addr == self.default_ip || addr.is_unspecified() {
115 Some(self.internet.borrow())
116 } else {
117 None
118 }
119 }
120
121 pub fn is_addr_in_use(
122 &self,
123 protocol_type: IanaProtocol,
124 src: SocketAddrV4,
125 dst: SocketAddrV4,
126 ) -> Result<bool, NoInterface> {
127 if src.ip().is_unspecified() {
128 Ok(self
129 .localhost
130 .borrow()
131 .is_addr_in_use(protocol_type, src.port(), dst)
132 || self
133 .internet
134 .borrow()
135 .is_addr_in_use(protocol_type, src.port(), dst))
136 } else {
137 match self.interface_borrow(*src.ip()) {
138 Some(i) => Ok(i.is_addr_in_use(protocol_type, src.port(), dst)),
139 None => Err(NoInterface),
140 }
141 }
142 }
143
144 pub fn get_random_free_port(
146 &self,
147 protocol_type: IanaProtocol,
148 interface_ip: Ipv4Addr,
149 peer: SocketAddrV4,
150 mut rng: impl rand::RngExt,
151 ) -> Option<u16> {
152 for _ in 0..10 {
160 let random_port = rng.random_range(MIN_RANDOM_PORT..=u16::MAX);
161
162 let specific_in_use = self
164 .is_addr_in_use(
165 protocol_type,
166 SocketAddrV4::new(interface_ip, random_port),
167 peer,
168 )
169 .unwrap_or(true);
170 let generic_in_use = self
171 .is_addr_in_use(
172 protocol_type,
173 SocketAddrV4::new(interface_ip, random_port),
174 SocketAddrV4::new(Ipv4Addr::UNSPECIFIED, 0),
175 )
176 .unwrap_or(true);
177 if !specific_in_use && !generic_in_use {
178 return Some(random_port);
179 }
180 }
181
182 let start = rng.random_range(MIN_RANDOM_PORT..=u16::MAX);
186 for port in (start..=u16::MAX).chain(MIN_RANDOM_PORT..start) {
187 let specific_in_use = self
188 .is_addr_in_use(protocol_type, SocketAddrV4::new(interface_ip, port), peer)
189 .unwrap_or(true);
190 let generic_in_use = self
191 .is_addr_in_use(
192 protocol_type,
193 SocketAddrV4::new(interface_ip, port),
194 SocketAddrV4::new(Ipv4Addr::UNSPECIFIED, 0),
195 )
196 .unwrap_or(true);
197 if !specific_in_use && !generic_in_use {
198 return Some(port);
199 }
200 }
201
202 log::warn!("unable to find free ephemeral port for {protocol_type:?} peer {peer}");
203 None
204 }
205
206 pub unsafe fn associate_interface(
213 &self,
214 socket: &InetSocket,
215 protocol: IanaProtocol,
216 bind_addr: SocketAddrV4,
217 peer_addr: SocketAddrV4,
218 ) -> AssociationHandle {
219 if bind_addr.ip().is_unspecified() {
220 self.localhost
222 .borrow()
223 .associate(socket, protocol, bind_addr.port(), peer_addr);
224 self.internet
225 .borrow()
226 .associate(socket, protocol, bind_addr.port(), peer_addr);
227 } else {
228 if let Some(iface) = self.interface_borrow(*bind_addr.ip()) {
230 iface.associate(socket, protocol, bind_addr.port(), peer_addr);
231 }
232 }
233
234 AssociationHandle {
235 protocol,
236 local_addr: bind_addr,
237 remote_addr: peer_addr,
238 }
239 }
240
241 pub fn disassociate_interface(
247 &self,
248 protocol: IanaProtocol,
249 bind_addr: SocketAddrV4,
250 peer_addr: SocketAddrV4,
251 ) {
252 if bind_addr.ip().is_unspecified() {
253 self.localhost
255 .borrow()
256 .disassociate(protocol, bind_addr.port(), peer_addr);
257
258 self.internet
259 .borrow()
260 .disassociate(protocol, bind_addr.port(), peer_addr);
261 } else {
262 if let Some(iface) = self.interface_borrow(*bind_addr.ip()) {
264 iface.disassociate(protocol, bind_addr.port(), peer_addr);
265 }
266 }
267 }
268}
269
270impl std::ops::Drop for NetworkNamespace {
271 fn drop(&mut self) {
272 if !self.has_run_cleanup.get() && !std::thread::panicking() {
273 warn_and_debug_panic!("Dropped the network namespace before it has been cleaned up");
274 }
275 }
276}
277
278#[derive(Copy, Clone, Debug, PartialEq, Eq)]
279pub struct NoInterface;
280
281impl std::fmt::Display for NoInterface {
282 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
283 write!(f, "No interface available")
284 }
285}
286
287impl std::error::Error for NoInterface {}
288
289#[derive(Debug)]
294pub struct AssociationHandle {
295 protocol: IanaProtocol,
296 local_addr: SocketAddrV4,
297 remote_addr: SocketAddrV4,
298}
299
300impl AssociationHandle {
301 pub fn local_addr(&self) -> SocketAddrV4 {
302 self.local_addr
303 }
304
305 pub fn remote_addr(&self) -> SocketAddrV4 {
306 self.remote_addr
307 }
308}
309
310impl std::ops::Drop for AssociationHandle {
311 fn drop(&mut self) {
312 Worker::with_active_host(|host| {
313 host.network_namespace_borrow().disassociate_interface(
314 self.protocol,
315 self.local_addr,
316 self.remote_addr,
317 );
318 })
319 .unwrap();
320 }
321}