use futures::stream::StreamExt;
use std::{
marker::PhantomData,
net::{Ipv4Addr, Ipv6Addr},
};
use netlink_packet_route::{
constants::*,
nlas::rule::Nla,
NetlinkMessage,
RtnlMessage,
RuleMessage,
};
use crate::{try_nl, Error, Handle};
pub struct RuleAddRequest<T = ()> {
handle: Handle,
message: RuleMessage,
replace: bool,
_phantom: PhantomData<T>,
}
impl<T> RuleAddRequest<T> {
pub(crate) fn new(handle: Handle) -> Self {
let mut message = RuleMessage::default();
message.header.table = RT_TABLE_MAIN;
message.header.action = FR_ACT_UNSPEC;
RuleAddRequest {
handle,
message,
replace: false,
_phantom: Default::default(),
}
}
pub fn input_interface(mut self, ifname: String) -> Self {
self.message.nlas.push(Nla::Iifname(ifname));
self
}
pub fn output_interface(mut self, ifname: String) -> Self {
self.message.nlas.push(Nla::OifName(ifname));
self
}
pub fn table(mut self, table: u8) -> Self {
self.message.header.table = table;
self
}
pub fn tos(mut self, tos: u8) -> Self {
self.message.header.tos = tos;
self
}
pub fn action(mut self, action: u8) -> Self {
self.message.header.action = action;
self
}
pub fn v4(mut self) -> RuleAddRequest<Ipv4Addr> {
self.message.header.family = AF_INET as u8;
RuleAddRequest {
handle: self.handle,
message: self.message,
replace: false,
_phantom: Default::default(),
}
}
pub fn v6(mut self) -> RuleAddRequest<Ipv6Addr> {
self.message.header.family = AF_INET6 as u8;
RuleAddRequest {
handle: self.handle,
message: self.message,
replace: false,
_phantom: Default::default(),
}
}
pub fn replace(self) -> Self {
Self {
replace: true,
..self
}
}
pub async fn execute(self) -> Result<(), Error> {
let RuleAddRequest {
mut handle,
message,
replace,
..
} = self;
let mut req = NetlinkMessage::from(RtnlMessage::NewRule(message));
let replace = if replace { NLM_F_REPLACE } else { NLM_F_EXCL };
req.header.flags = NLM_F_REQUEST | NLM_F_ACK | replace | NLM_F_CREATE;
let mut response = handle.request(req)?;
while let Some(message) = response.next().await {
try_nl!(message);
}
Ok(())
}
pub fn message_mut(&mut self) -> &mut RuleMessage {
&mut self.message
}
}
impl RuleAddRequest<Ipv4Addr> {
pub fn source_prefix(mut self, addr: Ipv4Addr, prefix_length: u8) -> Self {
self.message.header.src_len = prefix_length;
let src = addr.octets().to_vec();
self.message.nlas.push(Nla::Source(src));
self
}
pub fn destination_prefix(mut self, addr: Ipv4Addr, prefix_length: u8) -> Self {
self.message.header.dst_len = prefix_length;
let dst = addr.octets().to_vec();
self.message.nlas.push(Nla::Destination(dst));
self
}
}
impl RuleAddRequest<Ipv6Addr> {
pub fn source_prefix(mut self, addr: Ipv6Addr, prefix_length: u8) -> Self {
self.message.header.src_len = prefix_length;
let src = addr.octets().to_vec();
self.message.nlas.push(Nla::Source(src));
self
}
pub fn destination_prefix(mut self, addr: Ipv6Addr, prefix_length: u8) -> Self {
self.message.header.dst_len = prefix_length;
let dst = addr.octets().to_vec();
self.message.nlas.push(Nla::Destination(dst));
self
}
}