use std::collections::HashMap;
use std::net::{IpAddr, Ipv6Addr};
use std::sync::{Arc, Mutex};
use pnet_packet::{
Packet,
ip::{IpNextHeaderProtocol, IpNextHeaderProtocols},
};
use pnet_transport::{
self as transport, TransportChannelType, TransportProtocol, TransportReceiver, TransportSender,
};
const TRANSPORT_BUFFER_SIZE: usize = 4096;
const CHANNEL_TYPE_UDP_V4: TransportChannelType =
TransportChannelType::Layer4(TransportProtocol::Ipv4(IpNextHeaderProtocols::Udp));
const CHANNEL_TYPE_UDP_V6: TransportChannelType =
TransportChannelType::Layer4(TransportProtocol::Ipv6(IpNextHeaderProtocols::Udp));
const CHANNEL_TYPE_TCP_V4: TransportChannelType =
TransportChannelType::Layer4(TransportProtocol::Ipv4(IpNextHeaderProtocols::Tcp));
const CHANNEL_TYPE_TCP_V6: TransportChannelType =
TransportChannelType::Layer4(TransportProtocol::Ipv6(IpNextHeaderProtocols::Tcp));
const CHANNEL_TYPE_ICMP_V4: TransportChannelType =
TransportChannelType::Layer4(TransportProtocol::Ipv4(IpNextHeaderProtocols::Icmp));
const CHANNEL_TYPE_ICMP_V6: TransportChannelType =
TransportChannelType::Layer4(TransportProtocol::Ipv6(IpNextHeaderProtocols::Icmpv6));
const CHANNEL_TYPE_SCTP_V4: TransportChannelType =
TransportChannelType::Layer4(TransportProtocol::Ipv4(IpNextHeaderProtocols::Sctp));
const CHANNEL_TYPE_SCTP_V6: TransportChannelType =
TransportChannelType::Layer4(TransportProtocol::Ipv6(IpNextHeaderProtocols::Sctp));
#[non_exhaustive]
#[derive(Debug, Clone, Copy)]
pub enum TransportType {
TcpLayer4,
UdpLayer4,
IcmpLayer4,
SctpLayer4,
IpProtocol(u8),
}
pub struct TransportSenderHandle {
v4: Option<Family>,
v6: Option<Family>,
routes: Mutex<HashMap<IpAddr, Option<IpAddr>>>,
}
const ROUTE_MEMO_LIMIT: usize = 1 << 16;
struct Family {
socket: Arc<Mutex<Socket>>,
channel: TransportChannelType,
pinned: Mutex<HashMap<IpAddr, Arc<Mutex<Socket>>>>,
}
impl Family {
fn new(sender: TransportSender, channel: TransportChannelType) -> Self {
Self {
socket: Socket::new(sender),
channel,
pinned: Mutex::new(HashMap::new()),
}
}
fn pinned(&self, source: IpAddr) -> Result<Arc<Mutex<Socket>>, RawSocketError> {
let mut pinned = self.pinned.lock().map_err(|_| RawSocketError::Poisoned)?;
if let Some(socket) = pinned.get(&source) {
return Ok(socket.clone());
}
let (sender, _receiver) = open_channel(self.channel)?;
pin(&sender, source)?;
let socket = Socket::new(sender);
pinned.insert(source, socket.clone());
Ok(socket)
}
}
struct Socket {
sender: TransportSender,
hop_limit: Option<u8>,
}
impl Socket {
fn new(sender: TransportSender) -> Arc<Mutex<Self>> {
Arc::new(Mutex::new(Self {
sender,
hop_limit: None,
}))
}
}
#[non_exhaustive]
#[derive(Debug, thiserror::Error)]
pub enum RawSocketError {
#[error("a raw socket could not be opened: {source}")]
Open {
#[source]
source: std::io::Error,
},
#[error(
"no open raw socket for {destination}, whose address family this handle does not carry"
)]
NoSocket {
destination: IpAddr,
},
#[error("a hop limit of {hop_limit} could not be set: {source}")]
HopLimit {
hop_limit: u8,
#[source]
source: std::io::Error,
},
#[error("{address} is not an address this host holds, so no raw socket can send from it")]
NotHeld {
address: IpAddr,
},
#[error("a raw socket could not be pinned to {address}: {source}")]
Pin {
address: IpAddr,
#[source]
source: std::io::Error,
},
#[error("sending to {destination} failed: {source}")]
Send {
destination: IpAddr,
#[source]
source: std::io::Error,
},
#[error("the raw socket lock was poisoned by another thread's panic")]
Poisoned,
}
impl TransportSenderHandle {
pub fn send_to<T: Packet>(
&self,
packet: T,
destination: IpAddr,
zone: Option<u32>,
hop_limit: u8,
) -> Result<usize, RawSocketError> {
let family = self.family(destination)?;
send_on(&family.socket, packet, destination, zone, hop_limit)
}
pub fn send_from<T: Packet>(
&self,
packet: T,
source: IpAddr,
destination: IpAddr,
zone: Option<u32>,
hop_limit: u8,
) -> Result<usize, RawSocketError> {
let family = self.family(destination)?;
let socket = if self.kernel_source(destination) == Some(source) {
family.socket.clone()
} else {
family.pinned(source)?
};
send_on(&socket, packet, destination, zone, hop_limit)
}
fn family(&self, destination: IpAddr) -> Result<&Family, RawSocketError> {
match destination {
IpAddr::V4(_) => self.v4.as_ref(),
IpAddr::V6(_) => self.v6.as_ref(),
}
.ok_or(RawSocketError::NoSocket { destination })
}
fn kernel_source(&self, destination: IpAddr) -> Option<IpAddr> {
let ask = || {
crate::system::interface::probe_route_source(
destination,
&mut crate::system::interface::ProbeSockets::default(),
)
};
let Ok(mut routes) = self.routes.lock() else {
return ask();
};
if let Some(known) = routes.get(&destination) {
return *known;
}
if routes.len() >= ROUTE_MEMO_LIMIT {
routes.clear();
}
let source = ask();
routes.insert(destination, source);
source
}
}
fn send_on<T: Packet>(
socket: &Mutex<Socket>,
packet: T,
destination: IpAddr,
zone: Option<u32>,
hop_limit: u8,
) -> Result<usize, RawSocketError> {
let mut socket = socket.lock().map_err(|_| RawSocketError::Poisoned)?;
if socket.hop_limit != Some(hop_limit) {
socket
.sender
.set_ttl(hop_limit)
.map_err(|source| RawSocketError::HopLimit { hop_limit, source })?;
socket.hop_limit = Some(hop_limit);
}
match (destination, zone) {
(IpAddr::V6(v6), Some(zone)) => {
send_scoped(socket.sender.socket.fd, packet.packet(), v6, 0, zone)
}
_ => socket.sender.send_to(packet, destination),
}
.map_err(|source| RawSocketError::Send {
destination,
source,
})
}
#[cfg(unix)]
fn pin(sender: &TransportSender, source: IpAddr) -> Result<(), RawSocketError> {
use std::os::fd::BorrowedFd;
let link = crate::system::interface::interfaces()
.into_iter()
.find(|link| link.addresses().iter().any(|held| held.address() == source))
.ok_or(RawSocketError::NotHeld { address: source })?;
let failed = |error| RawSocketError::Pin {
address: source,
source: error,
};
let fd = unsafe { BorrowedFd::borrow_raw(sender.socket.fd) };
let socket = socket2::SockRef::from(&fd);
let address = match source {
IpAddr::V4(v4) => std::net::SocketAddr::from((v4, 0)),
IpAddr::V6(v6) => {
let scope = if v6.is_unicast_link_local() {
link.index()
} else {
0
};
std::net::SocketAddr::V6(std::net::SocketAddrV6::new(v6, 0, 0, scope))
}
};
socket.bind(&address.into()).map_err(failed)?;
#[cfg(any(target_os = "linux", target_os = "android", target_vendor = "apple"))]
{
let index = std::num::NonZeroU32::new(link.index());
match source {
IpAddr::V4(_) => socket.bind_device_by_index_v4(index),
IpAddr::V6(_) => socket.bind_device_by_index_v6(index),
}
.map_err(failed)?;
}
Ok(())
}
#[cfg(not(unix))]
fn pin(_sender: &TransportSender, source: IpAddr) -> Result<(), RawSocketError> {
Err(RawSocketError::Pin {
address: source,
source: std::io::Error::new(
std::io::ErrorKind::Unsupported,
"a raw socket is not pinned to a source on this platform",
),
})
}
#[cfg(unix)]
fn send_scoped(
fd: std::os::fd::RawFd,
bytes: &[u8],
destination: Ipv6Addr,
port: u16,
zone: u32,
) -> std::io::Result<usize> {
let address = socket2::SockAddr::from(std::net::SocketAddrV6::new(destination, port, 0, zone));
let written = unsafe {
libc::sendto(
fd,
bytes.as_ptr().cast(),
bytes.len(),
0,
address.as_ptr().cast(),
address.len(),
)
};
match written {
-1 => Err(std::io::Error::last_os_error()),
written => Ok(written as usize),
}
}
#[cfg(not(unix))]
fn send_scoped(
_fd: usize,
_bytes: &[u8],
_destination: Ipv6Addr,
_port: u16,
_zone: u32,
) -> std::io::Result<usize> {
Err(std::io::Error::new(
std::io::ErrorKind::Unsupported,
"a scoped raw send is not built on this platform",
))
}
pub fn open_sender(transport_type: TransportType) -> Result<TransportSenderHandle, RawSocketError> {
match transport_type {
TransportType::TcpLayer4 => both(CHANNEL_TYPE_TCP_V4, CHANNEL_TYPE_TCP_V6),
TransportType::UdpLayer4 => both(CHANNEL_TYPE_UDP_V4, CHANNEL_TYPE_UDP_V6),
TransportType::SctpLayer4 => both(CHANNEL_TYPE_SCTP_V4, CHANNEL_TYPE_SCTP_V6),
TransportType::IcmpLayer4 => both(CHANNEL_TYPE_ICMP_V4, CHANNEL_TYPE_ICMP_V6),
TransportType::IpProtocol(number) => {
let protocol = IpNextHeaderProtocol(number);
both(
TransportChannelType::Layer4(TransportProtocol::Ipv4(protocol)),
TransportChannelType::Layer4(TransportProtocol::Ipv6(protocol)),
)
}
}
}
fn both(
v4: TransportChannelType,
v6: TransportChannelType,
) -> Result<TransportSenderHandle, RawSocketError> {
let (v4_tx, _v4_rx) = open_channel(v4)?;
let v6_tx = open_channel(v6).ok().map(|(v6_tx, _v6_rx)| v6_tx);
Ok(TransportSenderHandle {
v4: Some(Family::new(v4_tx, v4)),
v6: v6_tx.map(|tx| Family::new(tx, v6)),
routes: Mutex::new(HashMap::new()),
})
}
fn open_channel(
channel_type: TransportChannelType,
) -> Result<(TransportSender, TransportReceiver), RawSocketError> {
transport::transport_channel(TRANSPORT_BUFFER_SIZE, channel_type)
.map_err(|source| RawSocketError::Open { source })
}
#[cfg(all(test, unix))]
mod tests {
use super::*;
use std::net::UdpSocket;
use std::os::fd::AsRawFd;
const DISCARD: u16 = 9;
#[test]
fn a_scoped_send_reaches_the_kernel_with_its_interface_on_it() {
let mut links: Vec<_> = crate::system::interface::interfaces()
.into_iter()
.filter(|link| link.is_up() && !link.is_loopback() && !link.is_point_to_point())
.collect();
links.sort_by_key(crate::system::interface::Link::index);
let Some((address, zone)) = links.iter().find_map(|link| {
link.addresses()
.iter()
.map(|held| held.address())
.find_map(|address| match address {
IpAddr::V6(v6) if v6.is_unicast_link_local() => Some((v6, link.index())),
_ => None,
})
}) else {
return;
};
let socket = UdpSocket::bind("[::]:0").expect("an unprivileged socket");
let sent = send_scoped(socket.as_raw_fd(), b"zond", address, DISCARD, zone);
assert!(
sent.is_ok(),
"a scoped destination is deliverable: {}",
sent.unwrap_err()
);
}
}