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<TransportSender>>>,
v6: Option<Arc<Mutex<TransportSender>>>,
}
impl TransportSenderHandle {
pub fn send_to<T: Packet>(&self, packet: T, destination: IpAddr) -> anyhow::Result<usize> {
let sender = 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"))?;
sender
.lock()
.unwrap()
.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)| Arc::new(Mutex::new(v6_tx)));
Ok(TransportSenderHandle {
v4: Some(Arc::new(Mutex::new(v4_tx))),
v6,
})
}
TransportType::UdpLayer4 => {
let (v4_tx, _v4_rx) = open_channel(CHANNEL_TYPE_UDP_V4)?;
Ok(TransportSenderHandle {
v4: Some(Arc::new(Mutex::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)| Arc::new(Mutex::new(v6_tx)));
Ok(TransportSenderHandle {
v4: Some(Arc::new(Mutex::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))
}