use std::net::{IpAddr, Ipv6Addr, SocketAddrV6};
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<Arc<Mutex<Socket>>>,
v6: Option<Arc<Mutex<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("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 socket = match destination {
IpAddr::V4(_) => self.v4.as_ref(),
IpAddr::V6(_) => self.v6.as_ref(),
}
.ok_or(RawSocketError::NoSocket { destination })?;
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 send_scoped(
fd: std::os::fd::RawFd,
bytes: &[u8],
destination: Ipv6Addr,
port: u16,
zone: u32,
) -> std::io::Result<usize> {
let address = socket2::SockAddr::from(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: std::os::windows::io::RawSocket,
_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 => {
let (v4_tx, _v4_rx) = open_channel(CHANNEL_TYPE_TCP_V4)?;
let v6 = open_channel(CHANNEL_TYPE_TCP_V6)
.ok()
.map(|(v6_tx, _v6_rx)| Socket::new(v6_tx));
Ok(TransportSenderHandle {
v4: Some(Socket::new(v4_tx)),
v6,
})
}
TransportType::UdpLayer4 => {
let (v4_tx, _v4_rx) = open_channel(CHANNEL_TYPE_UDP_V4)?;
let v6 = open_channel(CHANNEL_TYPE_UDP_V6)
.ok()
.map(|(v6_tx, _v6_rx)| Socket::new(v6_tx));
Ok(TransportSenderHandle {
v4: Some(Socket::new(v4_tx)),
v6,
})
}
TransportType::SctpLayer4 => {
let (v4_tx, _v4_rx) = open_channel(CHANNEL_TYPE_SCTP_V4)?;
let v6 = open_channel(CHANNEL_TYPE_SCTP_V6)
.ok()
.map(|(v6_tx, _v6_rx)| Socket::new(v6_tx));
Ok(TransportSenderHandle {
v4: Some(Socket::new(v4_tx)),
v6,
})
}
TransportType::IpProtocol(number) => {
let protocol = IpNextHeaderProtocol(number);
let (v4_tx, _v4_rx) = open_channel(TransportChannelType::Layer4(
TransportProtocol::Ipv4(protocol),
))?;
let v6 = open_channel(TransportChannelType::Layer4(TransportProtocol::Ipv6(
protocol,
)))
.ok()
.map(|(v6_tx, _v6_rx)| Socket::new(v6_tx));
Ok(TransportSenderHandle {
v4: Some(Socket::new(v4_tx)),
v6,
})
}
TransportType::IcmpLayer4 => {
let (v4_tx, _v4_rx) = open_channel(CHANNEL_TYPE_ICMP_V4)?;
let v6 = open_channel(CHANNEL_TYPE_ICMP_V6)
.ok()
.map(|(v6_tx, _v6_rx)| Socket::new(v6_tx));
Ok(TransportSenderHandle {
v4: Some(Socket::new(v4_tx)),
v6,
})
}
}
}
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()
);
}
}