use netlink_packet_core::{
emit_u32, emit_u64, parse_u32, parse_u64, DecodeError, DefaultNla,
ErrorContext, Nla, NlaBuffer, NlasIterator, Parseable,
};
const NDTPA_IFINDEX: u16 = 1;
const NDTPA_REFCNT: u16 = 2;
const NDTPA_REACHABLE_TIME: u16 = 3;
const NDTPA_BASE_REACHABLE_TIME: u16 = 4;
const NDTPA_RETRANS_TIME: u16 = 5;
const NDTPA_GC_STALETIME: u16 = 6;
const NDTPA_DELAY_PROBE_TIME: u16 = 7;
const NDTPA_QUEUE_LEN: u16 = 8;
const NDTPA_APP_PROBES: u16 = 9;
const NDTPA_UCAST_PROBES: u16 = 10;
const NDTPA_MCAST_PROBES: u16 = 11;
const NDTPA_ANYCAST_DELAY: u16 = 12;
const NDTPA_PROXY_DELAY: u16 = 13;
const NDTPA_PROXY_QLEN: u16 = 14;
const NDTPA_LOCKTIME: u16 = 15;
const NDTPA_QUEUE_LENBYTES: u16 = 16;
const NDTPA_MCAST_REPROBES: u16 = 17;
const NDTPA_INTERVAL_PROBE_TIME_MS: u16 = 19;
#[derive(Debug, PartialEq, Eq, Clone)]
#[non_exhaustive]
pub enum NeighbourTableParameter {
Ifindex(u32),
ReferenceCount(u32),
ReachableTime(u64),
BaseReachableTime(u64),
RetransTime(u64),
GcStaletime(u64),
DelayProbeTime(u64),
QueueLen(u32),
AppProbes(u32),
UcastProbes(u32),
McastProbes(u32),
AnycastDelay(u64),
ProxyDelay(u64),
ProxyQlen(u32),
Locktime(u64),
QueueLenbytes(u32),
McastReprobes(u32),
IntervalProbeTimeMs(u64),
Other(DefaultNla),
}
impl Nla for NeighbourTableParameter {
fn value_len(&self) -> usize {
match self {
Self::Ifindex(_)
| Self::ReferenceCount(_)
| Self::QueueLen(_)
| Self::AppProbes(_)
| Self::UcastProbes(_)
| Self::McastProbes(_)
| Self::ProxyQlen(_)
| Self::QueueLenbytes(_)
| Self::McastReprobes(_) => 4,
Self::ReachableTime(_)
| Self::BaseReachableTime(_)
| Self::RetransTime(_)
| Self::GcStaletime(_)
| Self::DelayProbeTime(_)
| Self::AnycastDelay(_)
| Self::ProxyDelay(_)
| Self::Locktime(_)
| Self::IntervalProbeTimeMs(_) => 8,
Self::Other(nla) => nla.value_len(),
}
}
fn emit_value(&self, buffer: &mut [u8]) {
match self {
Self::Ifindex(v)
| Self::ReferenceCount(v)
| Self::QueueLen(v)
| Self::AppProbes(v)
| Self::UcastProbes(v)
| Self::McastProbes(v)
| Self::ProxyQlen(v)
| Self::QueueLenbytes(v)
| Self::McastReprobes(v) => emit_u32(buffer, *v).unwrap(),
Self::ReachableTime(v)
| Self::BaseReachableTime(v)
| Self::RetransTime(v)
| Self::GcStaletime(v)
| Self::DelayProbeTime(v)
| Self::AnycastDelay(v)
| Self::ProxyDelay(v)
| Self::Locktime(v)
| Self::IntervalProbeTimeMs(v) => emit_u64(buffer, *v).unwrap(),
Self::Other(nla) => nla.emit_value(buffer),
}
}
fn kind(&self) -> u16 {
match self {
Self::Ifindex(_) => NDTPA_IFINDEX,
Self::ReferenceCount(_) => NDTPA_REFCNT,
Self::ReachableTime(_) => NDTPA_REACHABLE_TIME,
Self::BaseReachableTime(_) => NDTPA_BASE_REACHABLE_TIME,
Self::RetransTime(_) => NDTPA_RETRANS_TIME,
Self::GcStaletime(_) => NDTPA_GC_STALETIME,
Self::DelayProbeTime(_) => NDTPA_DELAY_PROBE_TIME,
Self::QueueLen(_) => NDTPA_QUEUE_LEN,
Self::AppProbes(_) => NDTPA_APP_PROBES,
Self::UcastProbes(_) => NDTPA_UCAST_PROBES,
Self::McastProbes(_) => NDTPA_MCAST_PROBES,
Self::AnycastDelay(_) => NDTPA_ANYCAST_DELAY,
Self::ProxyDelay(_) => NDTPA_PROXY_DELAY,
Self::ProxyQlen(_) => NDTPA_PROXY_QLEN,
Self::Locktime(_) => NDTPA_LOCKTIME,
Self::QueueLenbytes(_) => NDTPA_QUEUE_LENBYTES,
Self::McastReprobes(_) => NDTPA_MCAST_REPROBES,
Self::IntervalProbeTimeMs(_) => NDTPA_INTERVAL_PROBE_TIME_MS,
Self::Other(nla) => nla.kind(),
}
}
}
impl<'a, T: AsRef<[u8]> + ?Sized> Parseable<NlaBuffer<&'a T>>
for NeighbourTableParameter
{
fn parse(buf: &NlaBuffer<&'a T>) -> Result<Self, DecodeError> {
let payload = buf.value();
Ok(match buf.kind() {
NDTPA_IFINDEX => {
Self::Ifindex(parse_u32(payload).context(format!(
"invalid NDTPA_IFINDEX value {payload:?}"
))?)
}
NDTPA_REFCNT => {
Self::ReferenceCount(parse_u32(payload).context(format!(
"invalid NDTPA_REFCNT value {payload:?}"
))?)
}
NDTPA_REACHABLE_TIME => {
Self::ReachableTime(parse_u64(payload).context(format!(
"invalid NDTPA_REACHABLE_TIME value {payload:?}"
))?)
}
NDTPA_BASE_REACHABLE_TIME => {
Self::BaseReachableTime(parse_u64(payload).context(format!(
"invalid NDTPA_BASE_REACHABLE_TIME value {payload:?}"
))?)
}
NDTPA_RETRANS_TIME => {
Self::RetransTime(parse_u64(payload).context(format!(
"invalid NDTPA_RETRANS_TIME value {payload:?}"
))?)
}
NDTPA_GC_STALETIME => {
Self::GcStaletime(parse_u64(payload).context(format!(
"invalid NDTPA_GC_STALE_TIME value {payload:?}"
))?)
}
NDTPA_DELAY_PROBE_TIME => {
Self::DelayProbeTime(parse_u64(payload).context(format!(
"invalid NDTPA_DELAY_PROBE_TIME value {payload:?}"
))?)
}
NDTPA_QUEUE_LEN => Self::QueueLen(parse_u32(payload).context(
format!("invalid NDTPA_QUEUE_LEN value {payload:?}"),
)?),
NDTPA_APP_PROBES => Self::AppProbes(parse_u32(payload).context(
format!("invalid NDTPA_APP_PROBES value {payload:?}"),
)?),
NDTPA_UCAST_PROBES => {
Self::UcastProbes(parse_u32(payload).context(format!(
"invalid NDTPA_UCAST_PROBES value {payload:?}"
))?)
}
NDTPA_MCAST_PROBES => {
Self::McastProbes(parse_u32(payload).context(format!(
"invalid NDTPA_MCAST_PROBES value {payload:?}"
))?)
}
NDTPA_ANYCAST_DELAY => {
Self::AnycastDelay(parse_u64(payload).context(format!(
"invalid NDTPA_ANYCAST_DELAY value {payload:?}"
))?)
}
NDTPA_PROXY_DELAY => Self::ProxyDelay(parse_u64(payload).context(
format!("invalid NDTPA_PROXY_DELAY value {payload:?}"),
)?),
NDTPA_PROXY_QLEN => Self::ProxyQlen(parse_u32(payload).context(
format!("invalid NDTPA_PROXY_QLEN value {payload:?}"),
)?),
NDTPA_LOCKTIME => Self::Locktime(parse_u64(payload).context(
format!("invalid NDTPA_LOCKTIME value {payload:?}"),
)?),
NDTPA_QUEUE_LENBYTES => {
Self::QueueLenbytes(parse_u32(payload).context(format!(
"invalid NDTPA_QUEUE_LENBYTES value {payload:?}"
))?)
}
NDTPA_MCAST_REPROBES => {
Self::McastReprobes(parse_u32(payload).context(format!(
"invalid NDTPA_MCAST_PROBES value {payload:?}"
))?)
}
NDTPA_INTERVAL_PROBE_TIME_MS => Self::IntervalProbeTimeMs(
parse_u64(payload).context(format!(
"invalid NDTPA_INTERVAL_PROBE_TIME_MS value {payload:?}"
))?,
),
_ => Self::Other(DefaultNla::parse(buf).context(format!(
"invalid NDTA_PARMS attribute {payload:?}"
))?),
})
}
}
#[derive(Debug, PartialEq, Eq, Clone)]
pub(crate) struct VecNeighbourTableParameter(
pub(crate) Vec<NeighbourTableParameter>,
);
impl<'a, T: AsRef<[u8]> + ?Sized> Parseable<NlaBuffer<&'a T>>
for VecNeighbourTableParameter
{
fn parse(buf: &NlaBuffer<&'a T>) -> Result<Self, DecodeError> {
let mut nlas = vec![];
let err = "invalid NDTA_PARMS attribute";
for nla in NlasIterator::new(buf.into_inner()) {
let nla = nla.context(err)?;
nlas.push(NeighbourTableParameter::parse(&nla).context(err)?);
}
Ok(Self(nlas))
}
}