use alloc::string::{String, ToString};
use alloc::vec::Vec;
use crate::path::tlv_to_path;
use crate::tlv_builders::{
name, subscriber, text_name, value, value_u16, value_u32, value_u64, value_u8, BuildError,
};
use crate::{type_code, Opt, Tlv};
fn named_value(key: &str, val: Tlv) -> Result<[Tlv; 2], BuildError> {
Ok([name(key)?, val])
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct NamedField {
pub key: String,
pub value: Tlv,
}
pub fn named_fields(tlv: &Tlv) -> Result<Vec<NamedField>, BuildError> {
let mut out = Vec::new();
let ch = &tlv.children;
let mut i = 0;
while i + 1 < ch.len() {
if ch[i].type_code != type_code::NAME {
break;
}
out.push(NamedField {
key: ch[i].payload_str()?.to_string(),
value: ch[i + 1].clone(),
});
i += 2;
}
Ok(out)
}
pub fn named_field(tlv: &Tlv, key: &str) -> Result<Option<Tlv>, BuildError> {
Ok(named_fields(tlv)?
.into_iter()
.rev()
.find(|f| f.key == key)
.map(|f| f.value))
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SettingValue<'a> {
Value(&'a [u8]),
Name(&'a str),
}
fn settings_of(children: Vec<Tlv>) -> Tlv {
Tlv {
type_code: type_code::SETTINGS,
opt: Opt::structured(),
payload: Vec::new(),
children,
trailer: None,
}
}
pub fn settings_typed(pairs: &[(&str, SettingValue<'_>)]) -> Result<Tlv, BuildError> {
let mut children = Vec::with_capacity(pairs.len() * 2);
for (key, val) in pairs {
let node = match val {
SettingValue::Value(bytes) => value(bytes),
SettingValue::Name(text) => text_name(text)?,
};
let [k, v] = named_value(key, node)?;
children.push(k);
children.push(v);
}
Ok(settings_of(children))
}
pub fn settings(pairs: &[(&str, &[u8])]) -> Result<Tlv, BuildError> {
let mut children = Vec::with_capacity(pairs.len() * 2);
for (key, val) in pairs {
let [k, v] = named_value(key, value(val))?;
children.push(k);
children.push(v);
}
Ok(settings_of(children))
}
pub fn settings_get(tlv: &Tlv, key: &str) -> Result<Option<Vec<u8>>, BuildError> {
if tlv.type_code != type_code::SETTINGS {
return Err(BuildError::TypeMismatch);
}
Ok(named_field(tlv, key)?.map(|v| v.payload))
}
pub fn settings_str(tlv: &Tlv, key: &str) -> Result<Option<String>, BuildError> {
if tlv.type_code != type_code::SETTINGS {
return Err(BuildError::TypeMismatch);
}
for f in named_fields(tlv)?.into_iter().rev() {
if f.key == key && f.value.type_code == type_code::NAME {
return Ok(Some(f.value.payload_str()?.to_string()));
}
}
Ok(None)
}
pub fn subscriber_target(tlv: &Tlv) -> Result<Option<&Tlv>, BuildError> {
if tlv.type_code != type_code::SUBSCRIBER {
return Err(BuildError::TypeMismatch);
}
Ok(tlv.first_child(type_code::PATH))
}
pub fn subscriber_target_path(tlv: &Tlv) -> Result<Option<String>, BuildError> {
match subscriber_target(tlv)? {
Some(p) => Ok(Some(tlv_to_path(p)?)),
None => Ok(None),
}
}
pub const DELIVERY_POLICY_KEY: &str = "delivery_policy";
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub struct DeliveryPolicy {
pub bits: u16,
}
impl DeliveryPolicy {
pub const DURABILITY_REQUEST: u16 = 0x0020;
#[must_use]
pub const fn from_bits(bits: u16) -> Self {
Self { bits }
}
#[must_use]
pub const fn reliability(self) -> u8 {
(self.bits & 0x0003) as u8
}
#[must_use]
pub const fn priority(self) -> u8 {
((self.bits >> 2) & 0x0007) as u8
}
#[must_use]
pub const fn durability_request(self) -> bool {
(self.bits & Self::DURABILITY_REQUEST) != 0
}
#[must_use]
pub const fn delivery_class(self) -> u8 {
((self.bits >> 6) & 0x0003) as u8
}
#[must_use]
pub const fn reserved(self) -> u16 {
self.bits >> 8
}
#[must_use]
pub const fn is_default(self) -> bool {
self.bits == 0
}
}
pub fn subscriber_policy(tlv: &Tlv) -> Result<DeliveryPolicy, BuildError> {
if tlv.type_code != type_code::SUBSCRIBER {
return Err(BuildError::TypeMismatch);
}
let mut policy = DeliveryPolicy::default();
for child in tlv.children_of_type(type_code::SETTINGS) {
for f in named_fields(child)? {
if f.key != DELIVERY_POLICY_KEY {
continue;
}
if f.value.type_code != type_code::VALUE || f.value.payload.len() != 2 {
continue;
}
policy = DeliveryPolicy::from_bits(u16::from_le_bytes([
f.value.payload[0],
f.value.payload[1],
]));
}
}
Ok(policy)
}
pub fn subscriber_with_policy(
target_path: &[&str],
policy: DeliveryPolicy,
) -> Result<Tlv, BuildError> {
let mut tlv = subscriber(target_path)?;
if !policy.is_default() {
tlv.children.push(Tlv {
type_code: type_code::SETTINGS,
opt: Opt::structured(),
payload: Vec::new(),
children: alloc::vec![name(DELIVERY_POLICY_KEY)?, value_u16(policy.bits)],
trailer: None,
});
}
Ok(tlv)
}
pub fn point(
vertex_name: &str,
own_value: Option<&[u8]>,
extra: &[Tlv],
) -> Result<Tlv, BuildError> {
let mut children = Vec::new();
children.push(name(vertex_name)?);
if let Some(v) = own_value {
children.push(value(v));
}
children.extend_from_slice(extra);
Ok(Tlv {
type_code: type_code::POINT,
opt: Opt::structured(),
payload: Vec::new(),
children,
trailer: None,
})
}
pub fn point_name(tlv: &Tlv) -> Result<Option<String>, BuildError> {
if tlv.type_code != type_code::POINT {
return Err(BuildError::TypeMismatch);
}
match tlv.first_child(type_code::NAME) {
Some(n) => Ok(Some(n.payload_str()?.to_string())),
None => Ok(None),
}
}
pub fn point_value(tlv: &Tlv) -> Result<Option<Vec<u8>>, BuildError> {
if tlv.type_code != type_code::POINT {
return Err(BuildError::TypeMismatch);
}
Ok(tlv.first_child(type_code::VALUE).map(|v| v.payload.clone()))
}
pub fn point_children(tlv: &Tlv) -> Result<Vec<&Tlv>, BuildError> {
if tlv.type_code != type_code::POINT {
return Err(BuildError::TypeMismatch);
}
Ok(tlv.children_of_type(type_code::POINT).collect())
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Ace {
pub ace_type: u8,
pub flags: u8,
pub subject: Vec<u8>,
pub access_mask: u32,
pub expires_ns: Option<u64>,
}
impl Ace {
fn to_tlv(&self) -> Tlv {
let mut children = Vec::new();
push_named(&mut children, "type", value_u8(self.ace_type));
push_named(&mut children, "flags", value_u8(self.flags));
push_named(&mut children, "subject", value(&self.subject));
push_named(&mut children, "access_mask", value_u32(self.access_mask));
if let Some(exp) = self.expires_ns {
push_named(&mut children, "expires_ns", value_u64(exp));
}
Tlv {
type_code: type_code::ACL,
opt: Opt::structured(),
payload: Vec::new(),
children,
trailer: None,
}
}
}
fn push_named(children: &mut Vec<Tlv>, key: &str, val: Tlv) {
children.push(name(key).expect("ACE field key is a valid segment"));
children.push(val);
}
pub fn acl(aces: &[Ace]) -> Tlv {
Tlv {
type_code: type_code::ACL,
opt: Opt::structured(),
payload: Vec::new(),
children: aces.iter().map(Ace::to_tlv).collect(),
trailer: None,
}
}
pub fn acl_aces(tlv: &Tlv) -> Result<Vec<Ace>, BuildError> {
if tlv.type_code != type_code::ACL {
return Err(BuildError::TypeMismatch);
}
let mut out = Vec::new();
for inner in tlv.children_of_type(type_code::ACL) {
let ch = &inner.children;
if ch.len() % 2 != 0 {
return Err(BuildError::TypeMismatch);
}
let mut ace_type: Option<u8> = None;
let mut flags: Option<u8> = None;
let mut subject: Option<Vec<u8>> = None;
let mut access_mask: Option<u32> = None;
let mut expires_ns: Option<u64> = None;
let mut i = 0;
while i + 1 < ch.len() {
if ch[i].type_code != type_code::NAME {
return Err(BuildError::TypeMismatch);
}
let val = &ch[i + 1];
match ch[i].payload_str()? {
"type" => {
if ace_type.is_some() || val.type_code != type_code::VALUE {
return Err(BuildError::TypeMismatch);
}
ace_type = Some(val.payload_uint() as u8);
}
"flags" => {
if flags.is_some() || val.type_code != type_code::VALUE {
return Err(BuildError::TypeMismatch);
}
flags = Some(val.payload_uint() as u8);
}
"subject" => {
if subject.is_some() || val.payload.is_empty() {
return Err(BuildError::TypeMismatch);
}
subject = Some(val.payload.clone());
}
"access_mask" => {
if access_mask.is_some() || val.type_code != type_code::VALUE {
return Err(BuildError::TypeMismatch);
}
let mask = val.payload_uint();
if mask & !0x03 != 0 {
return Err(BuildError::TypeMismatch);
}
access_mask = Some(mask as u32);
}
"expires_ns" => {
if expires_ns.is_some() || val.type_code != type_code::VALUE {
return Err(BuildError::TypeMismatch);
}
expires_ns = Some(val.payload_uint());
}
_ => return Err(BuildError::TypeMismatch),
}
i += 2;
}
let (Some(ace_type), Some(subject), Some(access_mask)) = (ace_type, subject, access_mask)
else {
return Err(BuildError::TypeMismatch);
};
out.push(Ace {
ace_type,
flags: flags.unwrap_or(0),
subject,
access_mask,
expires_ns,
});
}
Ok(out)
}
pub fn spec(type_sel: &str, child_name: &str, config: Option<Tlv>) -> Result<Tlv, BuildError> {
let mut children = Vec::new();
let [k1, v1] = named_value("type", text_name(type_sel)?)?;
children.push(k1);
children.push(v1);
let [k2, v2] = named_value("name", name(child_name)?)?;
children.push(k2);
children.push(v2);
if let Some(cfg) = config {
children.push(name("config")?);
children.push(cfg);
}
Ok(Tlv {
type_code: type_code::SPEC,
opt: Opt::structured(),
payload: Vec::new(),
children,
trailer: None,
})
}
pub fn spec_type_name(tlv: &Tlv) -> Result<(Option<String>, Option<String>), BuildError> {
if tlv.type_code != type_code::SPEC {
return Err(BuildError::TypeMismatch);
}
let named_str = |key: &str| -> Result<Option<String>, BuildError> {
for f in named_fields(tlv)?.into_iter().rev() {
if f.key == key && f.value.type_code == type_code::NAME {
return Ok(Some(f.value.payload_str()?.to_string()));
}
}
Ok(None)
};
Ok((named_str("type")?, named_str("name")?))
}