use crate::packet::ChunkParseError;
use crate::packet::SerializableTlv;
use crate::packet::ensure;
use crate::packet::parameter::RawParameter;
use crate::packet::parameter::write_parameter_header;
use std::fmt;
pub(crate) const CAUSE_CODE: u16 = 13;
#[derive(Debug)]
pub struct ProtocolViolationErrorCause {
pub(crate) information: String,
}
impl TryFrom<RawParameter<'_>> for ProtocolViolationErrorCause {
type Error = ChunkParseError;
fn try_from(raw: RawParameter<'_>) -> Result<Self, ChunkParseError> {
ensure!(raw.typ == CAUSE_CODE, ChunkParseError::InvalidType);
let information = String::from_utf8(raw.value.to_vec())
.unwrap_or_else(|_| "Failed to parse additional information".into());
Ok(Self { information })
}
}
impl SerializableTlv for ProtocolViolationErrorCause {
fn serialize_to(&self, output: &mut [u8]) {
let value = write_parameter_header(CAUSE_CODE, self.value_size(), output);
value.copy_from_slice(self.information.as_bytes());
}
fn value_size(&self) -> usize {
self.information.len()
}
}
impl fmt::Display for ProtocolViolationErrorCause {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "Protocol Violation, additional_information={}", self.information)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn serialize_and_deserialize() {
let cause = ProtocolViolationErrorCause { information: "abracadabra".into() };
let mut serialized = vec![0; cause.serialized_size()];
cause.serialize_to(&mut serialized);
let error =
ProtocolViolationErrorCause::try_from(RawParameter::from_bytes(&serialized).unwrap().0)
.unwrap();
assert_eq!(error.information, "abracadabra");
}
}