1pub mod attrs;
2
3use serde::{Deserialize, Serialize};
4use std::fmt;
5
6#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
10pub enum CosemDataType {
11 Null,
13 Array(Vec<CosemDataType>),
15 Structure(Vec<CosemDataType>),
17 Boolean(bool),
19 Integer(i8),
21 Long(i16),
23 Unsigned(u8),
25 LongUnsigned(u16),
27 DoubleLong(i32),
29 DoubleLongUnsigned(u32),
31 OctetString(Vec<u8>),
33 DateTime(Vec<u8>),
35 BitString(Vec<u8>),
37 Enum(u8),
39}
40
41#[derive(Debug, PartialEq)]
43pub enum BerError {
44 InvalidTag,
46 InvalidLength,
48 InvalidValue,
50}
51
52impl CosemDataType {
53 pub fn serialize_ber(&self, buf: &mut Vec<u8>) -> Result<(), BerError> {
55 match self {
60 CosemDataType::Null => {
61 buf.push(0x00); Ok(())
63 }
64 CosemDataType::Array(items) => {
65 buf.push(0x01); write_length(items.len(), buf); for item in items {
68 item.serialize_ber(buf)?;
69 }
70 Ok(())
71 }
72 CosemDataType::Structure(items) => {
73 buf.push(0x02); write_length(items.len(), buf); for item in items {
76 item.serialize_ber(buf)?;
77 }
78 Ok(())
79 }
80 CosemDataType::Boolean(b) => {
81 buf.push(0x03); buf.push(if *b { 0x01 } else { 0x00 });
83 Ok(())
84 }
85 CosemDataType::Integer(i) => {
86 buf.push(0x0F); #[allow(clippy::cast_sign_loss)]
89 buf.push(*i as u8);
90 Ok(())
91 }
92 CosemDataType::Long(i) => {
93 buf.push(0x10); buf.extend_from_slice(&i.to_be_bytes());
95 Ok(())
96 }
97 CosemDataType::Unsigned(u) => {
98 buf.push(0x11); buf.push(*u);
100 Ok(())
101 }
102 CosemDataType::LongUnsigned(u) => {
103 buf.push(0x12); buf.extend_from_slice(&u.to_be_bytes());
105 Ok(())
106 }
107 CosemDataType::DoubleLong(i) => {
108 buf.push(0x05); buf.extend_from_slice(&i.to_be_bytes());
110 Ok(())
111 }
112 CosemDataType::DoubleLongUnsigned(u) => {
113 buf.push(0x06); buf.extend_from_slice(&u.to_be_bytes());
115 Ok(())
116 }
117 CosemDataType::OctetString(s) => {
118 buf.push(0x09); write_length(s.len(), buf);
120 buf.extend_from_slice(s);
121 Ok(())
122 }
123 CosemDataType::DateTime(dt) => {
124 buf.push(0x19); write_length(dt.len(), buf);
126 buf.extend_from_slice(dt);
127 Ok(())
128 }
129 CosemDataType::BitString(s) => {
130 buf.push(0x04); write_length(s.len(), buf);
134 buf.extend_from_slice(s);
135 Ok(())
136 }
137 CosemDataType::Enum(e) => {
138 buf.push(0x16); buf.push(*e);
140 Ok(())
141 }
142 }
143 }
144
145 pub fn deserialize_ber(data: &[u8]) -> Result<(Self, &[u8]), BerError> {
148 if data.is_empty() {
149 return Err(BerError::InvalidTag);
150 }
151 match data[0] {
152 0x00 => Ok((CosemDataType::Null, &data[1..])),
153 0x01 => {
154 let (count, mut rest) = read_length(&data[1..])?;
155 let mut items = Vec::with_capacity(count);
156 for _ in 0..count {
157 let (item, next) = CosemDataType::deserialize_ber(rest)?;
158 items.push(item);
159 rest = next;
160 }
161 Ok((CosemDataType::Array(items), rest))
162 }
163 0x02 => {
164 let (count, mut rest) = read_length(&data[1..])?;
165 let mut items = Vec::with_capacity(count);
166 for _ in 0..count {
167 let (item, next) = CosemDataType::deserialize_ber(rest)?;
168 items.push(item);
169 rest = next;
170 }
171 Ok((CosemDataType::Structure(items), rest))
172 }
173 0x03 => {
174 if data.len() >= 2 {
175 Ok((CosemDataType::Boolean(data[1] != 0), &data[2..]))
176 } else {
177 Err(BerError::InvalidLength)
178 }
179 }
180 0x0F => {
181 if data.len() >= 2 {
182 #[allow(clippy::cast_possible_wrap)]
184 let value = data[1] as i8;
185 Ok((CosemDataType::Integer(value), &data[2..]))
186 } else {
187 Err(BerError::InvalidLength)
188 }
189 }
190 0x10 => {
191 if data.len() >= 3 {
192 let value = i16::from_be_bytes([data[1], data[2]]);
193 Ok((CosemDataType::Long(value), &data[3..]))
194 } else {
195 Err(BerError::InvalidLength)
196 }
197 }
198 0x11 => {
199 if data.len() >= 2 {
200 Ok((CosemDataType::Unsigned(data[1]), &data[2..]))
201 } else {
202 Err(BerError::InvalidLength)
203 }
204 }
205 0x12 => {
206 if data.len() >= 3 {
207 let value = u16::from_be_bytes([data[1], data[2]]);
208 Ok((CosemDataType::LongUnsigned(value), &data[3..]))
209 } else {
210 Err(BerError::InvalidLength)
211 }
212 }
213 0x05 => {
214 if data.len() >= 5 {
215 let value = i32::from_be_bytes([data[1], data[2], data[3], data[4]]);
216 Ok((CosemDataType::DoubleLong(value), &data[5..]))
217 } else {
218 Err(BerError::InvalidLength)
219 }
220 }
221 0x06 => {
222 if data.len() >= 5 {
223 let value = u32::from_be_bytes([data[1], data[2], data[3], data[4]]);
224 Ok((CosemDataType::DoubleLongUnsigned(value), &data[5..]))
225 } else {
226 Err(BerError::InvalidLength)
227 }
228 }
229 0x09 => {
230 let (len, rest) = read_length(&data[1..])?;
231 if rest.len() >= len {
232 Ok((CosemDataType::OctetString(rest[..len].to_vec()), &rest[len..]))
233 } else {
234 Err(BerError::InvalidLength)
235 }
236 }
237 0x19 => {
238 let (len, rest) = read_length(&data[1..])?;
239 if rest.len() >= len {
240 Ok((CosemDataType::DateTime(rest[..len].to_vec()), &rest[len..]))
241 } else {
242 Err(BerError::InvalidLength)
243 }
244 }
245 0x04 => {
246 let (len, rest) = read_length(&data[1..])?;
247 if rest.len() >= len {
248 Ok((CosemDataType::BitString(rest[..len].to_vec()), &rest[len..]))
249 } else {
250 Err(BerError::InvalidLength)
251 }
252 }
253 0x16 => {
254 if data.len() >= 2 {
255 Ok((CosemDataType::Enum(data[1]), &data[2..]))
256 } else {
257 Err(BerError::InvalidLength)
258 }
259 }
260 _ => Err(BerError::InvalidTag),
261 }
262 }
263}
264
265#[allow(clippy::cast_possible_truncation)] fn write_length(length: usize, buf: &mut Vec<u8>) {
268 if length < 128 {
269 buf.push(length as u8);
270 } else {
271 let bytes = (length as u64).to_be_bytes();
272 let first_non_zero = bytes.iter().position(|&b| b != 0).unwrap_or(7);
273 let num_octets = 8 - first_non_zero;
274 buf.push(0x80 | num_octets as u8);
275 buf.extend_from_slice(&bytes[first_non_zero..]);
276 }
277}
278
279fn read_length(data: &[u8]) -> Result<(usize, &[u8]), BerError> {
280 if data.is_empty() {
281 return Err(BerError::InvalidLength);
282 }
283 if data[0] & 0x80 == 0 {
284 Ok((data[0] as usize, &data[1..]))
285 } else {
286 let num_octets = (data[0] & 0x7F) as usize;
287 if num_octets == 0 || num_octets > 4 || data.len() < num_octets + 1 {
290 return Err(BerError::InvalidLength);
291 }
292 let mut len: usize = 0;
293 for &b in &data[1..=num_octets] {
294 len = (len << 8) + b as usize;
295 }
296 let rest = &data[num_octets + 1..];
297 if len > rest.len() {
300 return Err(BerError::InvalidLength);
301 }
302 Ok((len, rest))
303 }
304}
305
306impl fmt::Display for CosemDataType {
307 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
308 match self {
309 CosemDataType::Null => write!(f, "Null"),
310 CosemDataType::Array(items) => {
311 write!(f, "Array([")?;
312 for (i, item) in items.iter().enumerate() {
313 if i > 0 {
314 write!(f, ", ")?;
315 }
316 write!(f, "{item}")?;
317 }
318 write!(f, "])")
319 }
320 CosemDataType::Structure(items) => {
321 write!(f, "Structure([")?;
322 for (i, item) in items.iter().enumerate() {
323 if i > 0 {
324 write!(f, ", ")?;
325 }
326 write!(f, "{item}")?;
327 }
328 write!(f, "])")
329 }
330 CosemDataType::Boolean(b) => write!(f, "Boolean({b})"),
331 CosemDataType::Integer(i) => write!(f, "Integer({i})"),
332 CosemDataType::Long(i) => write!(f, "Long({i})"),
333 CosemDataType::Unsigned(u) => write!(f, "Unsigned({u})"),
334 CosemDataType::LongUnsigned(u) => write!(f, "LongUnsigned({u})"),
335 CosemDataType::DoubleLong(i) => write!(f, "DoubleLong({i})"),
336 CosemDataType::DoubleLongUnsigned(u) => write!(f, "DoubleLongUnsigned({u})"),
337 CosemDataType::OctetString(s) => write!(f, "OctetString({s:?})"),
338 CosemDataType::DateTime(dt) => write!(f, "DateTime({dt:?})"),
339 CosemDataType::BitString(s) => write!(f, "BitString({s:?})"),
340 CosemDataType::Enum(e) => write!(f, "Enum({e})"),
341 }
342 }
343}
344
345#[cfg(test)]
346mod tests {
347 use super::*;
348
349 fn enc(v: &CosemDataType) -> Vec<u8> {
350 let mut buf = Vec::new();
351 v.serialize_ber(&mut buf).unwrap();
352 buf
353 }
354
355 #[test]
358 fn crafted_ber_length_is_rejected() {
359 let crafted = [0x09, 0x89, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF];
361 assert!(CosemDataType::deserialize_ber(&crafted).is_err());
362 let oversized = [0x09, 0x84, 0xFF, 0xFF, 0xFF, 0xFF];
364 assert!(CosemDataType::deserialize_ber(&oversized).is_err());
365 }
366
367 #[test]
370 fn axdr_reference_context_name() {
371 let s = CosemDataType::Structure(vec![
372 CosemDataType::Unsigned(2),
373 CosemDataType::Unsigned(16),
374 CosemDataType::LongUnsigned(756),
375 CosemDataType::Unsigned(5),
376 CosemDataType::Unsigned(8),
377 CosemDataType::Unsigned(1),
378 CosemDataType::Unsigned(1),
379 ]);
380 assert_eq!(
381 enc(&s),
382 vec![0x02, 0x07, 0x11, 0x02, 0x11, 0x10, 0x12, 0x02, 0xF4, 0x11, 0x05, 0x11, 0x08, 0x11, 0x01, 0x11, 0x01]
383 );
384 }
385
386 #[test]
388 fn axdr_scalar_tags() {
389 assert_eq!(enc(&CosemDataType::Null), vec![0x00]);
390 assert_eq!(enc(&CosemDataType::Boolean(true)), vec![0x03, 0x01]);
391 assert_eq!(enc(&CosemDataType::Integer(-1)), vec![0x0F, 0xFF]);
392 assert_eq!(enc(&CosemDataType::Long(-2)), vec![0x10, 0xFF, 0xFE]);
393 assert_eq!(enc(&CosemDataType::DoubleLong(1)), vec![0x05, 0x00, 0x00, 0x00, 0x01]);
394 assert_eq!(enc(&CosemDataType::DoubleLongUnsigned(1)), vec![0x06, 0x00, 0x00, 0x00, 0x01]);
395 assert_eq!(enc(&CosemDataType::Unsigned(5)), vec![0x11, 0x05]);
396 assert_eq!(enc(&CosemDataType::LongUnsigned(756)), vec![0x12, 0x02, 0xF4]);
397 assert_eq!(enc(&CosemDataType::Enum(3)), vec![0x16, 0x03]);
398 assert_eq!(enc(&CosemDataType::OctetString(vec![0xAB, 0xCD])), vec![0x09, 0x02, 0xAB, 0xCD]);
399 assert_eq!(enc(&CosemDataType::Array(vec![CosemDataType::Unsigned(1)])), vec![0x01, 0x01, 0x11, 0x01]);
400 }
401
402 #[test]
403 fn axdr_round_trip() {
404 let samples = vec![
405 CosemDataType::Null,
406 CosemDataType::Boolean(false),
407 CosemDataType::Integer(-128),
408 CosemDataType::Long(-32768),
409 CosemDataType::Unsigned(255),
410 CosemDataType::LongUnsigned(65535),
411 CosemDataType::DoubleLong(-1),
412 CosemDataType::DoubleLongUnsigned(4_000_000_000),
413 CosemDataType::Enum(7),
414 CosemDataType::OctetString(vec![1, 2, 3]),
415 CosemDataType::DateTime(vec![0x07, 0xE5, 0x05, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]),
416 CosemDataType::Array(vec![CosemDataType::Unsigned(1), CosemDataType::Unsigned(2)]),
417 CosemDataType::Structure(vec![
418 CosemDataType::LongUnsigned(7),
419 CosemDataType::OctetString(vec![0, 0, 96, 1, 0, 255]),
420 CosemDataType::Array(vec![CosemDataType::Enum(1)]),
421 ]),
422 ];
423 for s in samples {
424 let bytes = enc(&s);
425 let (decoded, rest) = CosemDataType::deserialize_ber(&bytes).unwrap();
426 assert!(rest.is_empty(), "trailing bytes for {s:?}");
427 assert_eq!(decoded, s);
428 }
429 }
430}