pub mod attrs;
use serde::{Deserialize, Serialize};
use std::fmt;
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
pub enum CosemDataType {
Null,
Array(Vec<CosemDataType>),
Structure(Vec<CosemDataType>),
Boolean(bool),
Integer(i8),
Long(i16),
Unsigned(u8),
LongUnsigned(u16),
DoubleLong(i32),
DoubleLongUnsigned(u32),
OctetString(Vec<u8>),
DateTime(Vec<u8>),
BitString(Vec<u8>),
Enum(u8),
}
#[derive(Debug, PartialEq)]
pub enum BerError {
InvalidTag,
InvalidLength,
InvalidValue,
}
impl CosemDataType {
pub fn serialize_ber(&self, buf: &mut Vec<u8>) -> Result<(), BerError> {
match self {
CosemDataType::Null => {
buf.push(0x00); Ok(())
}
CosemDataType::Array(items) => {
buf.push(0x01); write_length(items.len(), buf); for item in items {
item.serialize_ber(buf)?;
}
Ok(())
}
CosemDataType::Structure(items) => {
buf.push(0x02); write_length(items.len(), buf); for item in items {
item.serialize_ber(buf)?;
}
Ok(())
}
CosemDataType::Boolean(b) => {
buf.push(0x03); buf.push(if *b { 0x01 } else { 0x00 });
Ok(())
}
CosemDataType::Integer(i) => {
buf.push(0x0F); #[allow(clippy::cast_sign_loss)]
buf.push(*i as u8);
Ok(())
}
CosemDataType::Long(i) => {
buf.push(0x10); buf.extend_from_slice(&i.to_be_bytes());
Ok(())
}
CosemDataType::Unsigned(u) => {
buf.push(0x11); buf.push(*u);
Ok(())
}
CosemDataType::LongUnsigned(u) => {
buf.push(0x12); buf.extend_from_slice(&u.to_be_bytes());
Ok(())
}
CosemDataType::DoubleLong(i) => {
buf.push(0x05); buf.extend_from_slice(&i.to_be_bytes());
Ok(())
}
CosemDataType::DoubleLongUnsigned(u) => {
buf.push(0x06); buf.extend_from_slice(&u.to_be_bytes());
Ok(())
}
CosemDataType::OctetString(s) => {
buf.push(0x09); write_length(s.len(), buf);
buf.extend_from_slice(s);
Ok(())
}
CosemDataType::DateTime(dt) => {
buf.push(0x19); write_length(dt.len(), buf);
buf.extend_from_slice(dt);
Ok(())
}
CosemDataType::BitString(s) => {
buf.push(0x04); write_length(s.len(), buf);
buf.extend_from_slice(s);
Ok(())
}
CosemDataType::Enum(e) => {
buf.push(0x16); buf.push(*e);
Ok(())
}
}
}
pub fn deserialize_ber(data: &[u8]) -> Result<(Self, &[u8]), BerError> {
if data.is_empty() {
return Err(BerError::InvalidTag);
}
match data[0] {
0x00 => Ok((CosemDataType::Null, &data[1..])),
0x01 => {
let (count, mut rest) = read_length(&data[1..])?;
let mut items = Vec::with_capacity(count);
for _ in 0..count {
let (item, next) = CosemDataType::deserialize_ber(rest)?;
items.push(item);
rest = next;
}
Ok((CosemDataType::Array(items), rest))
}
0x02 => {
let (count, mut rest) = read_length(&data[1..])?;
let mut items = Vec::with_capacity(count);
for _ in 0..count {
let (item, next) = CosemDataType::deserialize_ber(rest)?;
items.push(item);
rest = next;
}
Ok((CosemDataType::Structure(items), rest))
}
0x03 => {
if data.len() >= 2 {
Ok((CosemDataType::Boolean(data[1] != 0), &data[2..]))
} else {
Err(BerError::InvalidLength)
}
}
0x0F => {
if data.len() >= 2 {
#[allow(clippy::cast_possible_wrap)]
let value = data[1] as i8;
Ok((CosemDataType::Integer(value), &data[2..]))
} else {
Err(BerError::InvalidLength)
}
}
0x10 => {
if data.len() >= 3 {
let value = i16::from_be_bytes([data[1], data[2]]);
Ok((CosemDataType::Long(value), &data[3..]))
} else {
Err(BerError::InvalidLength)
}
}
0x11 => {
if data.len() >= 2 {
Ok((CosemDataType::Unsigned(data[1]), &data[2..]))
} else {
Err(BerError::InvalidLength)
}
}
0x12 => {
if data.len() >= 3 {
let value = u16::from_be_bytes([data[1], data[2]]);
Ok((CosemDataType::LongUnsigned(value), &data[3..]))
} else {
Err(BerError::InvalidLength)
}
}
0x05 => {
if data.len() >= 5 {
let value = i32::from_be_bytes([data[1], data[2], data[3], data[4]]);
Ok((CosemDataType::DoubleLong(value), &data[5..]))
} else {
Err(BerError::InvalidLength)
}
}
0x06 => {
if data.len() >= 5 {
let value = u32::from_be_bytes([data[1], data[2], data[3], data[4]]);
Ok((CosemDataType::DoubleLongUnsigned(value), &data[5..]))
} else {
Err(BerError::InvalidLength)
}
}
0x09 => {
let (len, rest) = read_length(&data[1..])?;
if rest.len() >= len {
Ok((CosemDataType::OctetString(rest[..len].to_vec()), &rest[len..]))
} else {
Err(BerError::InvalidLength)
}
}
0x19 => {
let (len, rest) = read_length(&data[1..])?;
if rest.len() >= len {
Ok((CosemDataType::DateTime(rest[..len].to_vec()), &rest[len..]))
} else {
Err(BerError::InvalidLength)
}
}
0x04 => {
let (len, rest) = read_length(&data[1..])?;
if rest.len() >= len {
Ok((CosemDataType::BitString(rest[..len].to_vec()), &rest[len..]))
} else {
Err(BerError::InvalidLength)
}
}
0x16 => {
if data.len() >= 2 {
Ok((CosemDataType::Enum(data[1]), &data[2..]))
} else {
Err(BerError::InvalidLength)
}
}
_ => Err(BerError::InvalidTag),
}
}
}
#[allow(clippy::cast_possible_truncation)] fn write_length(length: usize, buf: &mut Vec<u8>) {
if length < 128 {
buf.push(length as u8);
} else {
let bytes = (length as u64).to_be_bytes();
let first_non_zero = bytes.iter().position(|&b| b != 0).unwrap_or(7);
let num_octets = 8 - first_non_zero;
buf.push(0x80 | num_octets as u8);
buf.extend_from_slice(&bytes[first_non_zero..]);
}
}
fn read_length(data: &[u8]) -> Result<(usize, &[u8]), BerError> {
if data.is_empty() {
return Err(BerError::InvalidLength);
}
if data[0] & 0x80 == 0 {
Ok((data[0] as usize, &data[1..]))
} else {
let num_octets = (data[0] & 0x7F) as usize;
if num_octets == 0 || num_octets > 4 || data.len() < num_octets + 1 {
return Err(BerError::InvalidLength);
}
let mut len: usize = 0;
for &b in &data[1..=num_octets] {
len = (len << 8) + b as usize;
}
let rest = &data[num_octets + 1..];
if len > rest.len() {
return Err(BerError::InvalidLength);
}
Ok((len, rest))
}
}
impl fmt::Display for CosemDataType {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
CosemDataType::Null => write!(f, "Null"),
CosemDataType::Array(items) => {
write!(f, "Array([")?;
for (i, item) in items.iter().enumerate() {
if i > 0 {
write!(f, ", ")?;
}
write!(f, "{item}")?;
}
write!(f, "])")
}
CosemDataType::Structure(items) => {
write!(f, "Structure([")?;
for (i, item) in items.iter().enumerate() {
if i > 0 {
write!(f, ", ")?;
}
write!(f, "{item}")?;
}
write!(f, "])")
}
CosemDataType::Boolean(b) => write!(f, "Boolean({b})"),
CosemDataType::Integer(i) => write!(f, "Integer({i})"),
CosemDataType::Long(i) => write!(f, "Long({i})"),
CosemDataType::Unsigned(u) => write!(f, "Unsigned({u})"),
CosemDataType::LongUnsigned(u) => write!(f, "LongUnsigned({u})"),
CosemDataType::DoubleLong(i) => write!(f, "DoubleLong({i})"),
CosemDataType::DoubleLongUnsigned(u) => write!(f, "DoubleLongUnsigned({u})"),
CosemDataType::OctetString(s) => write!(f, "OctetString({s:?})"),
CosemDataType::DateTime(dt) => write!(f, "DateTime({dt:?})"),
CosemDataType::BitString(s) => write!(f, "BitString({s:?})"),
CosemDataType::Enum(e) => write!(f, "Enum({e})"),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
fn enc(v: &CosemDataType) -> Vec<u8> {
let mut buf = Vec::new();
v.serialize_ber(&mut buf).unwrap();
buf
}
#[test]
fn crafted_ber_length_is_rejected() {
let crafted = [0x09, 0x89, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF];
assert!(CosemDataType::deserialize_ber(&crafted).is_err());
let oversized = [0x09, 0x84, 0xFF, 0xFF, 0xFF, 0xFF];
assert!(CosemDataType::deserialize_ber(&oversized).is_err());
}
#[test]
fn axdr_reference_context_name() {
let s = CosemDataType::Structure(vec![
CosemDataType::Unsigned(2),
CosemDataType::Unsigned(16),
CosemDataType::LongUnsigned(756),
CosemDataType::Unsigned(5),
CosemDataType::Unsigned(8),
CosemDataType::Unsigned(1),
CosemDataType::Unsigned(1),
]);
assert_eq!(
enc(&s),
vec![0x02, 0x07, 0x11, 0x02, 0x11, 0x10, 0x12, 0x02, 0xF4, 0x11, 0x05, 0x11, 0x08, 0x11, 0x01, 0x11, 0x01]
);
}
#[test]
fn axdr_scalar_tags() {
assert_eq!(enc(&CosemDataType::Null), vec![0x00]);
assert_eq!(enc(&CosemDataType::Boolean(true)), vec![0x03, 0x01]);
assert_eq!(enc(&CosemDataType::Integer(-1)), vec![0x0F, 0xFF]);
assert_eq!(enc(&CosemDataType::Long(-2)), vec![0x10, 0xFF, 0xFE]);
assert_eq!(enc(&CosemDataType::DoubleLong(1)), vec![0x05, 0x00, 0x00, 0x00, 0x01]);
assert_eq!(enc(&CosemDataType::DoubleLongUnsigned(1)), vec![0x06, 0x00, 0x00, 0x00, 0x01]);
assert_eq!(enc(&CosemDataType::Unsigned(5)), vec![0x11, 0x05]);
assert_eq!(enc(&CosemDataType::LongUnsigned(756)), vec![0x12, 0x02, 0xF4]);
assert_eq!(enc(&CosemDataType::Enum(3)), vec![0x16, 0x03]);
assert_eq!(enc(&CosemDataType::OctetString(vec![0xAB, 0xCD])), vec![0x09, 0x02, 0xAB, 0xCD]);
assert_eq!(enc(&CosemDataType::Array(vec![CosemDataType::Unsigned(1)])), vec![0x01, 0x01, 0x11, 0x01]);
}
#[test]
fn axdr_round_trip() {
let samples = vec![
CosemDataType::Null,
CosemDataType::Boolean(false),
CosemDataType::Integer(-128),
CosemDataType::Long(-32768),
CosemDataType::Unsigned(255),
CosemDataType::LongUnsigned(65535),
CosemDataType::DoubleLong(-1),
CosemDataType::DoubleLongUnsigned(4_000_000_000),
CosemDataType::Enum(7),
CosemDataType::OctetString(vec![1, 2, 3]),
CosemDataType::DateTime(vec![0x07, 0xE5, 0x05, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]),
CosemDataType::Array(vec![CosemDataType::Unsigned(1), CosemDataType::Unsigned(2)]),
CosemDataType::Structure(vec![
CosemDataType::LongUnsigned(7),
CosemDataType::OctetString(vec![0, 0, 96, 1, 0, 255]),
CosemDataType::Array(vec![CosemDataType::Enum(1)]),
]),
];
for s in samples {
let bytes = enc(&s);
let (decoded, rest) = CosemDataType::deserialize_ber(&bytes).unwrap();
assert!(rest.is_empty(), "trailing bytes for {s:?}");
assert_eq!(decoded, s);
}
}
}