use alloc::string::String;
use alloc::vec::Vec;
use crate::error_registry::ErrCode;
use crate::field::{field_tlv, parse_field, FieldLevel};
use crate::path::path_to_tlv;
use crate::tlv_builders::{path as build_path, value_u64, value_u8, BuildError};
use crate::{type_code, Opt, Tlv};
pub mod fwd_op {
pub const READ: u8 = 0;
pub const WRITE: u8 = 1;
pub const AWAIT: u8 = 2;
pub const REPLY: u8 = 3;
pub const OPCODE_MASK: u8 = 0x3F;
pub const FLAG_MINT_REQUEST: u8 = 0x80;
}
pub mod fwd_kind {
pub const RESULT: u8 = 0;
pub const ERROR: u8 = 1;
}
pub fn fwd_error_code_for_path(path: &str) -> u16 {
ErrCode::from_path(path).map(ErrCode::code).unwrap_or(0)
}
pub fn fwd_error_path(code: u16) -> Option<&'static str> {
ErrCode::from_code(code).map(ErrCode::path)
}
pub enum FieldSel<'a> {
Str(&'a str),
Levels(Vec<FieldLevel>),
}
pub struct FwdRequest<'a> {
pub op: u8,
pub dst: &'a [&'a str],
pub src: &'a [&'a str],
pub field: Option<FieldSel<'a>>,
pub payload: Option<Tlv>,
pub kind: Option<u8>,
pub await_timeout_ns: Option<u64>,
}
impl<'a> FwdRequest<'a> {
pub fn new(op: u8, dst: &'a [&'a str], src: &'a [&'a str]) -> FwdRequest<'a> {
FwdRequest {
op,
dst,
src,
field: None,
payload: None,
kind: None,
await_timeout_ns: None,
}
}
}
fn field_node(sel: &FieldSel) -> Result<Tlv, BuildError> {
match sel {
FieldSel::Str(s) => field_tlv(&parse_field(s)?),
FieldSel::Levels(l) => field_tlv(l),
}
}
pub fn encode_fwd(req: &FwdRequest) -> Result<Tlv, BuildError> {
let mut children = alloc::vec![value_u8(req.op), build_path(req.dst)?];
if let Some(sel) = &req.field {
children.push(field_node(sel)?);
}
children.push(build_path(req.src)?);
if req.op == fwd_op::REPLY {
children.push(value_u8(req.kind.unwrap_or(fwd_kind::RESULT)));
if let Some(p) = &req.payload {
children.push(p.clone());
}
} else if req.op == fwd_op::WRITE {
if let Some(p) = &req.payload {
children.push(p.clone());
}
} else if req.op == fwd_op::AWAIT {
if let Some(ns) = req.await_timeout_ns {
children.push(value_u64(ns));
}
}
Ok(Tlv {
type_code: type_code::FWD,
opt: Opt::structured(),
payload: Vec::new(),
children,
trailer: None,
})
}
pub fn encode_fwd_bytes(req: &FwdRequest) -> Result<Vec<u8>, BuildError> {
let bytes = crate::encode(&encode_fwd(req)?);
if bytes.is_empty() {
return Err(BuildError::InvalidPathRef);
}
Ok(bytes)
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ParsedFwd {
pub op: u8,
pub dst: Tlv,
pub field: Option<Tlv>,
pub src: Tlv,
pub kind: Option<u8>,
pub payload: Option<Tlv>,
pub await_timeout_ns: Option<u64>,
pub mint_request: bool,
pub dst_bound: bool,
}
fn u8_of(t: &Tlv) -> u8 {
t.payload.first().copied().unwrap_or(0)
}
pub fn parse_fwd_tlv(fwd: &Tlv) -> Result<ParsedFwd, BuildError> {
if fwd.type_code != type_code::FWD {
return Err(BuildError::TypeMismatch);
}
let ch = &fwd.children;
let mut i = 0;
if ch.get(i).map(|c| c.type_code) != Some(type_code::VALUE) {
return Err(BuildError::TypeMismatch);
}
let op_byte = u8_of(&ch[i]);
let op = op_byte & fwd_op::OPCODE_MASK;
let mint_request = op_byte & fwd_op::FLAG_MINT_REQUEST != 0;
i += 1;
let dst_bound = ch.get(i).map(|c| c.type_code) == Some(type_code::PATH_REF);
if !dst_bound && ch.get(i).map(|c| c.type_code) != Some(type_code::PATH) {
return Err(BuildError::TypeMismatch);
}
let dst = ch[i].clone();
i += 1;
let mut field = None;
if ch.get(i).map(|c| c.type_code) == Some(type_code::FIELD) {
field = Some(ch[i].clone());
i += 1;
}
let src_kind = ch.get(i).map(|c| c.type_code);
if src_kind != Some(type_code::PATH) && src_kind != Some(type_code::PATH_REF) {
return Err(BuildError::TypeMismatch);
}
let src = ch[i].clone();
i += 1;
let mut kind = None;
let mut payload = None;
let mut await_timeout_ns = None;
if op == fwd_op::REPLY {
if ch.get(i).map(|c| c.type_code) == Some(type_code::VALUE) {
kind = Some(u8_of(&ch[i]));
i += 1;
}
if i < ch.len() {
payload = Some(ch[i].clone());
}
} else if op == fwd_op::WRITE {
if i < ch.len() {
payload = Some(ch[i].clone());
}
} else if op == fwd_op::AWAIT {
if let Some(c) = ch.get(i) {
if c.type_code == type_code::VALUE && c.payload.len() >= 8 {
await_timeout_ns = Some(c.payload_uint());
}
}
}
Ok(ParsedFwd {
op,
dst,
field,
src,
kind,
payload,
await_timeout_ns,
mint_request,
dst_bound,
})
}
pub fn decode_fwd(bytes: &[u8]) -> Result<ParsedFwd, BuildError> {
let tlv = crate::decode(bytes).map_err(|_| BuildError::TypeMismatch)?;
parse_fwd_tlv(&tlv)
}
pub fn fwd_dst_path(fwd: &ParsedFwd) -> Result<String, BuildError> {
crate::path::tlv_to_path(&fwd.dst)
}
pub fn fwd_src_path(fwd: &ParsedFwd) -> Result<String, BuildError> {
crate::path::tlv_to_path(&fwd.src)
}
fn reply_error_tlv(reply: &ParsedFwd) -> Option<&Tlv> {
let status = reply.payload.as_ref()?;
if status.type_code == type_code::STATUS {
return status.first_child(type_code::ERROR);
}
None
}
pub fn reply_error_code(reply: &ParsedFwd) -> u16 {
if let Some(err) = reply_error_tlv(reply) {
if let Some(id) = err.children.first() {
if id.type_code == type_code::VALUE && id.payload.len() >= 2 {
return id.payload[0] as u16 | ((id.payload[1] as u16) << 8);
}
}
}
0
}
pub fn reply_error_path(reply: &ParsedFwd) -> Result<Option<String>, BuildError> {
if let Some(err) = reply_error_tlv(reply) {
if let Some(id) = err.children.first() {
if id.type_code == type_code::NAME {
return Ok(Some(id.payload_str()?.into()));
}
}
}
Ok(None)
}
pub fn path_tlv_from_str(text: &str) -> Result<Tlv, BuildError> {
path_to_tlv(text)
}