use alloc::string::{String, ToString};
use alloc::vec::Vec;
use crate::path::tlv_to_path;
use crate::tlv_builders::{name, value, value_u16, 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 < ch.len() {
if ch[i].type_code == type_code::NAME && i + 1 < ch.len() {
out.push(NamedField {
key: ch[i].payload_str()?.to_string(),
value: ch[i + 1].clone(),
});
i += 2;
continue;
}
i += 1;
}
Ok(out)
}
pub fn named_field(tlv: &Tlv, key: &str) -> Result<Option<Tlv>, BuildError> {
Ok(named_fields(tlv)?
.into_iter()
.find(|f| f.key == key)
.map(|f| f.value))
}
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(Tlv {
type_code: type_code::SETTINGS,
opt: Opt::structured(),
payload: Vec::new(),
children,
trailer: None,
})
}
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 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 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: u16,
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_u16(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 fields = named_fields(inner)?;
let get = |k: &str| fields.iter().find(|f| f.key == k).map(|f| &f.value);
let ace_type = get("type").ok_or(BuildError::TypeMismatch)?.payload_uint() as u8;
let flags = get("flags").map(|v| v.payload_uint() as u8).unwrap_or(0);
let subject = get("subject")
.ok_or(BuildError::TypeMismatch)?
.payload
.clone();
let access_mask = get("access_mask")
.ok_or(BuildError::TypeMismatch)?
.payload_uint() as u16;
let expires_ns = get("expires_ns").map(|v| v.payload_uint());
out.push(Ace {
ace_type,
flags,
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", value(type_sel.as_bytes()))?;
children.push(k1);
children.push(v1);
let [k2, v2] = named_value("name", value(child_name.as_bytes()))?;
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 type_sel = named_field(tlv, "type")?
.map(|v| v.payload_str().map(|s| s.to_string()))
.transpose()?;
let child_name = named_field(tlv, "name")?
.map(|v| v.payload_str().map(|s| s.to_string()))
.transpose()?;
Ok((type_sel, child_name))
}