use std::net::IpAddr;
use std::sync::{Arc, Mutex};
use anyhow::Context;
use pnet::{
packet::{Packet, ip::IpNextHeaderProtocols},
transport::{
self, 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_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));
#[derive(Debug, Clone, Copy)]
pub enum TransportType {
TcpLayer4,
UdpLayer4,
IcmpLayer4,
}
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,
}))
}
}
impl TransportSenderHandle {
pub fn send_to<T: Packet>(
&self,
packet: T,
destination: IpAddr,
hop_limit: u8,
) -> anyhow::Result<usize> {
let socket = match destination {
IpAddr::V4(_) => self.v4.as_ref(),
IpAddr::V6(_) => self.v6.as_ref(),
}
.with_context(|| format!("no open transport socket for {destination}'s address family"))?;
let mut socket = socket.lock().unwrap();
if socket.hop_limit != Some(hop_limit) {
socket
.sender
.set_ttl(hop_limit)
.with_context(|| format!("failed to set a hop limit of {hop_limit}"))?;
socket.hop_limit = Some(hop_limit);
}
socket
.sender
.send_to(packet, destination)
.with_context(|| format!("failed to send to {destination}"))
}
}
pub fn open_sender(transport_type: TransportType) -> anyhow::Result<TransportSenderHandle> {
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)?;
Ok(TransportSenderHandle {
v4: Some(Socket::new(v4_tx)),
v6: None,
})
}
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,
) -> anyhow::Result<(TransportSender, TransportReceiver)> {
let (tx, rx) = transport::transport_channel(TRANSPORT_BUFFER_SIZE, channel_type)?;
Ok((tx, rx))
}