use ipnet::{IpNet, Ipv4Net, Ipv6Net};
use prefix_trie::rkyv::ArchivedPrefixMap;
use prefix_trie::PrefixMap;
use rkyv::rancor::Error as RkyvError;
use crate::{Error, SnapValue, Snapshot};
fn align16(n: usize) -> usize {
n.div_ceil(16) * 16
}
fn header_len(type_id: &str) -> usize {
align16(2 + type_id.len()) + 8
}
fn head(type_id: &str) -> Vec<u8> {
let mut out = Vec::with_capacity(header_len(type_id));
out.extend_from_slice(&(type_id.len() as u16).to_le_bytes());
out.extend_from_slice(type_id.as_bytes());
out.resize(align16(out.len()), 0);
out.extend_from_slice(&[0u8; 8]);
out
}
pub struct TrieSection<U: SnapValue> {
v4: PrefixMap<Ipv4Net, U>,
v6: PrefixMap<Ipv6Net, U>,
}
impl<U: SnapValue> Default for TrieSection<U> {
fn default() -> Self {
Self::new()
}
}
impl<U: SnapValue> TrieSection<U> {
pub fn new() -> Self {
Self {
v4: PrefixMap::new(),
v6: PrefixMap::new(),
}
}
pub fn insert(&mut self, prefix: IpNet, value: U) -> Result<(), Error> {
if prefix.addr() != prefix.network() {
return Err(Error::BadPrefix(prefix.to_string()));
}
match prefix {
IpNet::V4(p) => {
self.v4.insert(p, value);
}
IpNet::V6(p) => {
self.v6.insert(p, value);
}
}
Ok(())
}
pub fn len(&self) -> usize {
self.v4.len() + self.v6.len()
}
pub fn is_empty(&self) -> bool {
self.len() == 0
}
pub fn to_bytes(&self) -> Result<Vec<u8>, Error> {
let v4 = rkyv::to_bytes::<RkyvError>(&self.v4).map_err(|_| Error::BadValue)?;
let v6 = rkyv::to_bytes::<RkyvError>(&self.v6).map_err(|_| Error::BadValue)?;
let mut out = head(U::TYPE_ID);
let lengths_at = out.len() - 8;
out[lengths_at..lengths_at + 4].copy_from_slice(&(v4.len() as u32).to_le_bytes());
out[lengths_at + 4..lengths_at + 8].copy_from_slice(&(v6.len() as u32).to_le_bytes());
out.extend_from_slice(&v4);
out.resize(align16(out.len()), 0);
out.extend_from_slice(&v6);
out.resize(align16(out.len()), 0);
Ok(out)
}
}
pub struct ProfileTrie<'a, U: SnapValue> {
v4: Option<&'a ArchivedPrefixMap<Ipv4Net, U>>,
v6: Option<&'a ArchivedPrefixMap<Ipv6Net, U>>,
}
impl<U: SnapValue> ProfileTrie<'_, U>
where
U::Archived: for<'b> rkyv::bytecheck::CheckBytes<rkyv::api::high::HighValidator<'b, RkyvError>>
+ rkyv::Deserialize<U, rkyv::api::high::HighDeserializer<RkyvError>>,
{
pub fn len(&self) -> usize {
self.v4.map(|m| m.len()).unwrap_or(0) + self.v6.map(|m| m.len()).unwrap_or(0)
}
pub fn is_empty(&self) -> bool {
self.len() == 0
}
pub fn get_exact(&self, prefix: IpNet) -> Option<U> {
let value = match prefix {
IpNet::V4(p) => self.v4.and_then(|m| m.get(&p)),
IpNet::V6(p) => self.v6.and_then(|m| m.get(&p)),
}?;
rkyv::deserialize::<U, RkyvError>(value).ok()
}
pub fn lpm(&self, prefix: IpNet) -> Option<(IpNet, U)> {
match prefix {
IpNet::V4(p) => {
let (found, value) = self.v4?.get_lpm(&p)?;
Some((
IpNet::V4(found),
rkyv::deserialize::<U, RkyvError>(value).ok()?,
))
}
IpNet::V6(p) => {
let (found, value) = self.v6?.get_lpm(&p)?;
Some((
IpNet::V6(found),
rkyv::deserialize::<U, RkyvError>(value).ok()?,
))
}
}
}
pub fn iter(&self) -> Vec<(IpNet, U)> {
let mut out = Vec::with_capacity(self.len());
if let Some(m) = self.v4 {
for (p, v) in m.iter() {
if let Ok(v) = rkyv::deserialize::<U, RkyvError>(v) {
out.push((IpNet::V4(p), v));
}
}
}
if let Some(m) = self.v6 {
for (p, v) in m.iter() {
if let Ok(v) = rkyv::deserialize::<U, RkyvError>(v) {
out.push((IpNet::V6(p), v));
}
}
}
out
}
}
impl<T: SnapValue> Snapshot<T> {
pub fn section_trie<U: SnapValue>(&self, id: u16) -> Result<Option<ProfileTrie<'_, U>>, Error>
where
U::Archived: for<'b> rkyv::bytecheck::CheckBytes<rkyv::api::high::HighValidator<'b, RkyvError>>
+ rkyv::Deserialize<U, rkyv::api::high::HighDeserializer<RkyvError>>,
{
let Some(bytes) = self.section_bytes(id) else {
return Ok(None);
};
if bytes.len() < 2 {
return Err(Error::BadArchive(id));
}
let id_len = u16::from_le_bytes([bytes[0], bytes[1]]) as usize;
let type_at = 2;
let after_id = align16(2 + id_len);
if bytes.len() < after_id + 8 {
return Err(Error::BadArchive(id));
}
let written = std::str::from_utf8(&bytes[type_at..type_at + id_len])
.map_err(|_| Error::BadArchive(id))?;
if written != U::TYPE_ID {
return Err(Error::ConfigMismatch(format!(
"section {id} holds {written}, not {}",
U::TYPE_ID
)));
}
let lengths = &bytes[after_id..after_id + 8];
let v4_len = u32::from_le_bytes([lengths[0], lengths[1], lengths[2], lengths[3]]) as usize;
let v6_len = u32::from_le_bytes([lengths[4], lengths[5], lengths[6], lengths[7]]) as usize;
let v4_at = after_id + 8;
let v6_at = align16(v4_at + v4_len);
if v6_at + v6_len > bytes.len() {
return Err(Error::BadArchive(id));
}
let v4 = &bytes[v4_at..v4_at + v4_len];
let v6 = &bytes[v6_at..v6_at + v6_len];
let v4 = rkyv::access::<ArchivedPrefixMap<Ipv4Net, U>, RkyvError>(v4)
.map_err(|_| Error::BadArchive(id))?;
let v6 = rkyv::access::<ArchivedPrefixMap<Ipv6Net, U>, RkyvError>(v6)
.map_err(|_| Error::BadArchive(id))?;
Ok(Some(ProfileTrie {
v4: Some(v4),
v6: Some(v6),
}))
}
}